public void SymmetricSignatureProvider_Publics()
{
SymmetricSignatureProvider provider = new SymmetricSignatureProvider(KeyingMaterial.DefaultSymmetricSecurityKey_256, KeyingMaterial.DefaultSymmetricSigningCreds_256_Sha2.Algorithm);
ExpectedException expectedException = ExpectedException.ArgumentOutOfRangeException("IDX10628:");
try
{
provider.MinimumSymmetricKeySizeInBits = SymmetricSignatureProvider.DefaultMinimumSymmetricKeySizeInBits - 10;
expectedException.ProcessNoException();
}
catch (Exception ex)
{
expectedException.ProcessException(ex);
}
}
public static ClaimsPrincipal ValidateToken(string securityToken, TokenValidationParameters validationParameters, ISecurityTokenValidator tokenValidator, ExpectedException expectedException)
{
ClaimsPrincipal retVal = null;
try
{
SecurityToken validatedToken;
retVal = tokenValidator.ValidateToken(securityToken, validationParameters, out validatedToken);
expectedException.ProcessNoException();
}
catch (Exception ex)
{
expectedException.ProcessException(ex);
}
return(retVal);
}
private void SymmetricSignatureProviders_Verify_Variation(SecurityKey key, string algorithm, byte[] rawBytes, byte[] signature, ExpectedException ee, List <string> errors, bool shouldSignatureSucceed)
{
try
{
SymmetricSignatureProvider provider = new SymmetricSignatureProvider(key, algorithm);
if (provider.Verify(rawBytes, signature) != shouldSignatureSucceed)
{
errors.Add("SignatureProvider.Verify did not return expected: " + shouldSignatureSucceed + " , algorithm: " + algorithm);
}
ee.ProcessNoException(errors);
}
catch (Exception ex)
{
ee.ProcessException(ex, errors);
}
}
#pragma warning restore CS3016 // Arrays as attribute arguments is not CLS-compliant
public void Constructors(string testId, SecurityKey key, string algorithm, ExpectedException ee)
{
try
{
var context = Guid.NewGuid().ToString();
var provider = CryptoProviderFactory.Default.CreateKeyWrapProvider(key, algorithm);
provider.Context = context;
ee.ProcessNoException();
Assert.Equal(provider.Algorithm, algorithm);
Assert.Equal(provider.Context, context);
Assert.True(ReferenceEquals(provider.Key, key));
}
catch (Exception ex)
{
ee.ProcessException(ex);
}
}
public void Constructors(string json, JsonWebKey compareTo, ExpectedException ee)
{
var context = new CompareContext();
try
{
var jsonWebKey = new JsonWebKey(json);
ee.ProcessNoException(context);
if (compareTo != null)
{
IdentityComparer.AreEqual(jsonWebKey, compareTo, context);
}
}
catch (Exception ex)
{
ee.ProcessException(ex, context.Diffs);
}
TestUtilities.AssertFailIfErrors(context);
}
#pragma warning restore CS3016 // Arrays as attribute arguments is not CLS-compliant
public void Constructors(string testId, SymmetricSecurityKey key, string algorithm, ExpectedException ee)
{
try
{
var context = Guid.NewGuid().ToString();
var provider = new AuthenticatedEncryptionProvider(key, algorithm)
{
Context = context
};
ee.ProcessNoException();
Assert.Equal(provider.Algorithm, algorithm);
Assert.Equal(provider.Context, context);
Assert.True(ReferenceEquals(provider.Key, key));
}
catch (Exception ex)
{
ee.ProcessException(ex);
}
}
private void FactoryCreateFor(string testcase, SecurityKey key, string algorithm, CryptoProviderFactory factory, ExpectedException expectedException)
{
Console.WriteLine(testcase);
try
{
if (testcase.StartsWith("Signing"))
{
factory.CreateForSigning(key, algorithm);
}
else
{
factory.CreateForVerifying(key, algorithm);
}
expectedException.ProcessNoException();
}
catch (Exception ex)
{
expectedException.ProcessException(ex);
}
}
private void AsymmetricConstructorVariation(string testcase, SecurityKey key, string algorithm, ExpectedException expectedException)
{
AsymmetricSignatureProvider provider = null;
try
{
if (testcase.StartsWith("Signing"))
{
provider = new AsymmetricSignatureProvider(key, algorithm, true);
}
else
{
provider = new AsymmetricSignatureProvider(key, algorithm, false);
}
expectedException.ProcessNoException();
}
catch (Exception ex)
{
expectedException.ProcessException(ex);
}
}
public void Constructors(string testId, SecurityKey key, string algorithm, bool isDecrypt, ExpectedException ee)
{
TestUtilities.WriteHeader("Constructors - " + testId, true);
try
{
var context = Guid.NewGuid().ToString();
var provider = new RsaKeyWrapProvider(key, algorithm, isDecrypt)
{
Context = context
};
ee.ProcessNoException();
Assert.Equal(provider.Algorithm, algorithm);
Assert.Equal(provider.Context, context);
Assert.True(ReferenceEquals(provider.Key, key));
}
catch (Exception ex)
{
ee.ProcessException(ex);
}
}
public void DefaultCryptoProviderFactory(SecurityKey key, string algorithm, bool isSupported, bool supportsSigning, ExpectedException ee)
{
Assert.True(CryptoProviderFactory.Default.IsSupportedAlgorithm(algorithm, key) == isSupported, string.Format(CultureInfo.InvariantCulture, "SecurityKey: '{0}', algorithm: '{1}', isSupported: '{2}'", key, algorithm, isSupported));
if (isSupported && supportsSigning)
{
try
{
var signatureProvider = CryptoProviderFactory.Default.CreateForSigning(key, algorithm);
var signatureProviderVerify = CryptoProviderFactory.Default.CreateForVerifying(key, algorithm);
var bytes = Encoding.UTF8.GetBytes("GenerateASignature");
var signature = signatureProvider.Sign(bytes);
var signatureCheck = signatureProviderVerify.Verify(bytes, signature);
Assert.True(signatureCheck);
CryptoProviderFactory.Default.ReleaseSignatureProvider(signatureProvider);
CryptoProviderFactory.Default.ReleaseSignatureProvider(signatureProviderVerify);
ee.ProcessNoException();
}
catch (Exception ex)
{
ee.ProcessException(ex);
}
}
}
/// <summary>
/// Sets a property, then checks it, checking for an expected exception.
/// </summary>
/// <param name="obj">object that has a 'setter'.</param>
/// <param name="property">the name of the property.</param>
/// <param name="propertyValue">value to set on the property.</param>
/// <param name="expectedException">checks that exception is correct.</param>
public static void SetGet(object obj, string property, object propertyValue, ExpectedException expectedException)
{
Assert.NotNull(obj);
Assert.False(string.IsNullOrWhiteSpace(property));
Type type = obj.GetType();
PropertyInfo propertyInfo = type.GetProperty(property);
Assert.True(propertyInfo != null, "'get is not found for property: '" + property + "', type: '" + type.ToString() + "'");
Assert.True(propertyInfo.CanWrite, "can not write to property: '" + property + "', type: '" + type.ToString() + "'");
try
{
propertyInfo.SetValue(obj, propertyValue);
object retval = propertyInfo.GetValue(obj);
Assert.Equal(propertyValue, retval);
expectedException.ProcessNoException();
}
catch (Exception exception)
{
// pass inner exception
expectedException.ProcessException(exception.InnerException);
}
}
public void Constructor()
{
var context = new CompareContext();
var expectedException = new ExpectedException(typeExpected: typeof(ArgumentNullException), substringExpected: "certificate");
try
{
new X509SecurityKey((X509Certificate2)null);
expectedException.ProcessNoException(context);
}
catch (Exception exception)
{
expectedException.ProcessException(exception, context);
}
var certificate = KeyingMaterial.DefaultCert_2048;
expectedException = new ExpectedException(typeExpected: typeof(ArgumentNullException), substringExpected: "keyId");
try
{
new X509SecurityKey(certificate, null);
expectedException.ProcessNoException(context);
}
catch (Exception exception)
{
expectedException.ProcessException(exception, context);
}
try
{
new X509SecurityKey(certificate, string.Empty);
expectedException.ProcessNoException(context);
}
catch (Exception exception)
{
expectedException.ProcessException(exception, context);
}
expectedException = ExpectedException.NoExceptionExpected;
try
{
var x509SecurityKey = new X509SecurityKey(certificate);
IdentityComparer.AreEqual(x509SecurityKey.KeyId, certificate.Thumbprint, context);
IdentityComparer.AreEqual(x509SecurityKey.X5t, Base64UrlEncoder.Encode(certificate.GetCertHash()), context);
IdentityComparer.AreEqual(certificate, x509SecurityKey.Certificate, context);
}
catch (Exception exception)
{
expectedException.ProcessException(exception, context);
}
try
{
var x509SecurityKey = new X509SecurityKey(certificate, "KID");
IdentityComparer.AreEqual(x509SecurityKey.KeyId, "KID", context);
IdentityComparer.AreEqual(x509SecurityKey.X5t, Base64UrlEncoder.Encode(certificate.GetCertHash()), context);
IdentityComparer.AreEqual(certificate, x509SecurityKey.Certificate, context);
}
catch (Exception exception)
{
expectedException.ProcessException(exception, context);
}
TestUtilities.AssertFailIfErrors(context);
}
