public CryptoServiceProviderHmac(
String provider,
ProviderType providerType,
AlgorithmId algorithm)
: base(provider, providerType, algorithm)
{
}
internal CryptoServiceProviderHash(
String provider,
ProviderType providerType,
AlgorithmId algorithm)
: base(provider, providerType, algorithm)
{
}
public CryptoServiceProviderHmac(
byte[] key,
String provider,
ProviderType providerType,
AlgorithmId algorithm)
: this(provider, providerType, algorithm)
{
_key = key;
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="AbstractCryptoServiceProviderHash"/> class.
/// </summary>
///
/// <param name="provider">
/// The name of the Capi provider.
/// </param>
///
/// <param name="providerType">
/// Type of the provider.
/// </param>
///
/// <param name="algorithm">
/// The hash algorithm.
/// </param>
internal AbstractCryptoServiceProviderHash(
String provider,
ProviderType providerType,
AlgorithmId algorithm)
{
this._algorithmId = algorithm;
this._provider = provider;
this._providerType = providerType;
}
public override void OnNavigatedTo(INavigationParameters parameters)
{
switch (parameters.GetNavigationMode())
{
case NavigationMode.Back:
break;
case NavigationMode.New:
_algorithmId = parameters.GetValue <AlgorithmId>(LiveAlgorithmPage.Parameters.Id);
RefreshAlgorithm();
// Subscrive to updates for this algorithm
Subscribe();
break;
default:
throw new ArgumentException($"Unsupported NavigationMode: {parameters.GetNavigationMode()}",
nameof(parameters));
}
}
/// <summary>
/// Map an algorithm ID to a string name
/// </summary>
internal static string GetAlgorithmName(AlgorithmId algorithm)
{
Contract.Ensures(!String.IsNullOrEmpty(Contract.Result <string>()));
return(algorithm.ToString().ToUpper(CultureInfo.InvariantCulture));
}
public static extern bool CryptGenKey(SafeCspHandle hProv,
AlgorithmId Algid,
KeyFlags dwFlags,
[Out] out SafeCapiKeyHandle phKey);
public static extern bool CryptCreateHash(SafeCspHandle hProv,
AlgorithmId Algid,
SafeCapiKeyHandle hKey,
int dwFlags,
[Out] out SafeCapiHashHandle phHash);
private static unsafe bool IsValidPublicKeyUnsafe(ImmutableArray<byte> blob)
{
var blobArray = blob.DangerousGetUnderlyingArray();
fixed (byte* blobPtr = blobArray)
{
var pkb = (SnPublicKeyBlob*)blobPtr;
// The number of public key bytes must be the same as the size of the header plus the size of the public key data.
if (blob.Length != s_publicKeyHeaderSize + pkb->PublicKeySize)
{
return false;
}
// Check for the ECMA key, which does not obey the invariants checked below.
if (ByteSequenceComparer.Equals(blob, s_ecmaKey))
{
return true;
}
// The public key must be in the wincrypto PUBLICKEYBLOB format
if (pkb->PublicKey[0] != PublicKeyBlobId)
{
return false;
}
var signatureAlgorithmId = new AlgorithmId(pkb->SigAlgId);
if (signatureAlgorithmId.IsSet && signatureAlgorithmId.Class != AlgorithmClass.Signature)
{
return false;
}
var hashAlgorithmId = new AlgorithmId(pkb->HashAlgId);
if (hashAlgorithmId.IsSet && (hashAlgorithmId.Class != AlgorithmClass.Hash || hashAlgorithmId.SubId < AlgorithmSubId.Sha1Hash))
{
return false;
}
}
return true;
}
/// <summary>Initializes a new instance of <see cref="KeyManagementAlgorithm"/>. </summary>
public KeyManagementAlgorithm(AlgorithmId id, string name, AlgorithmCategory keyType, KeyManagementAlgorithm wrappedAlgorithm, Sha2 sha2)
: this(id, name, keyType, requiredKeySizeInBits : 0, wrappedAlgorithm, sha2 : sha2, produceEncryptedKey : true)
{
}
internal static bool IsValidPublicKey(ImmutableArray <byte> blob)
{
// The number of public key bytes must be at least large enough for the header and one byte of data.
if (blob.IsDefault || blob.Length < s_publicKeyHeaderSize + 1)
{
return(false);
}
var blobReader = new LittleEndianReader(blob.AsSpan());
// Signature algorithm ID
var sigAlgId = blobReader.ReadUInt32();
// Hash algorithm ID
var hashAlgId = blobReader.ReadUInt32();
// Size of public key data in bytes, not including the header
var publicKeySize = blobReader.ReadUInt32();
// publicKeySize bytes of public key data
var publicKey = blobReader.ReadByte();
// The number of public key bytes must be the same as the size of the header plus the size of the public key data.
if (blob.Length != s_publicKeyHeaderSize + publicKeySize)
{
return(false);
}
// Check for the ECMA key, which does not obey the invariants checked below.
if (ByteSequenceComparer.Equals(blob, s_ecmaKey))
{
return(true);
}
// The public key must be in the wincrypto PUBLICKEYBLOB format
if (publicKey != PublicKeyBlobId)
{
return(false);
}
var signatureAlgorithmId = new AlgorithmId(sigAlgId);
if (
signatureAlgorithmId.IsSet && signatureAlgorithmId.Class != AlgorithmClass.Signature
)
{
return(false);
}
var hashAlgorithmId = new AlgorithmId(hashAlgId);
if (
hashAlgorithmId.IsSet &&
(
hashAlgorithmId.Class != AlgorithmClass.Hash ||
hashAlgorithmId.SubId < AlgorithmSubId.Sha1Hash
)
)
{
return(false);
}
return(true);
}
internal static Exception CreateNotSupportedException_Algorithm(AlgorithmId algorithm) => new NotSupportedException($"The algorithm '{algorithm}' is not supported.");
internal static void ThrowNotSupportedException_Algorithm(AlgorithmId algorithm) => throw CreateNotSupportedException_Algorithm(algorithm);
internal static Exception CreateNotSupportedException_AlgorithmForKeyWrap(AlgorithmId algorithm) => new NotSupportedException($"Key wrap is not supported for algorithm: '{algorithm}'.");
internal static SafeCapiKeyHandle ImportSymmetricKey(SafeCspHandle provider, AlgorithmId algorithm, byte[] key)
{
Contract.Requires(provider != null);
Contract.Requires(((int)algorithm & (int)AlgorithmClass.DataEncryption) == (int)AlgorithmClass.DataEncryption);
Contract.Requires(key != null);
Contract.Ensures(Contract.Result <SafeCapiKeyHandle>() != null &&
!Contract.Result <SafeCapiKeyHandle>().IsInvalid&&
!Contract.Result <SafeCapiKeyHandle>().IsClosed);
//
// Setup a PLAINTEXTKEYBLOB (v2) which has the following format:
// BLOBHEADER hdr
// DWORD cbKeySize
// BYTE rbgKeyData[]
//
int blobSize = Marshal.SizeOf(typeof(BLOBHEADER)) + Marshal.SizeOf(typeof(int)) + key.Length;
byte[] keyBlob = new byte[blobSize];
unsafe
{
fixed(byte *pBlob = keyBlob)
{
BLOBHEADER *pHeader = (BLOBHEADER *)pBlob;
pHeader->bType = KeyBlobType.PlainText;
pHeader->bVersion = 2;
pHeader->reserved = 0;
pHeader->aiKeyAlg = algorithm;
int *pSize = (int *)(pBlob + Marshal.SizeOf(*pHeader));
*pSize = key.Length;
}
}
Buffer.BlockCopy(key, 0, keyBlob, Marshal.SizeOf(typeof(BLOBHEADER)) + Marshal.SizeOf(typeof(int)), key.Length);
// Import the PLAINTEXTKEYBLOB into the CSP
SafeCapiKeyHandle importedKey = null;
RuntimeHelpers.PrepareConstrainedRegions();
try {
if (!UnsafeNativeMethods.CryptImportKey(provider,
keyBlob,
keyBlob.Length,
SafeCapiKeyHandle.InvalidHandle,
KeyFlags.Exportable,
out importedKey))
{
throw new CryptographicException(Marshal.GetLastWin32Error());
}
}
finally {
if (importedKey != null && !importedKey.IsInvalid)
{
importedKey.SetParentCsp(provider);
}
}
return(importedKey);
}
internal static unsafe SafeCapiKeyHandle ImportSymmetricKey(SafeCspHandle provider, AlgorithmId algorithm, byte[] key)
{
int num = (Marshal.SizeOf(typeof(BLOBHEADER)) + Marshal.SizeOf(typeof(int))) + key.Length;
byte[] dst = new byte[num];
fixed(byte *numRef = dst)
{
BLOBHEADER *blobheaderPtr = (BLOBHEADER *)numRef;
blobheaderPtr->bType = KeyBlobType.PlainText;
blobheaderPtr->bVersion = 2;
blobheaderPtr->reserved = 0;
blobheaderPtr->aiKeyAlg = algorithm;
int *numPtr = (int *)(numRef + Marshal.SizeOf(blobheaderPtr[0]));
numPtr[0] = key.Length;
}
Buffer.BlockCopy(key, 0, dst, Marshal.SizeOf(typeof(BLOBHEADER)) + Marshal.SizeOf(typeof(int)), key.Length);
SafeCapiKeyHandle phKey = null;
if (!UnsafeNativeMethods.CryptImportKey(provider, dst, dst.Length, SafeCapiKeyHandle.InvalidHandle, KeyFlags.Exportable, out phKey))
{
throw new CryptographicException(Marshal.GetLastWin32Error());
}
return(phKey);
}
// From StrongNameInternal.cpp
public static bool TryDecode(ImmutableArray<byte> bytes)
{
// The number of public key bytes must be at least large enough for the header and one byte of data.
if (bytes.IsDefault || bytes.Length < HeaderSize + 1)
{
return false;
}
// The number of public key bytes must be the same as the size of the header plus the size of the public key data.
var dataSize = ToUInt32(bytes, PublicKeySizeOffset);
if (bytes.Length != HeaderSize + dataSize)
{
return false;
}
// Check for the ECMA key, which does not obey the invariants checked below.
if (ByteSequenceComparer.Equals(bytes, s_ecmaKey))
{
return true;
}
var signatureAlgorithmId = new AlgorithmId(ToUInt32(bytes, 0));
if (signatureAlgorithmId.IsSet && signatureAlgorithmId.Class != AlgorithmClass.Signature)
{
return false;
}
var hashAlgorithmId = new AlgorithmId(ToUInt32(bytes, 4));
if (hashAlgorithmId.IsSet && (hashAlgorithmId.Class != AlgorithmClass.Hash || hashAlgorithmId.SubId < AlgorithmSubId.Sha1Hash))
{
return false;
}
if (bytes[PublicKeyDataOffset] != PublicKeyBlob)
{
return false;
}
return true;
}
internal static string GetAlgorithmName(AlgorithmId algorithm)
{
return(algorithm.ToString().ToUpper(CultureInfo.InvariantCulture));
}
/// <summary>Initializes a new instance of <see cref="KeyManagementAlgorithm"/>. </summary>
public KeyManagementAlgorithm(AlgorithmId id, string name, AlgorithmCategory keyType, bool produceEncryptedKey)
: this(id, name, keyType, requiredKeySizeInBits : 0, wrappedAlgorithm : null, sha2 : null, produceEncryptedKey)
{
}
internal static extern bool CryptCreateHash(
SafeCryptoContextHandle cryptoContext,
AlgorithmId algorithmId,
SafeCryptoKeyHandle key,
int flags,
out SafeCryptoHashHandle hash);