microsoft
/
SymCrypt
зеркало из https://github.com/microsoft/SymCrypt.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
SymCrypt/unittest/inc/algorithm_base.h

2100 строки
76 KiB
C++
Исходник Ответственный История

//
// Algorithm_base.h
// base classes for algorithm implementations
//
// Copyright (c) Microsoft Corporation. Licensed under the MIT license.
//
//
// AlgorithmImplementation class
// This is the abstract class that represents the common properties
// of all algorithm implementations.
//
class AlgorithmImplementation
{
public:
AlgorithmImplementation();
virtual ~AlgorithmImplementation() {};
private:
AlgorithmImplementation( const AlgorithmImplementation & );
VOID operator =( const AlgorithmImplementation & );
public:
std::string m_algorithmName; // Name of algorithm
std::string m_modeName; // Name of algorithm mode
std::string m_implementationName; // Name of implementation
virtual VOID setPerfKeySize( SIZE_T keySize ) {UNREFERENCED_PARAMETER(keySize);};
PerfKeyFn m_perfKeyFunction;
PerfDataFn m_perfDataFunction;
PerfDataFn m_perfDecryptFunction;
PerfCleanFn m_perfCleanFunction;
//
// During functional testing we test all implementations of a single algorithm
// in parallel. This makes debugging bugs triggered by the pseudo-random test cases
// much easier.
// When we check the (intermediate or final) result there are three types of errors we can encounter:
// - Result disagrees with majority of other implementations of the same algorithm
// - Results disagree but there is no majority to find out what result is correct
// - Result agrees with majority but not with KAT values.
//
// These counters count how often each of these cases happens.
//
ULONGLONG m_nErrorDisagreeWithMajority;
ULONGLONG m_nErrorNoMajority;
ULONGLONG m_nErrorKatFailure;
//
// Number of times this algorithm has produced a result during the test
//
ULONGLONG m_nResults;
//
// Performance information
//
typedef struct _ALG_PERF_INFO
{
SIZE_T keySize; // key size to add to row header. (0 if not used)
SIZE_T dataSize; // data size to add to row header. (only used with g_measure_specific_sizes)
char * operationName; // operation name string, must be 3 characters long
char * strPostfix; // postfix string, it is a string associated with a special key size for the given algorithm (i.e. data unit size, elliptic curve type, modulus type, etc.)
double cFixed; // clocks of fixed overhead.
double cPerByte; // clocks average cost per byte (used only for linear records, 0 for non-linear records)
double cRange; // 90 percentile of deviation from prediction by previous two numbers
} ALG_PERF_INFO;
std::vector<ALG_PERF_INFO> m_perfInfo;
};
class HashImplementation: public AlgorithmImplementation
{
public:
HashImplementation() {};
virtual ~HashImplementation() {};
private:
HashImplementation( const HashImplementation & );
VOID operator=( const HashImplementation & );
public:
virtual SIZE_T resultLen() = 0;
// Return the result length of this hash
virtual SIZE_T inputBlockLen() = 0;
// Return the input block length of this hash
virtual VOID init() = 0;
// Initialize for a new hash computation.
virtual VOID append( _In_reads_( cbData ) PCBYTE pbData, SIZE_T cbData ) = 0;
// Append data to the running hash computation.
virtual VOID result( _Out_writes_( cbResult ) PBYTE pbResult, SIZE_T cbResult ) = 0;
// Get the result of the running hash computation.
virtual VOID hash( _In_reads_( cbData ) PCBYTE pbData, SIZE_T cbData,
_Out_writes_( cbResult ) PBYTE pbResult, SIZE_T cbResult );
// Single hash computation.
// The default implementation calls init/append/result so implementations that do not
// have a separate compute-hash function can call the generic implementation in this
// class.
virtual NTSTATUS initWithLongMessage( ULONGLONG nBytes ) = 0;
// nBytes is a multiple of the input block length.
// Set the computation to the state as if it has processed a message nBytes long
// which resulted in the internal chaining state having the value with every
// byte equal to the character 'b'.
// This allows us to test carry-handling of the message length counters. (A known
// problem area.)
// Return zero if success, NT status error if not supported.
virtual NTSTATUS exportSymCryptFormat(
_Out_writes_bytes_to_( cbResultBufferSize, *pcbResult ) PBYTE pbResult,
_In_ SIZE_T cbResultBufferSize,
_Out_ SIZE_T *pcbResult ) = 0;
};
class XofImplementation : public AlgorithmImplementation
{
public:
XofImplementation() {};
virtual ~XofImplementation() {};
private:
XofImplementation(const XofImplementation&);
VOID operator=(const XofImplementation&);
public:
virtual SIZE_T inputBlockLen() = 0;
// Return the input block length of this XOF
virtual VOID init() = 0;
// Initialize for a new XOF computation.
virtual VOID append(_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData) = 0;
// Append data to the running XOF computation.
virtual VOID extract(_Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult, BOOLEAN bWipe) = 0;
// XOF extraction.
// Extracts cbResult bytes from the XOF. Wipes and re-initializes the state if bWipe=TRUE.
virtual VOID result(_Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult) = 0;
// Get the result of the running XOF computation.
// Default implementation calls extract with bWipe=TRUE.
virtual VOID xof(_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData,
_Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult);
// Single-call XOF computation.
// The default implementation calls init/append/result.
};
class CustomizableXofImplementation : public AlgorithmImplementation
{
public:
CustomizableXofImplementation() {};
virtual ~CustomizableXofImplementation() {};
private:
CustomizableXofImplementation(const CustomizableXofImplementation&);
VOID operator=(const CustomizableXofImplementation&);
public:
virtual SIZE_T inputBlockLen() = 0;
// Return the input block length of this XOF
virtual VOID init( _In_reads_(cbNstr) PCBYTE pbNstr,
SIZE_T cbNstr,
_In_reads_(cbSstr) PCBYTE pbSstr,
SIZE_T cbSstr) = 0;
// Initialize for a new XOF computation.
virtual VOID append(_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData) = 0;
// Append data to the running XOF computation.
virtual VOID extract(_Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult, BOOLEAN bWipe) = 0;
// XOF extraction.
// Extracts cbResult bytes from the XOF. Wipes and re-initializes the state if bWipe=TRUE.
virtual VOID result(_Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult) = 0;
// Get the result of the running XOF computation.
// Default implementation calls extract with bWipe=TRUE.
virtual VOID xof(
_In_reads_( cbNstr ) PCBYTE pbNstr, SIZE_T cbNstr,
_In_reads_( cbSstr ) PCBYTE pbSstr, SIZE_T cbSstr,
_In_reads_( cbData ) PCBYTE pbData, SIZE_T cbData,
_Out_writes_( cbResult ) PBYTE pbResult, SIZE_T cbResult) = 0;
// Single-call XOF computation.
// The default implementation calls init/append/result.
};
#define MAX_PARALLEL_HASH_STATES 32
#define MAX_PARALLEL_HASH_OPERATIONS 128
class ParallelHashImplementation: public AlgorithmImplementation
{
public:
ParallelHashImplementation() {};
virtual ~ParallelHashImplementation() {};
private:
ParallelHashImplementation( const ParallelHashImplementation & );
VOID operator=( const ParallelHashImplementation & );
public:
virtual PCSYMCRYPT_HASH SymCryptHash() = 0;
// Return a pointer to the SymCrypt implementation of the equivalent hash algorithm.
virtual SIZE_T resultLen() = 0;
// Return the result length of this hash
virtual SIZE_T inputBlockLen() = 0;
// Return the input block length of this hash
virtual VOID init( SIZE_T nHashes ) = 0;
// Initialize for a new hash computation.
// nHashes = # hash states, nHashes <= MAX_PARALLEL_HASH_STATES
virtual VOID process(
_In_reads_( nOperations ) BCRYPT_MULTI_HASH_OPERATION * pOperations,
SIZE_T nOperations ) = 0;
// Process BCrypt-style operations on the parallel hash state
virtual NTSTATUS initWithLongMessage( ULONGLONG nBytes ) = 0;
// nBytes is a multiple of the input block length.
// Set the computation to the state as if it has processed a message nBytes long
// which resulted in the internal chaining state having the value with every
// byte equal to the character 'b'.
// This allows us to test carry-handling of the message length counters. (A known
// problem area.)
// Return zero if success, NT status error if not supported.
};
class MacImplementation: public AlgorithmImplementation
{
public:
MacImplementation() {};
~MacImplementation() {};
private:
MacImplementation( const MacImplementation & );
VOID operator=( const MacImplementation & );
public:
virtual SIZE_T resultLen() = 0;
// return the result length of this MAC
virtual SIZE_T inputBlockLen() = 0;
// return the input block length of this MAC
virtual NTSTATUS init( _In_reads_( cbKey ) PCBYTE pbKey, SIZE_T cbKey ) = 0;
// Start a new MAC computation with the given key.
// Return zero if success, NT status error if not supported.
virtual VOID append( _In_reads_( cbData ) PCBYTE pbData, SIZE_T cbData ) = 0;
// Append data to the running MAC computation.
virtual VOID result( _Out_writes_( cbResult ) PBYTE pbResult, SIZE_T cbResult ) = 0;
// Get the result of the running MAC computation.
virtual NTSTATUS mac( _In_reads_( cbKey ) PCBYTE pbKey, SIZE_T cbKey,
_In_reads_( cbData ) PCBYTE pbData, SIZE_T cbData,
_Out_writes_( cbResult ) PBYTE pbResult, SIZE_T cbResult );
// Complete a full MAC computation.
// The default implementation merely calls the init/append/result members.
// Return zero if success, NT status error if not supported.
};
class KmacImplementation : public AlgorithmImplementation
{
public:
KmacImplementation() {};
~KmacImplementation() {};
private:
KmacImplementation(const KmacImplementation&);
VOID operator=(const KmacImplementation&);
public:
virtual SIZE_T inputBlockLen() = 0;
// return the input block length of this MAC
virtual VOID init(
_In_reads_(cbCustomizationStr) PCBYTE pbCustomizationStr, SIZE_T cbCustomizationStr,
_In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey) = 0;
// Start a new MAC computation with the given key and customization string.
virtual VOID append(_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData) = 0;
// Append data to the running MAC computation.
virtual VOID extract(_Out_writes_(cbData) PBYTE pbResult, SIZE_T cbResult, BOOLEAN bWipe) = 0;
// Extract data in XOF mode.
virtual VOID result(_Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult) = 0;
// Get the result of the running MAC computation.
virtual VOID mac(
_In_reads_(cbCustomizationStr) PCBYTE pbCustomizationStr, SIZE_T cbCustomizationStr,
_In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey,
_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData,
_Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult);
// Complete a full MAC computation.
// The default implementation merely calls the init/append/result members.
virtual VOID xof(
_In_reads_(cbCustomizationStr) PCBYTE pbCustomizationStr, SIZE_T cbCustomizationStr,
_In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey,
_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData,
_Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult);
// Generate a fixed size output in XOF mode.
// The default implementation merely calls the init/append/extract members.
};
class BlockCipherImplementation: public AlgorithmImplementation
//
// Implements block cipher encryption modes.
// Data is always a multiple of the block length.
// The chaining value is used for CBC/CTR/CFB/etc mode, but is length 0 for ECB
//
{
public:
BlockCipherImplementation() {};
virtual ~BlockCipherImplementation() {};
private:
BlockCipherImplementation( const BlockCipherImplementation & );
VOID operator=( const BlockCipherImplementation & );
public:
virtual SIZE_T msgBlockLen() = 0;
virtual SIZE_T chainBlockLen() = 0;
virtual SIZE_T coreBlockLen() = 0;
virtual NTSTATUS setKey( PCBYTE pbKey, SIZE_T cbKey ) = 0;
virtual VOID encrypt(
_Inout_updates_opt_( cbChain ) PBYTE pbChain,
SIZE_T cbChain,
_In_reads_( cbData ) PCBYTE pbSrc,
_Out_writes_( cbData ) PBYTE pbDst,
SIZE_T cbData ) = 0;
virtual VOID decrypt(
_Inout_updates_opt_( cbChain ) PBYTE pbChain,
SIZE_T cbChain,
_In_reads_( cbData ) PCBYTE pbSrc,
_Out_writes_( cbData ) PBYTE pbDst,
SIZE_T cbData ) = 0;
};
class AuthEncImplementation: public AlgorithmImplementation
//
// Implements authenticated encryption modes.
//
{
public:
AuthEncImplementation() {};
virtual ~AuthEncImplementation() {};
private:
AuthEncImplementation( const AuthEncImplementation & );
VOID operator=( const AuthEncImplementation & );
public:
virtual std::set<SIZE_T> getNonceSizes() = 0;
virtual std::set<SIZE_T> getTagSizes() = 0;
virtual std::set<SIZE_T> getKeySizes() = 0;
virtual NTSTATUS setKey( _In_reads_( cbKey ) PCBYTE pbKey, SIZE_T cbKey ) = 0;
// The encrypt/decrypt can be called in two ways.
// First: process an entire message in one call. This requires no flags.
// Second: incremental processing of a message.
// For incremental processing, the AUTHENC_FLAG_PARTIAL flag is passed to all
// calls that are part of the incremental processing.
// All authdata has to be passed in the first incremental call.
// The last incremental call is marked by a nonzero pbTag.
// setTotalCbData() must be called before each sequence of incremental calls.
// Implementations that don't do incremental processing can simply return
// STATUS_NOT_SUPPORTED for all incremental calls.
#define AUTHENC_FLAG_PARTIAL 1
virtual VOID setTotalCbData( SIZE_T cbData ) = 0; // Set total cbData up front for partial processing (used by CCM)
virtual NTSTATUS encrypt(
_In_reads_( cbNonce ) PCBYTE pbNonce,
SIZE_T cbNonce,
_In_reads_( cbAuthData ) PCBYTE pbAuthData,
SIZE_T cbAuthData,
_In_reads_( cbData ) PCBYTE pbSrc,
_Out_writes_( cbData ) PBYTE pbDst,
SIZE_T cbData,
_Out_writes_( cbTag ) PBYTE pbTag,
SIZE_T cbTag,
ULONG flags ) = 0;
virtual NTSTATUS decrypt(
_In_reads_( cbNonce ) PCBYTE pbNonce,
SIZE_T cbNonce,
_In_reads_( cbAuthData ) PCBYTE pbAuthData,
SIZE_T cbAuthData,
_In_reads_( cbData ) PCBYTE pbSrc,
_Out_writes_( cbData ) PBYTE pbDst,
SIZE_T cbData,
_In_reads_( cbTag ) PCBYTE pbTag,
SIZE_T cbTag,
ULONG flags ) = 0;
};
class XtsImplementation: public AlgorithmImplementation
{
public:
XtsImplementation() {};
virtual ~XtsImplementation() {};
private:
XtsImplementation( const XtsImplementation & );
VOID operator=( const XtsImplementation & );
public:
virtual NTSTATUS setKey( PCBYTE pbKey, SIZE_T cbKey, UINT32 flags ) = 0;
virtual NTSTATUS encrypt(
SIZE_T cbDataUnit,
ULONGLONG tweak,
_In_reads_( cbData ) PCBYTE pbSrc,
_Out_writes_( cbData ) PBYTE pbDst,
SIZE_T cbData ) = 0;
// Return zero if success, NT status error if not supported.
virtual NTSTATUS decrypt(
SIZE_T cbDataUnit,
ULONGLONG tweak,
_In_reads_( cbData ) PCBYTE pbSrc,
_Out_writes_( cbData ) PBYTE pbDst,
SIZE_T cbData ) = 0;
// Return zero if success, NT status error if not supported.
virtual NTSTATUS encryptWith128bTweak(
SIZE_T cbDataUnit,
_In_reads_( SYMCRYPT_AES_BLOCK_SIZE ) PCBYTE pbTweak,
_In_reads_( cbData ) PCBYTE pbSrc,
_Out_writes_( cbData ) PBYTE pbDst,
SIZE_T cbData ) = 0;
// Return zero if success, NT status error if not supported.
virtual NTSTATUS decryptWith128bTweak(
SIZE_T cbDataUnit,
_In_reads_( SYMCRYPT_AES_BLOCK_SIZE ) PCBYTE pbTweak,
_In_reads_( cbData ) PCBYTE pbSrc,
_Out_writes_( cbData ) PBYTE pbDst,
SIZE_T cbData ) = 0;
// Return zero if success, NT status error if not supported.
};
class StreamCipherImplementation: public AlgorithmImplementation
{
public:
StreamCipherImplementation() {};
virtual ~StreamCipherImplementation() {};
private:
StreamCipherImplementation( const StreamCipherImplementation & );
VOID operator=( const StreamCipherImplementation & );
public:
virtual std::set<SIZE_T> getNonceSizes() = 0;
virtual std::set<SIZE_T> getKeySizes() = 0;
virtual NTSTATUS setKey( _In_reads_( cbKey ) PCBYTE pbKey, SIZE_T cbKey ) = 0;
virtual NTSTATUS setNonce( _In_reads_( cbNonce ) PCBYTE pbNonce, SIZE_T cbNonce ) = 0;
virtual BOOL isRandomAccess() = 0;
virtual VOID setOffset( UINT64 offset ) = 0;
virtual VOID encrypt(
_In_reads_( cbData ) PCBYTE pbSrc,
_Out_writes_( cbData ) PBYTE pbDst,
SIZE_T cbData ) = 0;
};
class RngSp800_90Implementation: public AlgorithmImplementation
{
public:
RngSp800_90Implementation() {};
virtual ~RngSp800_90Implementation() {};
private:
RngSp800_90Implementation( const RngSp800_90Implementation & );
VOID operator=( const RngSp800_90Implementation & );
public:
virtual NTSTATUS instantiate( _In_reads_( cbEntropy ) PCBYTE pbEntropy, SIZE_T cbEntropy ) = 0;
virtual NTSTATUS reseed( _In_reads_( cbEntropy ) PCBYTE pbEntropy, SIZE_T cbEntropy ) = 0;
virtual VOID generate( _Out_writes_( cbData ) PBYTE pbData, SIZE_T cbData ) = 0;
};
//
// KDF implementation
//
typedef enum _KDF_ARGUMENT_TYPE {
KdfArgumentGeneric = 1, // numeric values are used in KAT files, do not change.
KdfArgumentPbkdf2 = 2,
KdfArgumentSp800_108 = 3,
KdfArgumentTlsPrf = 4,
KdfArgumentHkdf = 5,
KdfArgumentSshKdf = 6,
KdfArgumentSrtpKdf = 7,
KdfArgumentSskdf = 8,
} KDF_ARGUMENT_TYPE;
typedef struct _KDF_GENERIC_ARGUMENTS {
PCBYTE pbSelector;
SIZE_T cbSelector;
} KDF_GENERIC_ARGUMENTS;
typedef struct _KDF_PBKDF2_ARGUMENTS {
PCBYTE pbSalt;
SIZE_T cbSalt;
ULONGLONG iterationCnt;
} KDF_PBKDF2_ARGUMENTS;
typedef struct _KDF_SP800_108_ARGUMENTS {
PCBYTE pbLabel;
SIZE_T cbLabel;
PCBYTE pbContext;
SIZE_T cbContext;
} KDF_SP800_108_ARGUMENTS;
typedef struct _KDF_TLSPRF_ARGUMENTS {
PCBYTE pbLabel;
SIZE_T cbLabel;
PCBYTE pbSeed;
SIZE_T cbSeed;
} KDF_TLSPRF_ARGUMENTS;
typedef struct _KDF_HKDF_ARGUMENTS {
PCBYTE pbSalt;
SIZE_T cbSalt;
PCBYTE pbInfo;
SIZE_T cbInfo;
} KDF_HKDF_ARGUMENTS;
typedef struct _KDF_SSHKDF_ARGUMENTS {
PCSTR hashName;
PCBYTE pbHashValue;
SIZE_T cbHashValue;
PCBYTE pbSessionId;
SIZE_T cbSessionId;
BYTE label;
} KDF_SSHKDF_ARGUMENTS;
typedef struct _KDF_SRTPKDF_ARGUMENTS {
PCBYTE pbSalt;
SIZE_T cbSalt;
UINT32 uKeyDerivationRate;
UINT64 uIndex;
UINT32 uIndexWidth;
BYTE label;
} KDF_SRTPKDF_ARGUMENTS;
typedef struct _KDF_SSKDF_ARGUMENTS {
PCBYTE pbSalt;
SIZE_T cbSalt;
PCBYTE pbInfo;
SIZE_T cbInfo;
} KDF_SSKDF_ARGUMENTS;
typedef struct _KDF_ARGUMENTS {
KDF_ARGUMENT_TYPE argType;
union {
KDF_GENERIC_ARGUMENTS uGeneric;
KDF_PBKDF2_ARGUMENTS uPbkdf2;
KDF_SP800_108_ARGUMENTS uSp800_108;
KDF_TLSPRF_ARGUMENTS uTlsPrf;
KDF_HKDF_ARGUMENTS uHkdf;
KDF_SSHKDF_ARGUMENTS uSshKdf;
KDF_SRTPKDF_ARGUMENTS uSrtpKdf;
KDF_SSKDF_ARGUMENTS uSskdf;
};
} KDF_ARGUMENTS, *PKDF_ARGUMENTS;
typedef const KDF_ARGUMENTS *PCKDF_ARGUMENTS;
class KdfImplementation: public AlgorithmImplementation
{
public:
KdfImplementation() {};
virtual ~KdfImplementation() {};
private:
KdfImplementation( const KdfImplementation & );
VOID operator=( const KdfImplementation & );
public:
virtual VOID derive(
_In_reads_( cbKey ) PCBYTE pbKey,
SIZE_T cbKey,
_In_ PKDF_ARGUMENTS args,
_Out_writes_( cbDst ) PBYTE pbDst,
SIZE_T cbDst ) = 0;
};
class TlsCbcHmacImplementation: public AlgorithmImplementation
{
public:
TlsCbcHmacImplementation() {};
~TlsCbcHmacImplementation() {};
private:
TlsCbcHmacImplementation( const TlsCbcHmacImplementation & );
VOID operator=( const TlsCbcHmacImplementation & );
public:
virtual NTSTATUS verify(
_In_reads_( cbKey ) PCBYTE pbKey,
SIZE_T cbKey,
_In_reads_( cbHeader ) PCBYTE pbHeader,
SIZE_T cbHeader,
_In_reads_( cbData ) PCBYTE pbData,
SIZE_T cbData ) = 0;
// Verify a TLS 1.2 CBC HMAC padded record in constant time
};
// ArithImplementation class is only used for performance measurement
class ArithImplementation: public AlgorithmImplementation
{
public:
ArithImplementation() {};
virtual ~ArithImplementation() {};
private:
ArithImplementation( const ArithImplementation & );
VOID operator=( const ArithImplementation & );
public:
};
// We need an implementation-independent way to store RSA keys
// As RSA key gen is so expensive, we generate a bunch of keys up front and use
// them for all tests.
#define RSAKEY_MAXKEYSIZE (1024) // 8192 bits = 1024 bytes
typedef struct _RSAKEY_TESTBLOB {
UINT32 nBitsModulus;
UINT64 u64PubExp;
UINT32 cbModulus;
UINT32 cbPrime1;
UINT32 cbPrime2;
BYTE abModulus[RSAKEY_MAXKEYSIZE];
BYTE abPrime1[RSAKEY_MAXKEYSIZE];
BYTE abPrime2[RSAKEY_MAXKEYSIZE];
// Only set in OpenSSL implementation right now.
BYTE abPrivateExp[RSAKEY_MAXKEYSIZE];
// And some fields to make debugging easier
const char * pcstrSource; // Where did this key come from
INT64 u64Line; // line # of test vector file (if applicable)
} RSAKEY_TESTBLOB, *PRSAKEY_TESTBLOB;
typedef const RSAKEY_TESTBLOB * PCRSAKEY_TESTBLOB;
class RsaSignImplementation: public AlgorithmImplementation
{
public:
RsaSignImplementation() {};
virtual ~RsaSignImplementation() {};
private:
RsaSignImplementation( const RsaSignImplementation & );
VOID operator=( const RsaSignImplementation & );
public:
virtual NTSTATUS setKey( PCRSAKEY_TESTBLOB pcKeyBlob ) = 0; // Returns an error if this key can't be handled.
// This is the abstraction that covers both PKCS1 and PSS. Both take a hash alg as parameter.
// We also add a salt size used for PSS.
virtual NTSTATUS sign(
_In_reads_( cbHash) PCBYTE pbHash,
SIZE_T cbHash,
PCSTR pcstrHashAlgName,
UINT32 u32Other,
_Out_writes_( cbSig ) PBYTE pbSig,
SIZE_T cbSig ) = 0; // cbSig == cbModulus of key
virtual NTSTATUS verify(
_In_reads_( cbHash) PCBYTE pbHash,
SIZE_T cbHash,
_In_reads_( cbSig ) PCBYTE pbSig,
SIZE_T cbSig,
PCSTR pcstrHashAlgName,
UINT32 u32Other ) = 0;
};
class RsaEncImplementation: public AlgorithmImplementation
{
public:
RsaEncImplementation() {};
virtual ~RsaEncImplementation() {};
private:
RsaEncImplementation( const RsaEncImplementation & );
VOID operator=( const RsaEncImplementation & );
public:
virtual NTSTATUS setKey( PCRSAKEY_TESTBLOB pcKeyBlob ) = 0; // Returns an error if this key can't be handled.
// This is the abstraction that covers RAW, PKCS1 and OAEP.
virtual NTSTATUS encrypt(
_In_reads_( cbMsg ) PCBYTE pbMsg,
SIZE_T cbMsg,
PCSTR pcstrHashAlgName,
PCBYTE pbLabel,
SIZE_T cbLabel,
_Out_writes_( cbCiphertext ) PBYTE pbCiphertext,
SIZE_T cbCiphertext ) = 0; // == cbModulus of key
virtual NTSTATUS decrypt(
_In_reads_( cbCiphertext ) PCBYTE pbCiphertext,
SIZE_T cbCiphertext,
PCSTR pcstrHashAlgName,
PCBYTE pbLabel,
SIZE_T cbLabel,
_Out_writes_to_(cbMsg,*pcbMsg) PBYTE pbMsg,
SIZE_T cbMsg,
SIZE_T *pcbMsg ) = 0;
};
#define DLKEY_MAXKEYSIZE (1024) // 8192 bits = 1024 bytes. Generating larger groups is too slow for testing
typedef struct _DLGROUP_TESTBLOB {
UINT32 nBitsP; // P = field prime, Q = subgroup order, G = generator
UINT32 cbPrimeP; //
UINT32 cbPrimeQ; // can be 0 if group order is not known
SYMCRYPT_DLGROUP_FIPS fipsStandard; // Which FIPS standard was used to generate this group
PCSYMCRYPT_HASH pHashAlgorithm; // Used for FIPS group generation
UINT32 cbSeed; // FIPS group generation seed
UINT32 genCounter; // FIPS group generation counter
BOOLEAN fHasPrimeQ; // Flag that specifies whether the object has a Q parameter
BOOLEAN isSafePrimeGroup; // Boolean indicating if this is a Safe Prime group
PCSTR pcstrHashAlgName; // Used for FIPS group generation in multi-implementation tests
BYTE abPrimeP[DLKEY_MAXKEYSIZE]; // cbPrimeP bytes
BYTE abPrimeQ[DLKEY_MAXKEYSIZE]; // cbPrimeQ bytes (optional)
BYTE abGenG[DLKEY_MAXKEYSIZE]; // cbPrimeP bytes
BYTE abSeed[DLKEY_MAXKEYSIZE]; // cbSeed bytes, cbSeed = 0 or cbSeed = cbPrimeQ
} DLGROUP_TESTBLOB, *PDLGROUP_TESTBLOB;
typedef const DLGROUP_TESTBLOB * PCDLGROUP_TESTBLOB;
typedef struct _DLKEY_TESTBLOB {
PCDLGROUP_TESTBLOB pGroup;
UINT32 nBitsPriv; // Non-zero value indicates Dlkey in DH safe-prime group with
// specified private key length
UINT32 cbPrivKey; //
BYTE abPubKey[DLKEY_MAXKEYSIZE]; // cbPrimeP bytes
BYTE abPrivKey[DLKEY_MAXKEYSIZE]; // cbPrivKey bytes
BOOL fPrivateModP; // private key in range [1,P-2] - not [1,Q-1]
} DLKEY_TESTBLOB, *PDLKEY_TESTBLOB;
typedef const DLKEY_TESTBLOB * PCDLKEY_TESTBLOB;
class DhImplementation: public AlgorithmImplementation
{
public:
DhImplementation() {};
virtual ~DhImplementation() {};
private:
DhImplementation( const DhImplementation & );
VOID operator=( const DhImplementation & );
public:
virtual NTSTATUS setKey(
_In_ PCDLKEY_TESTBLOB pcKeyBlob ) = 0; // Returns an error if this key can't be handled.
virtual NTSTATUS sharedSecret(
_In_ PCDLKEY_TESTBLOB pcPubkey, // Must be on same group object
_Out_writes_( cbSecret ) PBYTE pbSecret,
SIZE_T cbSecret ) = 0;
};
class DsaImplementation: public AlgorithmImplementation
{
public:
DsaImplementation() {};
virtual ~DsaImplementation() {};
private:
DsaImplementation( const DsaImplementation & );
VOID operator=( const DsaImplementation & );
public:
virtual NTSTATUS setKey(
_In_ PCDLKEY_TESTBLOB pcKeyBlob ) = 0; // Returns an error if this key can't be handled.
virtual NTSTATUS sign(
_In_reads_( cbHash) PCBYTE pbHash,
SIZE_T cbHash, // Can be any size, but often = size of Q
_Out_writes_( cbSig ) PBYTE pbSig,
SIZE_T cbSig ) = 0; // cbSig == 2 * cbPrimeQ of group
virtual NTSTATUS verify(
_In_reads_( cbHash) PCBYTE pbHash,
SIZE_T cbHash,
_In_reads_( cbSig ) PCBYTE pbSig,
SIZE_T cbSig ) = 0;
};
// RsaImplementation class is only used for performance measurements of RSA
/*
class RsaImplementation: public AlgorithmImplementation
{
public:
RsaImplementation() {};
virtual ~RsaImplementation() {};
private:
RsaImplementation( const RsaImplementation & );
VOID operator=( const RsaImplementation & );
public:
};
*/
// DlImplementation class is only used for performance measurements of Discrete Log group algorithms
class DlImplementation: public AlgorithmImplementation
{
public:
DlImplementation() {};
virtual ~DlImplementation() {};
private:
DlImplementation( const DlImplementation & );
VOID operator=( const DlImplementation & );
public:
};
// EccImplementation class is only used for performance measurements of elliptic curve cryptography
class EccImplementation: public AlgorithmImplementation
{
public:
EccImplementation() {};
virtual ~EccImplementation() {};
private:
EccImplementation( const EccImplementation & );
VOID operator=( const EccImplementation & );
public:
};
//////////////////////////////////////////////////////////////////////////////////
// Template classes for actual concrete implementations
//
//
// A template class to store the state of a hash implementation in.
//
template< class Implementation, class Algorithm> class HashImpState;
//
// A template class for the actual hash algorithm implementations
//
template< class Implementation, class Algorithm >
class HashImp: public HashImplementation
{
public:
HashImp();
virtual ~HashImp();
private:
HashImp( const HashImp & );
VOID operator=( const HashImp & );
public:
static const String s_algName; // Algorithm name
static const String s_modeName;
static const String s_impName; // Implementation name
virtual SIZE_T resultLen();
virtual SIZE_T inputBlockLen();
virtual void init();
virtual void append( _In_reads_( cbData ) PCBYTE pbData, SIZE_T cbData );
virtual void result( _Out_writes_( cbResult ) PBYTE pbResult, SIZE_T cbResult );
virtual VOID hash(
_In_reads_( cbData ) PCBYTE pbData,
SIZE_T cbData,
_Out_writes_( cbResult ) PBYTE pbResult,
SIZE_T cbResult );
virtual NTSTATUS initWithLongMessage( ULONGLONG nBytes );
virtual NTSTATUS exportSymCryptFormat(
_Out_writes_bytes_to_( cbResultBufferSize, *pcbResult ) PBYTE pbResult,
_In_ SIZE_T cbResultBufferSize,
_Out_ SIZE_T *pcbResult );
HashImpState<Implementation,Algorithm> state;
};
//
// A template class to store the state of a hash implementation in.
//
template< class Implementation, class Algorithm> class ParallelHashImpState;
//
// A template class for the actual hash algorithm implementations
//
template< class Implementation, class Algorithm >
class ParallelHashImp: public ParallelHashImplementation
{
public:
ParallelHashImp();
virtual ~ParallelHashImp();
private:
ParallelHashImp( const ParallelHashImp & );
VOID operator=( const ParallelHashImp & );
public:
static const String s_algName; // Algorithm name
static const String s_modeName;
static const String s_impName; // Implementation name
virtual PCSYMCRYPT_HASH SymCryptHash();
virtual SIZE_T resultLen();
virtual SIZE_T inputBlockLen();
virtual VOID init( SIZE_T nHashes );
virtual VOID process(
_In_reads_( nOperations ) BCRYPT_MULTI_HASH_OPERATION * pOperations,
SIZE_T nOperations );
virtual NTSTATUS initWithLongMessage( ULONGLONG nBytes );
ParallelHashImpState<Implementation,Algorithm> state;
};
//
// A template class to store the state of a XOF implementation in.
//
template< class Implementation, class Algorithm> class XofImpState;
//
// A template class for the actual XOF implementations
//
template< class Implementation, class Algorithm >
class XofImp: public XofImplementation
{
public:
XofImp();
virtual ~XofImp();
private:
XofImp( const XofImp & );
VOID operator=( const XofImp & );
public:
static const String s_algName; // Algorithm name
static const String s_modeName;
static const String s_impName; // Implementation name
virtual SIZE_T inputBlockLen();
virtual void init();
virtual void append( _In_reads_( cbData ) PCBYTE pbData, SIZE_T cbData );
virtual void extract( _Out_writes_( cbResult ) PBYTE pbResult, SIZE_T cbResult, BOOLEAN bWipe);
virtual void result( _Out_writes_( cbResult ) PBYTE pbResult, SIZE_T cbResult );
virtual VOID xof(
_In_reads_( cbData ) PCBYTE pbData,
SIZE_T cbData,
_Out_writes_( cbResult ) PBYTE pbResult,
SIZE_T cbResult );
XofImpState<Implementation,Algorithm> state;
};
//
// A template class to store the state of a customizable XOF implementation in.
//
template< class Implementation, class Algorithm> class CustomizableXofImpState;
//
// A template class for the actual XOF implementations
//
template< class Implementation, class Algorithm >
class CustomizableXofImp : public CustomizableXofImplementation
{
public:
CustomizableXofImp();
virtual ~CustomizableXofImp();
private:
CustomizableXofImp(const CustomizableXofImp&);
VOID operator=(const CustomizableXofImp&);
public:
static const String s_algName; // Algorithm name
static const String s_modeName;
static const String s_impName; // Implementation name
virtual SIZE_T inputBlockLen();
virtual void init(
_In_reads_( cbNstr ) PCBYTE pbNstr,
SIZE_T cbNstr,
_In_reads_( cbSstr ) PCBYTE pbSstr,
SIZE_T cbSstr);
virtual void append(_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData);
virtual void extract(_Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult, BOOLEAN bWipe);
virtual void result(_Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult);
virtual VOID xof(
_In_reads_( cbNstr ) PCBYTE pbNstr,
SIZE_T cbNstr,
_In_reads_( cbSstr ) PCBYTE pbSstr,
SIZE_T cbSstr,
_In_reads_( cbData ) PCBYTE pbData,
SIZE_T cbData,
_Out_writes_( cbResult ) PBYTE pbResult,
SIZE_T cbResult );
CustomizableXofImpState<Implementation, Algorithm> state;
};
//
// Template class to store the state of a MAC implementation
//
template< class Implementation, class Algorithm> class MacImpState;
//
// Template class for the actual MAC implementations
//
template< class Implementation, class Algorithm >
class MacImp: public MacImplementation
{
public:
MacImp();
virtual ~MacImp();
private:
MacImp( const MacImp & );
VOID operator=( const MacImp & );
public:
static const String s_algName;
static const String s_modeName;
static const String s_impName;
virtual SIZE_T resultLen();
virtual SIZE_T inputBlockLen();
virtual NTSTATUS init( _In_reads_( cbKey ) PCBYTE pbKey, SIZE_T cbKey );
virtual VOID append( _In_reads_( cbData ) PCBYTE pbData, SIZE_T cbData );
virtual VOID result( _Out_writes_( cbResult ) PBYTE pbResult, SIZE_T cbResult );
virtual NTSTATUS mac(
_In_reads_( cbKey ) PCBYTE pbKey,
SIZE_T cbKey,
_In_reads_( cbData ) PCBYTE pbData,
SIZE_T cbData,
_Out_writes_( cbResult ) PBYTE pbResult,
SIZE_T cbResult );
MacImpState<Implementation,Algorithm> state;
};
//
// A template class to store the state of a KMAC implementation in.
//
template< class Implementation, class Algorithm> class KmacImpState;
//
// Template class for the actual MAC implementations
//
template< class Implementation, class Algorithm >
class KmacImp : public KmacImplementation
{
public:
KmacImp();
virtual ~KmacImp();
private:
KmacImp(const KmacImp&);
VOID operator=(const KmacImp&);
public:
static const String s_algName;
static const String s_modeName;
static const String s_impName;
virtual SIZE_T inputBlockLen();
virtual VOID init(
_In_reads_(cbCustomizationStr) PCBYTE pbCustomizationStr,
SIZE_T cbCustomizationStr,
_In_reads_(cbKey) PCBYTE pbKey,
SIZE_T cbKey);
virtual VOID append(_In_reads_(cbData) PCBYTE pbData, SIZE_T cbData);
virtual VOID result(_Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult);
virtual VOID extract(_Out_writes_(cbResult) PBYTE pbResult, SIZE_T cbResult, BOOLEAN bWipe);
virtual VOID mac(
_In_reads_(cbCustomizationStr) PCBYTE pbCustomizationStr,
SIZE_T cbCustomizationStr,
_In_reads_(cbKey) PCBYTE pbKey,
SIZE_T cbKey,
_In_reads_(cbData) PCBYTE pbData,
SIZE_T cbData,
_Out_writes_(cbResult) PBYTE pbResult,
SIZE_T cbResult);
virtual VOID xof(
_In_reads_(cbCustomizationStr) PCBYTE pbCustomizationStr,
SIZE_T cbCustomizationStr,
_In_reads_(cbKey) PCBYTE pbKey,
SIZE_T cbKey,
_In_reads_(cbData) PCBYTE pbData,
SIZE_T cbData,
_Out_writes_(cbResult) PBYTE pbResult,
SIZE_T cbResult);
KmacImpState<Implementation, Algorithm> state;
};
template< class Implementation, class Algorithm, class Mode > class BlockCipherImpState;
template< class Implementation, class Algorithm, class Mode >
class BlockCipherImp: public BlockCipherImplementation
{
public:
BlockCipherImp();
virtual ~BlockCipherImp();
private:
BlockCipherImp( const BlockCipherImp & );
VOID operator=( const BlockCipherImp & );
public:
static const String s_algName;
static const String s_modeName;
static const String s_impName;
virtual SIZE_T msgBlockLen(); // block length of mode (msg must be multiple of this)
virtual SIZE_T chainBlockLen(); // length of chaining field
virtual SIZE_T coreBlockLen(); // block length of underlying cipher
virtual NTSTATUS setKey( _In_reads_( cbKey ) PCBYTE pbKey, SIZE_T cbKey );
virtual VOID encrypt(
_Inout_updates_opt_( cbChain ) PBYTE pbChain,
SIZE_T cbChain,
_In_reads_( cbData ) PCBYTE pbSrc,
_Out_writes_( cbData ) PBYTE pbDst,
SIZE_T cbData );
virtual VOID decrypt(
_Inout_updates_opt_( cbChain ) PBYTE pbChain,
SIZE_T cbChain,
_In_reads_( cbData ) PCBYTE pbSrc,
_Out_writes_( cbData ) PBYTE pbDst,
SIZE_T cbData );
BlockCipherImpState< Implementation, Algorithm, Mode > state;
};
template< class Implementation, class Algorithm > class XtsImpState;
template< class Implementation, class Algorithm >
class XtsImp: public XtsImplementation
{
public:
XtsImp();
virtual ~XtsImp();
private:
XtsImp( const XtsImp & );
VOID operator=( const XtsImp & );
public:
static const String s_algName;
static const String s_modeName;
static const String s_impName;
virtual NTSTATUS setKey( PCBYTE pbKey, SIZE_T cbKey, UINT32 flags );
virtual NTSTATUS encrypt(
SIZE_T cbDataUnit,
ULONGLONG tweak,
_In_reads_( cbData ) PCBYTE pbSrc,
_Out_writes_( cbData ) PBYTE pbDst,
SIZE_T cbData );
// Return zero if success, NT status error if not supported.
virtual NTSTATUS decrypt(
SIZE_T cbDataUnit,
ULONGLONG tweak,
_In_reads_( cbData ) PCBYTE pbSrc,
_Out_writes_( cbData ) PBYTE pbDst,
SIZE_T cbData );
// Return zero if success, NT status error if not supported.
virtual NTSTATUS encryptWith128bTweak(
SIZE_T cbDataUnit,
_In_reads_( SYMCRYPT_AES_BLOCK_SIZE ) PCBYTE pbTweak,
_In_reads_( cbData ) PCBYTE pbSrc,
_Out_writes_( cbData ) PBYTE pbDst,
SIZE_T cbData );
// Return zero if success, NT status error if not supported.
virtual NTSTATUS decryptWith128bTweak(
SIZE_T cbDataUnit,
_In_reads_( SYMCRYPT_AES_BLOCK_SIZE ) PCBYTE pbTweak,
_In_reads_( cbData ) PCBYTE pbSrc,
_Out_writes_( cbData ) PBYTE pbDst,
SIZE_T cbData );
// Return zero if success, NT status error if not supported.
XtsImpState< Implementation, Algorithm > state;
};
template< class Implementation, class Algorithm, class Mode >
SIZE_T BlockCipherImp<Implementation, Algorithm, Mode>::chainBlockLen()
{
if( (Mode::flags & MODE_FLAG_CHAIN) == 0 )
{
return 0;
}
return coreBlockLen();
}
template< class Implementation, class Algorithm, class Mode >
SIZE_T BlockCipherImp<Implementation, Algorithm, Mode>::msgBlockLen()
{
if( (Mode::flags & MODE_FLAG_CFB) != 0 )
{
return g_modeCfbShiftParam;
}
return coreBlockLen();
}
template< class Implementation, class Algorithm, class Mode> class AuthEncImpState;
template< class Implementation, class Algorithm, class Mode >
class AuthEncImp: public AuthEncImplementation
{
public:
AuthEncImp();
virtual ~AuthEncImp();
PVOID operator new( size_t size )
{
return std::malloc( size );
}
VOID operator delete( PVOID p )
{
std::free( p );
}
private:
AuthEncImp( const AuthEncImp & );
VOID operator=( const AuthEncImp & );
public:
static const String s_algName;
static const String s_modeName;
static const String s_impName;
virtual std::set<SIZE_T> getNonceSizes();
virtual std::set<SIZE_T> getTagSizes();
virtual std::set<SIZE_T> getKeySizes();
virtual NTSTATUS setKey( PCBYTE pbKey, SIZE_T cbKey );
virtual VOID setTotalCbData( SIZE_T cbData );
virtual NTSTATUS encrypt(
_In_reads_( cbNonce ) PCBYTE pbNonce,
SIZE_T cbNonce,
_In_reads_( cbAuthData ) PCBYTE pbAuthData,
SIZE_T cbAuthData,
_In_reads_( cbData ) PCBYTE pbSrc,
_Out_writes_( cbData ) PBYTE pbDst,
SIZE_T cbData,
_Out_writes_( cbTag ) PBYTE pbTag,
SIZE_T cbTag,
ULONG flags );
// returns an error only if the request is not supported; only allowed for partial requests.
virtual NTSTATUS decrypt(
_In_reads_( cbNonce ) PCBYTE pbNonce,
SIZE_T cbNonce,
_In_reads_( cbAuthData ) PCBYTE pbAuthData,
SIZE_T cbAuthData,
_In_reads_( cbData ) PCBYTE pbSrc,
_Out_writes_( cbData ) PBYTE pbDst,
SIZE_T cbData,
_In_reads_( cbTag ) PCBYTE pbTag,
SIZE_T cbTag,
ULONG flags );
// returns STATUS_AUTH_TAG_MISMATCH if the tag is wrong.
// returns STATUS_NOT_SUPPORTED if the request is not supported (only for partial requests)
AuthEncImpState< Implementation, Algorithm, Mode > state;
};
template< class Implementation, class Algorithm> class StreamCipherImpState;
template< class Implementation, class Algorithm>
class StreamCipherImp: public StreamCipherImplementation
{
public:
StreamCipherImp();
virtual ~StreamCipherImp();
private:
StreamCipherImp( const StreamCipherImp & );
VOID operator=( const StreamCipherImp & );
public:
static const String s_impName;
static const String s_modeName;
static const String s_algName;
static const BOOL s_isRandomAccess;
virtual std::set<SIZE_T> getNonceSizes();
virtual std::set<SIZE_T> getKeySizes();
virtual NTSTATUS setKey( _In_reads_( cbKey ) PCBYTE pbKey, SIZE_T cbKey );
virtual NTSTATUS setNonce( _In_reads_( cbNonce ) PCBYTE pbNonce, SIZE_T cbNonce );
virtual BOOL isRandomAccess() { return s_isRandomAccess; };
virtual VOID setOffset( UINT64 offset );
virtual VOID encrypt(
_In_reads_( cbData ) PCBYTE pbSrc,
_Out_writes_( cbData ) PBYTE pbDst,
SIZE_T cbData );
StreamCipherImpState< Implementation, Algorithm> state;
};
template< class Implementation, class Algorithm> class RngSp800_90ImpState;
template< class Implementation, class Algorithm>
class RngSp800_90Imp: public RngSp800_90Implementation
{
public:
RngSp800_90Imp();
virtual ~RngSp800_90Imp();
private:
RngSp800_90Imp( const RngSp800_90Imp & );
VOID operator=( const RngSp800_90Imp & );
public:
static const String s_impName;
static const String s_modeName;
static const String s_algName;
virtual NTSTATUS instantiate( _In_reads_( cbEntropy ) PCBYTE pbEntropy, SIZE_T cbEntropy ) ;
virtual NTSTATUS reseed( _In_reads_( cbEntropy ) PCBYTE pbEntropy, SIZE_T cbEntropy );
virtual VOID generate( _Out_writes_( cbData ) PBYTE pbData, SIZE_T cbData );
RngSp800_90ImpState< Implementation, Algorithm> state;
};
template< class Implementation, class Algorithm, class BaseAlg > class KdfImpState;
template< class Implementation, class Algorithm, class BaseAlg >
class KdfImp: public KdfImplementation
{
public:
KdfImp();
virtual ~KdfImp();
private:
KdfImp( const KdfImp & );
VOID operator=( const KdfImp & );
public:
static const String s_impName;
static const String s_modeName;
static const String s_algName;
virtual VOID derive(
_In_reads_( cbKey ) PCBYTE pbKey,
SIZE_T cbKey,
_In_ PKDF_ARGUMENTS args,
_Out_writes_( cbDst ) PBYTE pbDst,
SIZE_T cbDst );
KdfImpState<Implementation,Algorithm,BaseAlg> state;
};
template< class Implementation, class Algorithm >
class TlsCbcHmacImp: public TlsCbcHmacImplementation
{
public:
TlsCbcHmacImp();
virtual ~TlsCbcHmacImp();
private:
TlsCbcHmacImp( const TlsCbcHmacImp & );
VOID operator=( const TlsCbcHmacImp & );
public:
static const String s_algName;
static const String s_modeName;
static const String s_impName;
virtual NTSTATUS verify(
_In_reads_( cbKey ) PCBYTE pbKey,
SIZE_T cbKey,
_In_reads_( cbHeader ) PCBYTE pbHeader,
SIZE_T cbHeader,
_In_reads_( cbData ) PCBYTE pbData,
SIZE_T cbData );
};
template< class Implementation, class Algorithm>
class ArithImp: public ArithImplementation
{
public:
ArithImp();
virtual ~ArithImp();
private:
ArithImp( const ArithImp & );
VOID operator=( const ArithImp & );
public:
static const String s_impName;
static const String s_modeName;
static const String s_algName;
};
/*
template< class Implementation, class Algorithm>
class RsaImp: public RsaImplementation
{
public:
RsaImp();
virtual ~RsaImp();
private:
RsaImp( const RsaImp & );
VOID operator=( const RsaImp & );
public:
static const String s_impName;
static const String s_modeName;
static const String s_algName;
};
*/
template< class Implementation, class Algorithm>
class DlImp: public DlImplementation
{
public:
DlImp();
virtual ~DlImp();
private:
DlImp( const DlImp & );
VOID operator=( const DlImp & );
public:
static const String s_impName;
static const String s_modeName;
static const String s_algName;
};
template< class Implementation, class Algorithm > class RsaSignImpState;
template< class Implementation, class Algorithm>
class RsaSignImp: public RsaSignImplementation
{
public:
RsaSignImp();
virtual ~RsaSignImp();
private:
RsaSignImp( const RsaSignImp & );
VOID operator=( const RsaSignImp & );
public:
static const String s_algName; // Algorithm name
static const String s_modeName;
static const String s_impName; // Implementation name
virtual NTSTATUS setKey( PCRSAKEY_TESTBLOB pcKeyBlob );
virtual NTSTATUS sign(
_In_reads_( cbHash) PCBYTE pbHash,
SIZE_T cbHash,
PCSTR pcstrHashAlgName,
UINT32 u32Other,
_Out_writes_( cbSig ) PBYTE pbSig,
SIZE_T cbSig );
virtual NTSTATUS verify(
_In_reads_( cbHash) PCBYTE pbHash,
SIZE_T cbHash,
_In_reads_( cbSig ) PCBYTE pbSig,
SIZE_T cbSig,
PCSTR pcstrHashAlgName,
UINT32 u32Other );
RsaSignImpState<Implementation,Algorithm> state;
};
template< class Implementation, class Algorithm > class RsaEncImpState;
template< class Implementation, class Algorithm>
class RsaEncImp: public RsaEncImplementation
{
public:
RsaEncImp();
virtual ~RsaEncImp();
private:
RsaEncImp( const RsaEncImp & );
VOID operator=( const RsaEncImp & );
public:
static const String s_algName; // Algorithm name
static const String s_modeName;
static const String s_impName; // Implementation name
virtual NTSTATUS setKey( PCRSAKEY_TESTBLOB pcKeyBlob );
virtual NTSTATUS encrypt(
_In_reads_( cbMsg ) PCBYTE pbMsg,
SIZE_T cbMsg,
PCSTR pcstrHashAlgName,
PCBYTE pbLabel,
SIZE_T cbLabel,
_Out_writes_( cbCiphertext ) PBYTE pbCiphertext,
SIZE_T cbCiphertext ); // == cbModulus of key
virtual NTSTATUS decrypt(
_In_reads_( cbCiphertext ) PCBYTE pbCiphertext,
SIZE_T cbCiphertext,
PCSTR pcstrHashAlgName,
PCBYTE pbLabel,
SIZE_T cbLabel,
_Out_writes_to_(cbMsg,*pcbMsg) PBYTE pbMsg,
SIZE_T cbMsg,
SIZE_T *pcbMsg );
RsaEncImpState<Implementation,Algorithm> state;
};
template< class Implementation, class Algorithm > class DhImpState;
template< class Implementation, class Algorithm>
class DhImp: public DhImplementation
{
public:
DhImp();
virtual ~DhImp();
private:
DhImp( const DhImp & );
VOID operator=( const DhImp & );
public:
static const String s_algName; // Algorithm name
static const String s_modeName;
static const String s_impName; // Implementation name
virtual NTSTATUS setKey(
_In_ PCDLKEY_TESTBLOB pcKeyBlob );
virtual NTSTATUS sharedSecret(
_In_ PCDLKEY_TESTBLOB pcPubkey,
_Out_writes_( cbSecret ) PBYTE pbSecret,
SIZE_T cbSecret );
DhImpState<Implementation,Algorithm> state;
};
template< class Implementation, class Algorithm > class DsaImpState;
template< class Implementation, class Algorithm>
class DsaImp: public DsaImplementation
{
public:
DsaImp();
virtual ~DsaImp();
private:
DsaImp( const DsaImp & );
VOID operator=( const DsaImp & );
public:
static const String s_algName; // Algorithm name
static const String s_modeName;
static const String s_impName; // Implementation name
virtual NTSTATUS setKey(
_In_ PCDLKEY_TESTBLOB pcKeyBlob ); // Returns an error if this key can't be handled.
virtual NTSTATUS sign(
_In_reads_( cbHash) PCBYTE pbHash,
SIZE_T cbHash, // Can be any size, but often = size of Q
_Out_writes_( cbSig ) PBYTE pbSig,
SIZE_T cbSig ); // cbSig == cbModulus of group
virtual NTSTATUS verify(
_In_reads_( cbHash) PCBYTE pbHash,
SIZE_T cbHash,
_In_reads_( cbSig ) PCBYTE pbSig,
SIZE_T cbSig );
DsaImpState<Implementation,Algorithm> state;
};
template< class Implementation, class Algorithm>
class EccImp: public EccImplementation
{
public:
EccImp();
virtual ~EccImp();
private:
EccImp( const EccImp & );
VOID operator=( const EccImp & );
public:
static const String s_impName;
static const String s_modeName;
static const String s_algName;
};
class KemImplementation : public AlgorithmImplementation
{
public:
KemImplementation() {};
virtual ~KemImplementation() {};
private:
KemImplementation( const KemImplementation & );
VOID operator=( const KemImplementation & );
public:
virtual NTSTATUS setKeyFromTestBlob(
_In_reads_bytes_( cbTestKeyBlob ) PCBYTE pcbTestKeyBlob,
SIZE_T cbTestKeyBlob,
BOOL canDecapsulate ) = 0;
virtual NTSTATUS getBlobFromKey(
UINT32 blobType,
_Out_writes_bytes_( cbBlob ) PBYTE pbBlob,
SIZE_T cbBlob ) = 0;
virtual NTSTATUS encapsulate(
_Out_writes_bytes_( cbAgreedSecret ) PBYTE pbAgreedSecret,
SIZE_T cbAgreedSecret,
_Out_writes_bytes_( cbCiphertext ) PBYTE pbCiphertext,
SIZE_T cbCiphertext ) = 0;
virtual NTSTATUS encapsulateEx(
_In_reads_bytes_( cbRandom ) PCBYTE pbRandom,
SIZE_T cbRandom,
_Out_writes_bytes_( cbAgreedSecret ) PBYTE pbAgreedSecret,
SIZE_T cbAgreedSecret,
_Out_writes_bytes_( cbCiphertext ) PBYTE pbCiphertext,
SIZE_T cbCiphertext ) = 0;
virtual NTSTATUS decapsulate(
_In_reads_bytes_( cbCiphertext ) PCBYTE pbCiphertext,
SIZE_T cbCiphertext,
_Out_writes_bytes_( cbAgreedSecret ) PBYTE pbAgreedSecret,
SIZE_T cbAgreedSecret ) = 0;
};
// Currently maximum key blob size is ML-KEM1024 decapsulation key blob
#define MAX_MLKEMKEY_BLOB_SIZE (3168)
typedef struct _MLKEMKEY_TESTBLOB
{
SYMCRYPT_MLKEM_PARAMS params; // represents the parameter set of ML-KEM
SYMCRYPT_MLKEMKEY_FORMAT format; // represents the format of the ML-KEM key blob
BYTE abKeyBlob[MAX_MLKEMKEY_BLOB_SIZE]; // byte blob representing an ML-KEM key
SIZE_T cbKeyBlob;
} MLKEMKEY_TESTBLOB, *PMLKEMKEY_TESTBLOB;
typedef const MLKEMKEY_TESTBLOB * PCMLKEMKEY_TESTBLOB;
template< class Implementation, class Algorithm > class KemImpState;
template< class Implementation, class Algorithm >
class KemImp : public KemImplementation
{
public:
KemImp();
virtual ~KemImp();
private:
KemImp( const KemImp & );
VOID operator=( const KemImp & );
public:
static const String s_algName; // Algorithm name
static const String s_modeName;
static const String s_impName; // Implementation name
virtual NTSTATUS setKeyFromTestBlob(
_In_reads_bytes_( cbTestKeyBlob ) PCBYTE pcbTestKeyBlob,
SIZE_T cbTestKeyBlob,
BOOL canDecapsulate );
virtual NTSTATUS getBlobFromKey(
UINT32 blobType,
_Out_writes_bytes_( cbBlob ) PBYTE pbBlob,
SIZE_T cbBlob );
virtual NTSTATUS encapsulate(
_Out_writes_bytes_( cbAgreedSecret ) PBYTE pbAgreedSecret,
SIZE_T cbAgreedSecret,
_Out_writes_bytes_( cbCiphertext ) PBYTE pbCiphertext,
SIZE_T cbCiphertext );
virtual NTSTATUS encapsulateEx(
_In_reads_bytes_( cbRandom ) PCBYTE pbRandom,
SIZE_T cbRandom,
_Out_writes_bytes_( cbAgreedSecret ) PBYTE pbAgreedSecret,
SIZE_T cbAgreedSecret,
_Out_writes_bytes_( cbCiphertext ) PBYTE pbCiphertext,
SIZE_T cbCiphertext );
virtual NTSTATUS decapsulate(
_In_reads_bytes_( cbCiphertext ) PCBYTE pbCiphertext,
SIZE_T cbCiphertext,
_Out_writes_bytes_( cbAgreedSecret ) PBYTE pbAgreedSecret,
SIZE_T cbAgreedSecret );
KemImpState<Implementation,Algorithm> state;
};
// Hash-Based Signatures
class HbsImplementation : public AlgorithmImplementation
{
public:
HbsImplementation() {};
virtual ~HbsImplementation() {};
private:
HbsImplementation(const HbsImplementation&);
VOID operator=(const HbsImplementation&);
public:
virtual NTSTATUS setKey(
UINT32 uAlgId,
BOOL fMultitree,
_In_reads_bytes_(cbSrc) PCBYTE pbSrc,
SIZE_T cbSrc,
BOOL fVerify ) = 0;
// Set an XMSS key from algorithm identifier and key blob.
//
// If fVerify is TRUE then this function computes the public root
// from the private key -only if the key is private- and compares
// it to the public root that is in the private key.
virtual NTSTATUS sign(
_In_reads_bytes_(cbMsg) PCBYTE pbMsg,
SIZE_T cbMsg,
_Out_writes_bytes_(cbSignature) PBYTE pbSignature,
SIZE_T cbSignature ) = 0;
// Sign a message using the private key initialized by setKey()
virtual NTSTATUS verify(
_In_reads_bytes_(cbMsg) PCBYTE pbMsg,
SIZE_T cbMsg,
_In_reads_bytes_(cbSignature) PCBYTE pbSignature,
SIZE_T cbSignature ) = 0;
// Verify a signature on a message using the private key initialized
// by setKey()
};
//
// A template class to store the state of an XMSS implementation in.
//
template<class Implementation, class Algorithm> class XmssImpState;
//
// Template class for the actual XMSS implementations
//
template< class Implementation, class Algorithm >
class XmssImp : public HbsImplementation
{
public:
XmssImp();
virtual ~XmssImp();
private:
XmssImp(const XmssImp&);
VOID operator=(const XmssImp&);
public:
virtual NTSTATUS setKey(
UINT32 uAlgId,
BOOL fMultitree,
_In_reads_bytes_(cbSrc) PCBYTE pbSrc,
SIZE_T cbSrc,
BOOL fVerify );
virtual NTSTATUS sign(
_In_reads_bytes_(cbMsg) PCBYTE pbMsg,
SIZE_T cbMsg,
_Out_writes_bytes_(cbSignature) PBYTE pbSignature,
SIZE_T cbSignature ) ;
virtual NTSTATUS verify(
_In_reads_bytes_(cbMsg) PCBYTE pbMsg,
SIZE_T cbMsg,
_In_reads_bytes_(cbSignature) PCBYTE pbSignature,
SIZE_T cbSignature );
static const String s_algName;
static const String s_modeName;
static const String s_impName;
XmssImpState<Implementation, Algorithm> state;
};
//
// The stub classes we use to distinguish our implementations and algorithms contain the
// name of said implementation/algorithm. We use this to auto-define the algorithm name
// and implementation name of the *Imp<imp,alg> classes.
//
template< class Implementation, class Algorithm >
const String HashImp<Implementation,Algorithm>::s_algName = Algorithm::name;
template< class Implementation, class Algorithm >
const String HashImp<Implementation,Algorithm>::s_modeName;
template< class Implementation, class Algorithm >
const String HashImp<Implementation,Algorithm>::s_impName = Implementation::name;
template< class Implementation, class Algorithm >
const String ParallelHashImp<Implementation,Algorithm>::s_algName = Algorithm::name;
template< class Implementation, class Algorithm >
const String ParallelHashImp<Implementation,Algorithm>::s_modeName;
template< class Implementation, class Algorithm >
const String ParallelHashImp<Implementation,Algorithm>::s_impName = Implementation::name;
template< class Implementation, class Algorithm >
const String XofImp<Implementation,Algorithm>::s_algName = Algorithm::name;
template< class Implementation, class Algorithm >
const String XofImp<Implementation,Algorithm>::s_modeName;
template< class Implementation, class Algorithm >
const String XofImp<Implementation,Algorithm>::s_impName = Implementation::name;
template< class Implementation, class Algorithm >
const String CustomizableXofImp<Implementation,Algorithm>::s_algName = Algorithm::name;
template< class Implementation, class Algorithm >
const String CustomizableXofImp<Implementation,Algorithm>::s_modeName;
template< class Implementation, class Algorithm >
const String CustomizableXofImp<Implementation,Algorithm>::s_impName = Implementation::name;
template< class Implementation, class Algorithm >
const String KmacImp<Implementation,Algorithm>::s_algName = Algorithm::name;
template< class Implementation, class Algorithm >
const String KmacImp<Implementation,Algorithm>::s_modeName;
template< class Implementation, class Algorithm >
const String KmacImp<Implementation,Algorithm>::s_impName = Implementation::name;
template< class Implementation, class Algorithm >
const String MacImp<Implementation,Algorithm>::s_algName = Algorithm::name;
template< class Implementation, class Algorithm >
const String MacImp<Implementation,Algorithm>::s_modeName;
template< class Implementation, class Algorithm >
const String MacImp<Implementation,Algorithm>::s_impName = Implementation::name;
template< class Implementation, class Algorithm, class Mode >
const String BlockCipherImp<Implementation,Algorithm,Mode>::s_algName = Algorithm::name ;
template< class Implementation, class Algorithm, class Mode >
const String BlockCipherImp<Implementation,Algorithm,Mode>::s_modeName = Mode::name ;
template< class Implementation, class Algorithm, class Mode >
const String BlockCipherImp<Implementation,Algorithm,Mode>::s_impName = Implementation::name;
template< class Implementation, class Algorithm, class Mode >
const String AuthEncImp<Implementation, Algorithm, Mode>::s_algName = Algorithm::name;
template< class Implementation, class Algorithm, class Mode >
const String AuthEncImp<Implementation,Algorithm,Mode>::s_modeName = Mode::name ;
template< class Implementation, class Algorithm, class Mode >
const String AuthEncImp<Implementation,Algorithm,Mode>::s_impName = Implementation::name;
template< class Implementation, class Algorithm>
const String StreamCipherImp<Implementation,Algorithm>::s_algName = Algorithm::name;
template< class Implementation, class Algorithm>
const String StreamCipherImp<Implementation,Algorithm>::s_modeName;
template< class Implementation, class Algorithm>
const String StreamCipherImp<Implementation,Algorithm>::s_impName = Implementation::name;
template< class Implementation, class Algorithm>
const BOOL StreamCipherImp<Implementation,Algorithm>::s_isRandomAccess = Algorithm::isRandomAccess;
template< class Implementation, class Algorithm>
const String RngSp800_90Imp<Implementation,Algorithm>::s_algName = Algorithm::name;
template< class Implementation, class Algorithm>
const String RngSp800_90Imp<Implementation,Algorithm>::s_modeName;
template< class Implementation, class Algorithm>
const String RngSp800_90Imp<Implementation,Algorithm>::s_impName = Implementation::name;
template< class Implementation, class Algorithm, class BaseAlg >
const String KdfImp<Implementation,Algorithm,BaseAlg>::s_algName = Algorithm::name;
template< class Implementation, class Algorithm, class BaseAlg >
const String KdfImp<Implementation,Algorithm,BaseAlg>::s_modeName = BaseAlg::name;
template< class Implementation, class Algorithm, class BaseAlg >
const String KdfImp<Implementation,Algorithm,BaseAlg>::s_impName = Implementation::name;
template< class Implementation, class Algorithm>
const String XtsImp<Implementation, Algorithm>::s_impName = Implementation::name;
template< class Implementation, class Algorithm>
const String XtsImp<Implementation, Algorithm>::s_algName = Algorithm::name;
template< class Implementation, class Algorithm>
const String XtsImp<Implementation, Algorithm>::s_modeName;
template< class Implementation, class Algorithm>
const String TlsCbcHmacImp<Implementation, Algorithm>::s_impName = Implementation::name;
template< class Implementation, class Algorithm>
const String TlsCbcHmacImp<Implementation, Algorithm>::s_algName = Algorithm::name;
template< class Implementation, class Algorithm>
const String TlsCbcHmacImp<Implementation, Algorithm>::s_modeName;
template< class Implementation, class Algorithm>
const String ArithImp<Implementation, Algorithm>::s_impName = Implementation::name;
template< class Implementation, class Algorithm>
const String ArithImp<Implementation, Algorithm>::s_algName = Algorithm::name;
template< class Implementation, class Algorithm>
const String ArithImp<Implementation, Algorithm>::s_modeName;
/*
template< class Implementation, class Algorithm>
const String RsaImp<Implementation, Algorithm>::s_impName = Implementation::name;
template< class Implementation, class Algorithm>
const String RsaImp<Implementation, Algorithm>::s_algName = Algorithm::name;
template< class Implementation, class Algorithm>
const String RsaImp<Implementation, Algorithm>::s_modeName;
*/
template< class Implementation, class Algorithm>
const String DlImp<Implementation, Algorithm>::s_impName = Implementation::name;
template< class Implementation, class Algorithm>
const String DlImp<Implementation, Algorithm>::s_algName = Algorithm::name;
template< class Implementation, class Algorithm>
const String DlImp<Implementation, Algorithm>::s_modeName;
template< class Implementation, class Algorithm>
const String EccImp<Implementation, Algorithm>::s_impName = Implementation::name;
template< class Implementation, class Algorithm>
const String EccImp<Implementation, Algorithm>::s_algName = Algorithm::name;
template< class Implementation, class Algorithm>
const String EccImp<Implementation, Algorithm>::s_modeName;
template< class Imp, class Alg>
const String RsaSignImp<Imp,Alg>::s_impName = Imp::name;
template< class Imp, class Alg>
const String RsaSignImp<Imp,Alg>::s_algName = Alg::name;
template< class Imp, class Alg>
const String RsaSignImp<Imp,Alg>::s_modeName;
template< class Imp, class Alg>
const String RsaEncImp<Imp,Alg>::s_impName = Imp::name;
template< class Imp, class Alg>
const String RsaEncImp<Imp,Alg>::s_algName = Alg::name;
template< class Imp, class Alg>
const String RsaEncImp<Imp,Alg>::s_modeName;
template< class Imp, class Alg>
const String DhImp<Imp,Alg>::s_impName = Imp::name;
template< class Imp, class Alg>
const String DhImp<Imp,Alg>::s_algName = Alg::name;
template< class Imp, class Alg>
const String DhImp<Imp,Alg>::s_modeName;
template< class Imp, class Alg>
const String DsaImp<Imp,Alg>::s_impName = Imp::name;
template< class Imp, class Alg>
const String DsaImp<Imp,Alg>::s_algName = Alg::name;
template< class Imp, class Alg>
const String DsaImp<Imp,Alg>::s_modeName;
template< class Implementation, class Algorithm >
const String XmssImp<Implementation,Algorithm>::s_algName = Algorithm::name;
template< class Implementation, class Algorithm >
const String XmssImp<Implementation,Algorithm>::s_modeName;
template< class Implementation, class Algorithm >
const String XmssImp<Implementation,Algorithm>::s_impName = Implementation::name;
template< class Imp, class Alg>
const String KemImp<Imp,Alg>::s_impName = Imp::name;
template< class Imp, class Alg>
const String KemImp<Imp,Alg>::s_algName = Alg::name;
template< class Imp, class Alg>
const String KemImp<Imp,Alg>::s_modeName;
//
// Template declaration for performance functions (for those implementations that wish to use them)
//
template< class Implementation, class Algorithm >
VOID algImpKeyPerfFunction( PBYTE buf1, PBYTE buf2, PBYTE buf3, SIZE_T keySize );
template< class Implementation, class Algorithm, class Mode >
VOID algImpKeyPerfFunction( PBYTE buf1, PBYTE buf2, PBYTE buf3, SIZE_T keySize );
template< class Implementation, class Algorithm >
VOID algImpDataPerfFunction( PBYTE buf1, PBYTE buf2, PBYTE buf3, SIZE_T dataSize );
template< class Implementation, class Algorithm, class Mode >
VOID algImpDataPerfFunction( PBYTE buf1, PBYTE buf2, PBYTE buf3, SIZE_T dataSize );
template< class Implementation, class Algorithm >
VOID algImpDecryptPerfFunction( PBYTE buf1, PBYTE buf2, PBYTE buf3, SIZE_T dataSize );
template< class Implementation, class Algorithm, class Mode >
VOID algImpDecryptPerfFunction( PBYTE buf1, PBYTE buf2, PBYTE buf3, SIZE_T dataSize );
template< class Implementation, class Algorithm >
VOID algImpCleanPerfFunction( PBYTE buf1, PBYTE buf2, PBYTE buf3 );
template< class Implementation, class Algorithm, class Mode >
VOID algImpCleanPerfFunction( PBYTE buf1, PBYTE buf2, PBYTE buf3 );
;
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку