public void CreateToken()
{
TokenClaim claim = CreateClaim();
TestPayload payload = CreatePayload();
CreateToken(claim, payload);
}
/// <summary>
/// <see cref="IAuthoritionTokenService.GetToken(IAuthoritionComponent)"/>
/// </summary>
public TokenClaim GetToken(IAuthoritionComponent component)
{
var feature = component.GetFeatureCode();
//Try to remove the read-write lock from cache
var locker = TokenCache.GetOrCreate(feature + "_locker", () => new ReaderWriterLockSlim(), null);
TokenClaim Claim = null;
do
{
Claim = locker.RetryReadWithLocker(
() => TokenCache.Get <TokenClaim>(feature), READ_WAIT_LIMIT, DefaultOptionManagement.MaximumNumberOfRetries);
//Return directly if the ticket exists
if (Claim != null && Claim.Expires.HasValue)
{
return(Claim);
}
} while (!locker.TryEnterWriteLock(10));
//Read and write cannot acquire the state normally in the case of asynchronous,
//so the process of acquiring the token is executed in a synchronous blocking manner.
Claim = Task.Run(() => GetClaimTryToCache(TokenCache, feature, component)).Result;
locker.ExitWriteLock();
return(Claim);
}
public void CreateToken_NullClaim()
{
TokenClaim claim = null;
TestPayload payload = CreatePayload();
CreateToken(claim, payload);
}
public async Task <TokenClaim> ApplyToken()
{
var content = new MultipartFormDataContent();
foreach (var item in AuthoritionTicket)
{
content.Add(new StringContent(item.Value), item.Key);
}
var response = await DependenceInjectService.GetService <IHttpClientFactory>().SendAsync(AuthorityServer, content);
var Claim = new TokenClaim {
Raw = await response.Content.ReadAsStringAsync()
};
var json = JObject.Parse(Claim.Raw);
Claim.Token = Credential.Invoke(json, CredentialKey);
var ExpireSecond = ExpireTime.Invoke(json, ExpireTimeKey);
if (ExpireSecond > 0)
{
Claim.Expires = DateTime.Now.AddSeconds(ExpireSecond);
}
return(Claim);
}
public void CreateToken_NullPayload()
{
TokenClaim claim = CreateClaim();
TestPayload payload = null;
claim.Expiration = DateTimeOffset.UtcNow.AddSeconds(-1);
CreateToken(claim, payload);
}
/// <summary>
///
/// </summary>
/// <param name="claim"></param>
/// <param name="payload"></param>
/// <returns></returns>
private ITokenPair GetToken(TokenClaim claim, TestPayload payload)
{
MsJwtProviderBase <TestPayload> provider = new TestMsJwtRS256Provider().CreateProvider();
TokenInfo accessToken = new TokenInfo(provider.CreateToken(claim, payload), claim.Expiration, claim.NotBefore);
claim.Expiration = DateTimeOffset.UtcNow.AddSeconds(TestConstants.RefreshTokenLifetimeSeconds);
TokenInfo refreshToken = new TokenInfo(provider.CreateToken(claim, payload), claim.Expiration, claim.NotBefore);
return(new TokenPair(accessToken, refreshToken));
}
public void CreateToken_NotBefore()
{
TokenClaim claim = TestMsJwtProviderBase.CreateClaim();
TestPayload payload = TestMsJwtProviderBase.CreatePayload();
claim.NotBefore = DateTimeOffset.UtcNow.AddSeconds(5);
string token = GetProvider().CreateToken(claim, payload);
MsJwtValidatorBase <TestPayload> validator = CreateValidator(TestConstants.Issuer, TestConstants.Audience);
Assert.IsFalse(validator.ValidateToken(token, out ITokenClaim tokenClaim, out TestPayload tokenPayload, out TokenState state, out string errorMessage));
Assert.AreEqual(state, TokenState.NotBefore);
}
public void CreateToken_NullPayload()
{
TokenClaim claim = TestMsJwtProviderBase.CreateClaim();
TestPayload payload = null;
string token = GetProvider().CreateToken(claim, payload);
MsJwtValidatorBase <TestPayload> validator = CreateValidator(TestConstants.Issuer, TestConstants.Audience);
Assert.IsTrue(validator.ValidateToken(token, out ITokenClaim tokenClaim, out TestPayload tokenPayload, out TokenState state, out string errorMessage));
Assert.IsTrue(ValueEquals(claim, tokenClaim));
Assert.IsNull(tokenPayload);
Assert.AreEqual(state, TokenState.Valid);
}
public async Task<TokenClaim> ApplyToken()
{
TimeSpan spend = DateTime.Now.ToUniversalTime() - new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
if (Mode == GAMode.RemoteAccess)
{
var response = await DependenceInjectService.GetService<IHttpClientFactory>().SendAsync(AuthorityServer, null, HttpMethod.Get);
var Claim = new TokenClaim();
Claim.Raw = Claim.Token = await response.Content.ReadAsStringAsync();
Claim.Expires = DateTime.Now.AddSeconds(spend.TotalSeconds % ExpireSecond);
return Claim;
}
else if (Mode == GAMode.Generation)
return GetCodeInternal(SecretKey, spend);
else
throw new NotSupportedException("The authentication component has not been initialized yet. Please set the server address or Secretkey.");
}
private TokenClaim GetCodeInternal(string secret, TimeSpan spend)
{
var Claim = new TokenClaim();
var Second = (ulong)ExpireSecond;
ulong chlg = (ulong)(spend.TotalSeconds / Second);
Claim.Expires = DateTime.Now.AddSeconds(spend.TotalSeconds % Second);
byte[] challenge = new byte[8];
for (int j = 7; j >= 0; j--)
{
challenge[j] = (byte)((int)chlg & 0xff);
chlg >>= 8;
}
var key = Base32ToBytes(secret);
for (int i = secret.Length; i < key.Length; i++)
{
key[i] = 0;
}
HMACSHA1 mac = new HMACSHA1(key);
var hash = mac.ComputeHash(challenge);
int offset = hash[hash.Length - 1] & 0xf;
int truncatedHash = 0;
for (int j = 0; j < 4; j++)
{
truncatedHash <<= 8;
truncatedHash |= hash[offset + j];
}
truncatedHash &= 0x7FFFFFFF;
truncatedHash %= 1000000;
string code = truncatedHash.ToString();
Claim.Raw = Claim.Token = code.PadLeft(6, '0');
return Claim;
}
/// <summary>
///
/// </summary>
private void CreateToken_InvalidAudience(bool validateAudience)
{
TokenClaim claim = TestMsJwtProviderBase.CreateClaim();
TestPayload payload = TestMsJwtProviderBase.CreatePayload();
string token = GetProvider().CreateToken(claim, payload);
MsJwtValidatorBase <TestPayload> validator = CreateValidator(TestConstants.Issuer, validateAudience ? "thisAudience" : null);
if (validateAudience)
{
Assert.IsFalse(validator.ValidateToken(token, out ITokenClaim tokenClaim, out TestPayload tokenPayload, out TokenState state, out string errorMessage));
Assert.AreEqual(state, TokenState.InvalidAudience);
}
else
{
Assert.IsTrue(validator.ValidateToken(token, out ITokenClaim tokenClaim, out TestPayload tokenPayload, out TokenState state, out string errorMessage));
Assert.AreEqual(state, TokenState.Valid);
}
}
/// <summary>
///
/// </summary>
/// <param name="secondsBefore"></param>
/// <returns></returns>
private TokenManager CreateRefresher(int secondsBefore)
{
return(new TokenManager(token =>
{
if (!m_Validator.ValidateToken(token, out ITokenClaim claim, out TestPayload payload, out TokenState state, out string errorMessage))
{
throw new ArgumentException(errorMessage);
}
TokenClaim newClaim = new TokenClaim()
{
JwtID = claim.JwtID,
Audience = claim.Audience,
Expiration = DateTimeOffset.UtcNow.AddSeconds(TestConstants.AccessTokenLifetimeSeconds),
};
return GetToken(newClaim, payload);
}
, secondsBefore
));
}
/// <summary>
///
/// </summary>
/// <param name="claim"></param>
/// <param name="payload"></param>
/// <returns></returns>
public string CreateToken(TokenClaim claim, TestPayload payload)
{
MsJwtProviderBase <TestPayload> provider = CreateProvider();
return(provider.CreateToken(claim, payload));
}
public void AuthorizeFormSetting(MultipartFormDataContent Content, TokenClaim Claim)
{
Content.Add(new StringContent(Claim.Token), "auth_token");
}
public void AuthorizeFormSetting(MultipartFormDataContent content, TokenClaim claim)
{
throw new NotImplementedException();
}
public void AuthorizeFormSetting(MultipartFormDataContent content, TokenClaim Token)
{
content.Add(new StringContent(Token.Token), "auth_token");
}
