重用令牌进行服务到服务的通信

Question

我正在尝试使用 OAuth（从现在开始称为消费者和提供者）保护两个服务之间的通信。

让我们假设消费者刚刚启动。现在多个 http 调用几乎同时到达它。消费者需要与提供者通信才能处理请求。我非常希望消费者为这种通信重用一个令牌（而不是为每个传入的请求获取一个新令牌）。首先，当令牌过期时，应该获取一个新令牌。

如何做到这一点？

   public class TokenProvider
   {
        private readonly HttpClient _httpClient;
        private Token _token;
        private object _lock = new object();

        public TokenProvider(HttpClient httpClient)
        {
            _httpClient = httpClient;
        }

        public async Task<string> GetTokenAsync()
        {
            if (_token != null && !_token.IsExpired())
            {
                return _token;
            }
            else
            {
                string oauthPostBody = string.Format(
                    "grant_type=client_credentials&client_id={0}&client_secret={1}", "fakeClientId", "fakeSecret");
                var tokenEndpoint = ...;
                var response = await _httpClient.PostAsync(tokenEndpoint.Uri, new StringContent(oauthPostBody));
                var responseContent = await response.Content.ReadAsStringAsync();
                var jsonResponse = JsonConvert.DeserializeObject<dynamic>(responseContent);

                lock (_lock)
                {
                    if (_token == null || _token.IsExpired())
                    {
                        string expiresIn = jsonResponse.expires_in;
                        _token = new Token(jsonResponse.access_token, int.Parse(expiresIn));
                    }
                    return _token;
                }
            }
        }

        private class Token
        {
            private readonly string _token;
            private readonly DateTime _expirationDateTime;

            public Token(string token, int expiresIn)
            {
                _token = token;
                _expirationDateTime = DateTime.UtcNow.AddSeconds(expiresIn);
            }

            public bool IsExpired()
            {
                return DateTime.UtcNow > _expirationDateTime;
            }

            public static implicit operator string(Token token)
            {
                return token._token;
            }
        }
    }

但是，我怀疑上述方法是否可行。这种怀疑是基于编译器优化等。请参阅 Eric Lippert 的 this post。

我正在尝试让多个线程同时读取令牌，但只能由单个线程更新。我也研究了 ReaderWriterLockSlim，但这似乎无助于解决我的问题。 （请注意，由于我在 GetTokenAsync 中有一个异步调用，因此它变得更加复杂。）

更新 根据@EricLippert 的评论，我更新了代码：

public class TokenProvider
{
    private readonly HttpClient _httpClient;
    private readonly IApplicationConfig _config;
    private Token _token;
    private AsyncReaderWriterLock _lock = new AsyncReaderWriterLock();

    public TokenProvider(HttpClient httpClient, IApplicationConfig config)
    {
        _httpClient = httpClient;
        _config = config;
    }

    public bool TryGetExistingToken(out string token)
    {
        using (_lock.ReaderLock())
        {
            if (_token != null)
            {
                token = _token;
                return true;
            }
            else
            {
                token = null;
                return false;
            }
        }
    }

    public async Task<string> GetNewTokenAsync()
    {
        using (await _lock.WriterLockAsync())
        {
            if (_token != null && !_token.IsExpired())
            {
                return _token;
            }
            else
            {
                var clientId = _config.Get<string>("oauth.clientId");
                var secret = _config.Get<string>("oauth.sharedSecret");
                string oauthPostBody = string.Format(
                    "grant_type=client_credentials&client_id={0}&client_secret={1}", clientId, secret);
                var queueEndpoint = _config.GetUri("recommendationQueue.host");
                var tokenPath = _config.Get<string>("recommendationQueue.path.token");
                var tokenEndpoint = new UriBuilder(queueEndpoint) {Path = tokenPath};
                var response = await _httpClient.PostAsync(tokenEndpoint.Uri, new StringContent(oauthPostBody));
                var responseContent = await response.Content.ReadAsStringAsync();
                var jsonResponse = JsonConvert.DeserializeObject<dynamic>(responseContent);

                if (_token == null || _token.IsExpired())
                {
                    string expiresIn = jsonResponse.expires_in;
                    string accessToken = jsonResponse.access_token;
                    _token = new Token(accessToken, int.Parse(expiresIn));
                }
                return _token;
            }
        }
    }

    private class Token
    {
        private readonly string _token;
        private readonly DateTime _expirationDateTime;

        public Token(string token, int expiresIn)
        {
            _token = token;
            _expirationDateTime = DateTime.UtcNow.AddSeconds(expiresIn);
        }

        public bool IsExpired()
        {
            return DateTime.UtcNow > _expirationDateTime;
        }

        public static implicit operator string(Token token)
        {
            return token._token;
        }
    }
}

我正在使用 Stephen Cleary 的 AsyncReaderWriterLock。 这是更好的方法吗？还是我只是把自己挖到了一个更大的坑里？

Answer 1

但是，我怀疑上述方法是否可行。这种怀疑是基于编译器优化等。请参阅 Eric Lippert 的这篇文章

我们不必假设奇异的编译器优化。首先，一个明显的问题是令牌是否过期变化：

• 静态变量中有未过期的令牌。
• 线程A检测到有未过期的token，进入if。
• 线程 A 挂起。
• 线程 B 运行的时间足够长，以至于令牌过期。
• 线程 A 恢复并返回一个过期的令牌。

就是这样。我们不保证返回的令牌是有效的。但情况远比这糟糕。我们甚至不能保证返回的令牌是当前令牌。

• 静态变量中有未过期的令牌。
• 线程A检测到有未过期的token，进入if。
• 线程 A 将未过期的令牌放入评估堆栈以供返回。
• 线程 A 挂起。
• 线程 B 运行的时间足够长，以至于令牌过期。
• 线程 C 运行，检测到令牌已过期，并将其替换为不同的令牌。
• 线程 A 恢复并返回一个过期的令牌，该令牌甚至不是变量的当前内容。

您在此处遇到了 TOCTOU 问题，无论您的双重检查锁定的实现是否存在任何问题。那就是 Time-Of-Check-is-not-Time-Of-Use。您对令牌的所有了解是它在过去的某个时间没有过期，但所有令牌都是如此。