/// <inheritdoc />
public byte[] ExportPublicKey(CryptographicPublicKeyBlobType blobType)
{
byte[] keyData = KeyDataWithTag(GetPublicKeyIdentifierWithTag(this.keyIdentifier)).ToArray();
RSAParameters parameters = KeyFormatter.Pkcs1.Read(keyData);
return(KeyFormatter.GetFormatter(blobType).Write(parameters));
}
public void KeyPairInterop(CryptographicPrivateKeyBlobType blobType, AsymmetricAlgorithm algorithmName, string base64Key)
{
var algorithm = WinRTCrypto.AsymmetricKeyAlgorithmProvider.OpenAlgorithm(algorithmName);
var key = algorithm.ImportKeyPair(Convert.FromBase64String(base64Key), blobType);
var p1 = KeyFormatter.GetFormatter(blobType).Read(Convert.FromBase64String(base64Key));
string exported = Convert.ToBase64String(key.Export(blobType));
var p2 = KeyFormatter.GetFormatter(blobType).Read(Convert.FromBase64String(exported));
this.LogRSAParameterComparison("Original", p1, "Re-exported", p2);
if (blobType == CryptographicPrivateKeyBlobType.Pkcs8RawPrivateKeyInfo && exported.Length == base64Key.Length - 20)
{
// I'm not sure what the last 20 bytes are (perhaps the optional attributes)
// But Windows platforms produces them and Android doesn't seem to.
// Since the private key material seems to be elsewhere, we'll exclude
// the suffix from the comparison.
// The prefix is also mismatched, but that seems to also be ignorable.
Assert.Equal(base64Key.Substring(6, exported.Length - 6), exported.Substring(6));
}
else
{
// This check tends to be too brittle to implementation details of the native crypto,
// which may re-encode the D parameter for reasons I don't understand.
////Assert.Equal(base64Key, exported);
// The two prime numbers are really all that matter.
Assert.Equal <byte>(p1.P, p2.P);
Assert.Equal <byte>(p1.Q, p2.Q);
}
}
private void KeyFormatters_PrivateKeyRoundTrip(RSAParameters initialValue, CryptographicPrivateKeyBlobType format)
{
this.logger.WriteLine("Generated RSA parameters:");
this.LogRSAParameters(initialValue, " ");
var formatter = KeyFormatter.GetFormatter(format);
byte[] custom = formatter.Write(initialValue);
var rsaParametersRead = formatter.Read(custom);
this.logger.WriteLine("Read RSA parameters:");
this.LogRSAParameters(rsaParametersRead, " ");
Assert.Equal <byte>(initialValue.Exponent, rsaParametersRead.Exponent);
Assert.Equal <byte>(initialValue.Modulus, rsaParametersRead.Modulus);
Assert.Equal <byte>(initialValue.P, rsaParametersRead.P);
Assert.Equal <byte>(initialValue.Q, rsaParametersRead.Q);
if (format != CryptographicPrivateKeyBlobType.BCryptPrivateKey)
{
Assert.Equal <byte>(initialValue.D, rsaParametersRead.D);
Assert.Equal <byte>(initialValue.DP, rsaParametersRead.DP);
Assert.Equal <byte>(initialValue.DQ, rsaParametersRead.DQ);
Assert.Equal <byte>(initialValue.InverseQ, rsaParametersRead.InverseQ);
}
else
{
// BCryptPrivateKey is lossy, by design.
Assert.Null(rsaParametersRead.D);
Assert.Null(rsaParametersRead.DP);
Assert.Null(rsaParametersRead.DQ);
Assert.Null(rsaParametersRead.InverseQ);
}
}
/// <inheritdoc/>
public ICryptographicKey ImportPublicKey(byte[] keyBlob, CryptographicPublicKeyBlobType blobType = CryptographicPublicKeyBlobType.X509SubjectPublicKeyInfo)
{
Requires.NotNull(keyBlob, "keyBlob");
RSAParameters parameters = KeyFormatter.GetFormatter(blobType).Read(keyBlob);
// Inject the PKCS#1 public key into the KeyChain.
string keyIdentifier = Guid.NewGuid().ToString();
string publicKeyIdentifier = RsaCryptographicKey.GetPublicKeyIdentifierWithTag(keyIdentifier);
var keyQueryDictionary = RsaCryptographicKey.CreateKeyQueryDictionary(publicKeyIdentifier);
keyQueryDictionary[KSec.ValueData] = NSData.FromArray(KeyFormatter.Pkcs1.Write(parameters, includePrivateKey: false));
keyQueryDictionary[KSec.AttrKeyClass] = KSec.AttrKeyClassPublic;
keyQueryDictionary[KSec.ReturnRef] = NSNumber.FromBoolean(true);
IntPtr resultHandle;
int status = RsaCryptographicKey.SecItemAdd(keyQueryDictionary.Handle, out resultHandle);
if (resultHandle != IntPtr.Zero)
{
var key = new SecKey(resultHandle, true);
return(new RsaCryptographicKey(key, keyIdentifier, this.Algorithm));
}
else
{
throw new InvalidOperationException("SecItemAdd return " + status);
}
}
public void SanitizeKeyTests(string oldKey, string newKey)
{
// Act
var result = KeyFormatter.SanitizeKey(oldKey);
// Assert
result.Should().Be(newKey);
}
/// <inheritdoc/>
public ICryptographicKey ImportPublicKey(byte[] keyBlob, CryptographicPublicKeyBlobType blobType = CryptographicPublicKeyBlobType.X509SubjectPublicKeyInfo)
{
Requires.NotNull(keyBlob, "keyBlob");
var rsa = new Platform.RSACryptoServiceProvider();
rsa.ImportParameters(KeyFormatter.ToPlatformParameters(KeyFormatter.GetFormatter(blobType).Read(keyBlob)));
return(new RsaCryptographicKey(rsa, this.algorithm));
}
/// <summary>
/// Creates a cryptographic key based on the specified RSA parameters.
/// </summary>
/// <param name="provider">The asymmetric algorithm provider.</param>
/// <param name="parameters">The RSA parameters from which to initialize the key.</param>
/// <returns>The cryptographic key.</returns>
public static ICryptographicKey ImportParameters(this IAsymmetricKeyAlgorithmProvider provider, RSAParameters parameters)
{
Requires.NotNull(provider, nameof(provider));
byte[] keyBlob = KeyFormatter.Pkcs1.Write(parameters);
return(KeyFormatter.HasPrivateKey(parameters)
? provider.ImportKeyPair(keyBlob, CryptographicPrivateKeyBlobType.Pkcs1RsaPrivateKey)
: provider.ImportPublicKey(keyBlob, CryptographicPublicKeyBlobType.Pkcs1RsaPublicKey));
}
public static ISshKey AddKeyFromFile(this IAgent agent, string fileName,
ICollection<Agent.KeyConstraint> constraints,
KeyFormatter.GetPassphraseCallback getPassword = null)
{
if (getPassword == null) {
getPassword = PasswordCallbackFactory(
string.Format(Strings.msgEnterPassphrase, Path.GetFileName(fileName)));
}
return agent.AddKeyFromFile(fileName, getPassword, constraints);
}
public LazyMemoryCache(string name, ValueFactory valueFactory, PolicyProvider policyProvider = null, KeyFormatter keyFormatter = null,
ValueRemoved valueRemoved = null)
{
_valueFactory = valueFactory;
_policyProvider = policyProvider ?? DefaultPolicyProvider;
_keyFormatter = keyFormatter ?? DefaultKeyFormatter;
_valueRemoved = valueRemoved ?? DefaultValueRemoved;
_cache = new MemoryCache(name);
}
public void Test()
{
var formatter = new KeyFormatter();
Assert.Throws <ArgumentNullException>(() => formatter.Format <string?>(null));
var key = Guid.NewGuid();
Assert.Equal(key.ToString(), formatter.Format(key.ToString()));
Assert.Equal(key.ToString(), formatter.Format(key));
}
public LazyMemoryCache(string name, ValueFactory valueFactory, PolicyProvider policyProvider = null, KeyFormatter keyFormatter = null,
ValueRemoved valueRemoved = null)
{
_valueFactory = valueFactory;
_policyProvider = policyProvider ?? DefaultPolicyProvider;
_keyFormatter = keyFormatter ?? DefaultKeyFormatter;
_valueRemoved = valueRemoved ?? DefaultValueRemoved;
_cache = new MemoryCache(name);
_scheduler = new LimitedConcurrencyLevelTaskScheduler(1);
}
/// <inheritdoc/>
public ICryptographicKey ImportPublicKey(byte[] keyBlob, CryptographicPublicKeyBlobType blobType = CryptographicPublicKeyBlobType.X509SubjectPublicKeyInfo)
{
Requires.NotNull(keyBlob, "keyBlob");
var parameters = KeyFormatter.GetFormatter(blobType).Read(keyBlob);
var spec = new RSAPublicKeySpec(new BigInteger(1, parameters.Modulus), new BigInteger(1, parameters.Exponent));
KeyFactory factory = KeyFactory.GetInstance("RSA");
IPublicKey publicKey = factory.GeneratePublic(spec);
return(new RsaCryptographicKey(publicKey, parameters, this.algorithm));
}
/// <inheritdoc />
public byte[] Export(CryptographicPrivateKeyBlobType blobType)
{
try
{
return(KeyFormatter.GetFormatter(blobType).Write(KeyFormatter.ToPCLParameters(this.key.ExportParameters(true))));
}
catch (CryptographicException ex)
{
throw new InvalidOperationException("Private key not available.", ex);
}
}
/// <inheritdoc/>
public ICryptographicKey ImportKeyPair(byte[] keyBlob, CryptographicPrivateKeyBlobType blobType = CryptographicPrivateKeyBlobType.Pkcs8RawPrivateKeyInfo)
{
Requires.NotNull(keyBlob, "keyBlob");
RSAParameters parameters = KeyFormatter.GetFormatter(blobType).Read(keyBlob);
string keyIdentifier = Guid.NewGuid().ToString();
SecKey privateKey = ImportKey(parameters, RsaCryptographicKey.GetPrivateKeyIdentifierWithTag(keyIdentifier));
SecKey publicKey = ImportKey(KeyFormatter.PublicKeyFilter(parameters), RsaCryptographicKey.GetPublicKeyIdentifierWithTag(keyIdentifier));
return(new RsaCryptographicKey(publicKey, privateKey, keyIdentifier, this.Algorithm));
}
/// <summary>Creates a cryptographic key based on the specified RSA parameters.</summary>
/// <param name="provider">The asymmetric algorithm provider.</param>
/// <param name="parameters">The RSA parameters from which to initialize the key.</param>
/// <returns>The cryptographic key.</returns>
public static ICryptographicKey ImportParameters(this IAsymmetricKeyAlgorithmProvider provider, RSAParameters parameters)
{
#if PCL
throw new NotImplementedException("Not implemented in reference assembly.");
#else
Requires.NotNull(provider, "provider");
byte[] keyBlob = KeyFormatter.Pkcs1.Write(parameters);
return(KeyFormatter.HasPrivateKey(parameters)
? provider.ImportKeyPair(keyBlob, CryptographicPrivateKeyBlobType.Pkcs1RsaPrivateKey)
: provider.ImportPublicKey(keyBlob, CryptographicPublicKeyBlobType.Pkcs1RsaPublicKey));
#endif
}
/// <inheritdoc/>
public ICryptographicKey ImportPublicKey(byte[] keyBlob, CryptographicPublicKeyBlobType blobType)
{
Requires.NotNull(keyBlob, "keyBlob");
using (var provider = NCryptOpenStorageProvider(KeyStorageProviders.MS_KEY_STORAGE_PROVIDER))
{
byte[] bcryptPublicBlob = blobType == this.NativePublicKeyFormatEnum
? keyBlob
: KeyFormatter.GetFormatter(this.NativePublicKeyFormatEnum).Write(KeyFormatter.GetFormatter(blobType).Read(keyBlob));
var key = NCryptImportKey(provider, null, this.NativePublicKeyFormatString, IntPtr.Zero, bcryptPublicBlob);
return(this.CreateKey(key, isPublicOnly: true));
}
}
public static string Serialize(InfluxPoint point)
{
var tags = point.Tags;
var fields = point.Fields;
var allTags = string.Join(",", TagsFormatter.Format(tags));
var allFields = string.Join(",", FieldFormatter.Format(fields));
var tagsPart = allTags.Length > 0 ? $",{allTags}" : allTags;
var measurement = KeyFormatter.Format(point.Measurement);
return($"{measurement}{tagsPart} {allFields} {FieldValueFormatter.FormatTimestamp(point.UtcTimestamp)}".Trim());
}
static KeyFormatterTests()
{
rsaParameters = new Lazy <RSAParameters>(() =>
{
var algorithm = WinRTCrypto.AsymmetricKeyAlgorithmProvider.OpenAlgorithm(AsymmetricAlgorithm.RsaOaepSha1);
using (var key = algorithm.CreateKeyPair(512))
{
const CryptographicPrivateKeyBlobType keyBlobFormat = CryptographicPrivateKeyBlobType.BCryptFullPrivateKey;
byte[] bcryptNative = key.Export(keyBlobFormat);
var rsaParameters = KeyFormatter.GetFormatter(keyBlobFormat).Read(bcryptNative);
return(rsaParameters);
}
});
}
public RepositoryConfiguration(
string repositoryOwner,
string repositoryName,
string hashTags)
{
PartitionKey = KeyFormatter.SanitizeKey(Configuration.RepositoryConfigurations.PartitionKey);
RowKey = KeyFormatter.SanitizeKey($"{repositoryOwner}|{repositoryName}");
RepositoryOwner = repositoryOwner;
RepositoryName = repositoryName;
HashTags = hashTags;
CreatedAt = DateTime.UtcNow;
IsActive = true;
}
/// <inheritdoc/>
public ICryptographicKey ImportKeyPair(byte[] keyBlob, CryptographicPrivateKeyBlobType blobType = CryptographicPrivateKeyBlobType.Pkcs8RawPrivateKeyInfo)
{
Requires.NotNull(keyBlob, nameof(keyBlob));
RSAParameters parameters = KeyFormatter.GetFormatter(blobType)
.Read(keyBlob)
.ComputeFullPrivateKeyData();
IPrivateKey? privateKey = null;
IPublicKey? publicKey = null;
BigInteger? modulus = null, d = null, publicExponent = null;
RSAPrivateKeySpec?privateKeySpec = null;
RSAPublicKeySpec? publicKeySpec = null;
try
{
#pragma warning disable CA2000 // Dispose objects before losing scope
modulus = new BigInteger(1, parameters.Modulus);
d = new BigInteger(1, parameters.D);
privateKeySpec = new RSAPrivateKeySpec(modulus, d);
var factory = KeyFactory.GetInstance("RSA");
if (factory is null)
{
throw new InvalidOperationException(Strings.UnsupportedAlgorithm);
}
privateKey = factory.GeneratePrivate(privateKeySpec) !;
var privateRsaKey = privateKey.JavaCast <IRSAPrivateKey>() !;
publicExponent = new BigInteger(1, parameters.Exponent);
publicKeySpec = new RSAPublicKeySpec(privateRsaKey.Modulus, publicExponent);
publicKey = factory.GeneratePublic(publicKeySpec) !;
return(new RsaCryptographicKey(publicKey, privateKey, parameters, this.algorithm));
#pragma warning restore CA2000 // Dispose objects before losing scope
}
catch
{
publicExponent?.Dispose();
publicKeySpec?.Dispose();
privateKeySpec?.Dispose();
modulus?.Dispose();
d?.Dispose();
privateKey?.Dispose();
publicKey?.Dispose();
throw;
}
}
public PublicationConfiguration(
string publicationSourceOwner,
string publicationSourceName,
string publicationUrl,
string hashTags)
{
PartitionKey = KeyFormatter.SanitizeKey(Configuration.PublicationConfigurations.PartitionKey);
RowKey = KeyFormatter.SanitizeKey($"{publicationSourceOwner}|{publicationSourceName}");
PublicationSourceOwner = publicationSourceOwner;
PublicationSourceName = publicationSourceName;
PublicationSourceUrl = publicationUrl;
HashTags = hashTags;
IsActive = true;
}
public IEnumerator <KeyValuePair <TKey, TValue> > GetEnumerator()
{
for (int i = 0; i < Count; i++)
{
TKey key = KeyFormatter.Deserialize(ref _reader, ref _context);
if (IsOnlyReadFieldOffset)
{
BssomFieldOffsetInfo offset = new BssomFieldOffsetInfo(_reader.Position);
yield return(new KeyValuePair <TKey, TValue>(key, Unsafe.As <BssomFieldOffsetInfo, TValue>(ref offset)));
}
else
{
yield return(new KeyValuePair <TKey, TValue>(key, ValueFormatter.Deserialize(ref _reader, ref _context)));
}
}
}
/// <inheritdoc />
public override byte[] Export(CryptographicPrivateKeyBlobType blobType = CryptographicPrivateKeyBlobType.Pkcs8RawPrivateKeyInfo)
{
Verify.Operation(!this.IsPublicOnly, "Only public key is available.");
try
{
byte[] nativeBlob;
string nativeFormatString;
CryptographicPrivateKeyBlobType nativeBlobType;
if (this.Provider.NativePrivateKeyFormats.TryGetValue(blobType, out nativeFormatString))
{
nativeBlobType = blobType;
}
else
{
nativeBlobType = this.Provider.PreferredNativePrivateKeyFormat;
nativeFormatString = this.Provider.NativePrivateKeyFormats[nativeBlobType];
}
#if NET40
nativeBlob = NCryptExportKey(this.Key, SafeKeyHandle.Null, nativeFormatString, IntPtr.Zero).ToByteArray();
#else
nativeBlob = NCryptExportKey(this.Key, SafeKeyHandle.Null, nativeFormatString, IntPtr.Zero).ToArray();
#endif
byte[] formattedBlob;
if (nativeBlobType != blobType)
{
var parameters = KeyFormatter.GetFormatter(nativeBlobType).Read(nativeBlob);
formattedBlob = KeyFormatter.GetFormatter(blobType).Write(parameters);
}
else
{
formattedBlob = nativeBlob;
}
return(formattedBlob);
}
catch (SecurityStatusException ex)
{
if (ex.NativeErrorCode == SECURITY_STATUS.NTE_NOT_SUPPORTED)
{
throw new NotSupportedException(ex.Message, ex);
}
throw;
}
}
public void KeyFormatters_PublicKeyRoundTrip(CryptographicPublicKeyBlobType format)
{
var formatter = KeyFormatter.GetFormatter(format);
byte[] custom = formatter.Write(rsaParameters.Value, includePrivateKey: false);
var rsaParametersRead = formatter.Read(custom);
Assert.Equal <byte>(rsaParameters.Value.Exponent, rsaParametersRead.Exponent);
Assert.Equal <byte>(rsaParameters.Value.Modulus, rsaParametersRead.Modulus);
Assert.Null(rsaParametersRead.D);
Assert.Null(rsaParametersRead.P);
Assert.Null(rsaParametersRead.Q);
Assert.Null(rsaParametersRead.DP);
Assert.Null(rsaParametersRead.DQ);
Assert.Null(rsaParametersRead.InverseQ);
}
public Publication(
string publicationSourceName,
string id,
DateTimeOffset publicationDate,
string title,
string description,
string url,
string hashTags)
{
PartitionKey = KeyFormatter.SanitizeKey(publicationSourceName);
PublicationSourceName = publicationSourceName;
RowKey = KeyFormatter.SanitizeKey($"{id}-{publicationDate.ToUnixTimeSeconds()}");
Id = id;
PublicationDate = publicationDate;
Title = title;
Description = description;
Url = url;
HashTags = hashTags;
}
/// <inheritdoc />
public override byte[] ExportPublicKey(CryptographicPublicKeyBlobType blobType)
{
try
{
byte[] nativeBlob = NCryptExportKey(this.Key, SafeKeyHandle.Null, this.Provider.NativePublicKeyFormatString, IntPtr.Zero).ToArray();
byte[] formattedBlob = blobType == this.Provider.NativePublicKeyFormatEnum
? nativeBlob
: KeyFormatter.GetFormatter(blobType).Write(KeyFormatter.GetFormatter(this.Provider.NativePublicKeyFormatEnum).Read(nativeBlob));
return(formattedBlob);
}
catch (SecurityStatusException ex)
{
if (ex.NativeErrorCode == SECURITY_STATUS.NTE_NOT_SUPPORTED)
{
throw new NotSupportedException(ex.Message, ex);
}
throw;
}
}
/// <inheritdoc/>
public ICryptographicKey ImportKeyPair(byte[] keyBlob, CryptographicPrivateKeyBlobType blobType = CryptographicPrivateKeyBlobType.Pkcs8RawPrivateKeyInfo)
{
Requires.NotNull(keyBlob, "keyBlob");
RSAParameters parameters = KeyFormatter.GetFormatter(blobType).Read(keyBlob);
IPrivateKey privateKey;
IPublicKey publicKey;
var spec = new RSAPrivateKeySpec(new BigInteger(1, parameters.Modulus), new BigInteger(1, parameters.D));
var factory = KeyFactory.GetInstance("RSA");
privateKey = factory.GeneratePrivate(spec);
var privateRsaKey = privateKey.JavaCast <IRSAPrivateKey>();
var publicKeySpec = new RSAPublicKeySpec(privateRsaKey.Modulus, new BigInteger(1, parameters.Exponent));
publicKey = factory.GeneratePublic(publicKeySpec);
return(new RsaCryptographicKey(publicKey, privateKey, parameters, this.algorithm));
}
/// <inheritdoc />
public byte[] Export(CryptographicPrivateKeyBlobType blobType)
{
NSData data = KeyDataWithTag(GetPrivateKeyIdentifierWithTag(this.keyIdentifier));
Verify.Operation(data != null, "Private key not available.");
byte[] keyData;
try
{
keyData = data.ToArray();
}
catch (ArgumentNullException ex)
{
// MonoTouch throws this when the private key is missing.
throw new InvalidOperationException("Private key not available.", ex);
}
var parameters = KeyFormatter.Pkcs1.Read(keyData);
return(KeyFormatter.GetFormatter(blobType).Write(parameters));
}
static ISshKey GetSshKey(Func <Stream> getPrivateKeyStream,
Func <Stream> getPublicKeyStream,
string fallbackComment,
KeyFormatter.GetPassphraseCallback getPassphrase)
{
ISshKey key;
using (var privateKeyStream = getPrivateKeyStream())
key = privateKeyStream.ReadSshKey(getPassphrase);
if (string.IsNullOrWhiteSpace(key.Comment) && getPublicKeyStream != null)
{
using (var stream = getPublicKeyStream())
key.Comment = KeyFormatter.GetComment(stream.ReadAllLines(Encoding.UTF8));
}
if (string.IsNullOrWhiteSpace(key.Comment))
{
key.Comment = fallbackComment;
}
return(key);
}
/// <inheritdoc/>
public ICryptographicKey ImportKeyPair(byte[] keyBlob, CryptographicPrivateKeyBlobType blobType = CryptographicPrivateKeyBlobType.Pkcs8RawPrivateKeyInfo)
{
Requires.NotNull(keyBlob, "keyBlob");
var parameters = KeyFormatter.GetFormatter(blobType)
.Read(keyBlob)
.ComputeFullPrivateKeyData();
if (!CapiKeyFormatter.IsCapiCompatible(parameters))
{
// Try to make it CAPI compatible since it's faster on desktop,
// and the only thing that could possibly work on wp8.
RSAParameters adjustedParameters = KeyFormatter.NegotiateSizes(parameters);
if (CapiKeyFormatter.IsCapiCompatible(adjustedParameters))
{
parameters = adjustedParameters;
}
}
Platform.RSA rsa;
if (CapiKeyFormatter.IsCapiCompatible(parameters))
{
rsa = new Platform.RSACryptoServiceProvider();
}
else
{
#if DESKTOP
rsa = new RSAManaged();
#else
// Throw the exception explaining the problem.
CapiKeyFormatter.VerifyCapiCompatibleParameters(parameters);
// Make it obvious to the compiler that the buck stops here.
// er... on the line above.
throw new NotSupportedException();
#endif
}
rsa.ImportParameters(KeyFormatter.ToPlatformParameters(parameters));
return(new RsaCryptographicKey(rsa, this.algorithm));
}
public void Pkcs1DecodingTest()
{
#pragma warning disable 0436
// Initialize the "Known Good" RSAParameters.
byte[] capi1Blob = Convert.FromBase64String(AsymmetricKeyAlgorithmProviderTests.Helper.PrivateKeyFormatsAndBlobs[Tuple.Create(PCLCrypto.AsymmetricAlgorithm.RsaOaepSha1, CryptographicPrivateKeyBlobType.Capi1PrivateKey)]);
var rsa = new RSACryptoServiceProvider();
rsa.ImportCspBlob(capi1Blob);
RSAParameters rsaCapi = rsa.ExportParameters(true);
// Now load up the tested one.
byte[] pkcs1KeyBlob = Convert.FromBase64String(AsymmetricKeyAlgorithmProviderTests.Helper.PrivateKeyFormatsAndBlobs[Tuple.Create(PCLCrypto.AsymmetricAlgorithm.RsaOaepSha1, CryptographicPrivateKeyBlobType.Pkcs1RsaPrivateKey)]);
RSAParameters homeReadPkcs1 = KeyFormatter.ToPlatformParameters(KeyFormatter.Pkcs1.Read(pkcs1KeyBlob));
#pragma warning restore 0436
Assert.Equal(WinRTCrypto.CryptographicBuffer.EncodeToHexString(rsaCapi.Modulus), WinRTCrypto.CryptographicBuffer.EncodeToHexString(homeReadPkcs1.Modulus));
Assert.Equal(WinRTCrypto.CryptographicBuffer.EncodeToHexString(rsaCapi.Exponent), WinRTCrypto.CryptographicBuffer.EncodeToHexString(homeReadPkcs1.Exponent));
Assert.Equal(WinRTCrypto.CryptographicBuffer.EncodeToHexString(rsaCapi.D), WinRTCrypto.CryptographicBuffer.EncodeToHexString(homeReadPkcs1.D));
Assert.Equal(WinRTCrypto.CryptographicBuffer.EncodeToHexString(rsaCapi.P), WinRTCrypto.CryptographicBuffer.EncodeToHexString(homeReadPkcs1.P));
Assert.Equal(WinRTCrypto.CryptographicBuffer.EncodeToHexString(rsaCapi.Q), WinRTCrypto.CryptographicBuffer.EncodeToHexString(homeReadPkcs1.Q));
Assert.Equal(WinRTCrypto.CryptographicBuffer.EncodeToHexString(rsaCapi.DP), WinRTCrypto.CryptographicBuffer.EncodeToHexString(homeReadPkcs1.DP));
Assert.Equal(WinRTCrypto.CryptographicBuffer.EncodeToHexString(rsaCapi.DQ), WinRTCrypto.CryptographicBuffer.EncodeToHexString(homeReadPkcs1.DQ));
Assert.Equal(WinRTCrypto.CryptographicBuffer.EncodeToHexString(rsaCapi.InverseQ), WinRTCrypto.CryptographicBuffer.EncodeToHexString(homeReadPkcs1.InverseQ));
}
