implglue.h File Reference

#include "symcrypt.h"
#include "symcrypt_low_level.h"

Include dependency graph for implglue.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	rsa_key
union	tagKEY_CONTEXT
struct	hash< _Key >

Macros
#define	RSAENH_MAX_HASH_SIZE   104

Typedefs
typedef union tagKEY_CONTEXT	KEY_CONTEXT

Functions
BOOL	init_hash_impl (ALG_ID algid, struct hash *hash)
static void	update_hash_impl (struct hash *hash, const BYTE *data, DWORD len)
static void	finalize_hash_impl (struct hash *hash, BYTE *hash_value, DWORD hash_size)
static DWORD	hash_len_impl (const struct hash *hash)
static DWORD	hash_block_len_impl (const struct hash *hash)
BOOL	new_key_impl (ALG_ID algid, KEY_CONTEXT *ctx, DWORD keylen)
BOOL	free_key_impl (ALG_ID algid, KEY_CONTEXT *ctx)
BOOL	setup_key_impl (ALG_ID algid, KEY_CONTEXT *ctx, DWORD keylen, DWORD effective_keylen, DWORD saltlen, const BYTE *keyvalue)
BOOL	duplicate_key_impl (ALG_ID algid, const KEY_CONTEXT *src, KEY_CONTEXT *dst)
BOOL	encrypt_block_impl (ALG_ID algid, KEY_CONTEXT *ctx, const BYTE *in, BYTE *out)
BOOL	decrypt_block_impl (ALG_ID algid, KEY_CONTEXT *ctx, const BYTE *in, BYTE *out)
BOOL	encrypt_stream_impl (ALG_ID algid, KEY_CONTEXT *ctx, BYTE *inout, DWORD len)
BOOL	sign_hash_impl (KEY_CONTEXT *ctx, const BYTE *in, BYTE *out)
BOOL	verify_signature_impl (KEY_CONTEXT *ctx, const BYTE *in, BYTE *out)
BOOL	export_public_key_impl (const KEY_CONTEXT *ctx, BYTE *dst, DWORD *pubexp)
BOOL	import_public_key_impl (ALG_ID algid, const BYTE *src, DWORD keylen, DWORD pubexp, KEY_CONTEXT *ctx)
BOOL	export_private_key_impl (const KEY_CONTEXT *ctx, BYTE *dst, DWORD *pubexp)
BOOL	import_private_key_impl (ALG_ID algid, const BYTE *src, DWORD keylen, DWORD pubexp, KEY_CONTEXT *ctx)

Macro Definition Documentation

RSAENH_MAX_HASH_SIZE

#define RSAENH_MAX_HASH_SIZE   104

Definition at line 30 of file implglue.h.

Typedef Documentation

KEY_CONTEXT

typedef union tagKEY_CONTEXT KEY_CONTEXT

Function Documentation

decrypt_block_impl()

BOOL decrypt_block_impl	(	ALG_ID	algid,
		KEY_CONTEXT *	ctx,
		const BYTE *	in,
		BYTE *	out
	)

Definition at line 395 of file implglue.c.

{
    switch (algid)
    {
    case CALG_RC2:
        SymCryptRc2Decrypt( &ctx->rc2, in, out );
        break;
    case CALG_3DES:
    case CALG_3DES_112:
        SymCrypt3DesDecrypt( &ctx->des3, in, out );
        break;
    case CALG_DES:
        SymCryptDesDecrypt( &ctx->des, in, out );
        break;
    case CALG_AES:
    case CALG_AES_128:
    case CALG_AES_192:
    case CALG_AES_256:
        SymCryptAesDecrypt( &ctx->aes, in, out );
        break;
    case CALG_RSA_KEYX:
    case CALG_RSA_SIGN:
    case CALG_SSL3_SHAMD5:
        return rsa_decrypt( ctx->rsa.key, in, SYMCRYPT_NUMBER_FORMAT_LSB_FIRST, out, SYMCRYPT_NUMBER_FORMAT_MSB_FIRST );
    default:
        SetLastError( NTE_BAD_ALGID );
        return FALSE;
    }
    return TRUE;
}

Referenced by import_symmetric_key(), and RSAENH_CPDecrypt().

duplicate_key_impl()

BOOL duplicate_key_impl	(	ALG_ID	algid,
		const KEY_CONTEXT *	src,
		KEY_CONTEXT *	dst
	)

Definition at line 183 of file implglue.c.

{
    switch (algid)
    {
    case CALG_RC4:
    case CALG_RC2:
    case CALG_3DES:
    case CALG_3DES_112:
    case CALG_DES:
        *dst = *src;
        break;
    case CALG_AES:
    case CALG_AES_128:
    case CALG_AES_192:
    case CALG_AES_256:
        /* SYMCRYPT_AES_EXPANDED_KEY contains pointers into its own RoundKey
         * array, so it cannot be copied by assignment. */
        SymCryptAesKeyCopy( &src->aes, &dst->aes );
        break;
    case CALG_RSA_KEYX:
    case CALG_RSA_SIGN:
    {
        BYTE *blob;
        DWORD pubexp, keylen = SymCryptRsakeySizeofModulus( src->rsa.key );
        BOOLEAN private = SymCryptRsakeyHasPrivateKey( src->rsa.key );
 
        if (!(dst->rsa.key = alloc_rsa_key( keylen * 8, private )) || !(blob = malloc( keylen * 2 )))
        {
            SetLastError( NTE_FAIL );
            return FALSE;
        }
        if (private)
        {
            if (!export_private_key_impl( src, blob, &pubexp ) ||
                !import_private_key_impl( algid, blob, keylen, pubexp, dst ))
            {
                free( blob );
                return FALSE;
            }
        }
        else
        {
            if (!export_public_key_impl( src, blob, &pubexp ) ||
                !import_public_key_impl( algid, blob, keylen, pubexp, dst ))
            {
                free( blob );
                return FALSE;
            }
        }
        dst->rsa.flags = src->rsa.flags;
        free( blob );
        break;
    }
    default:
        SetLastError( NTE_BAD_ALGID );
        return FALSE;
    }
    return TRUE;
}

Referenced by RSAENH_CPCreateHash(), and RSAENH_CPDuplicateKey().

encrypt_block_impl()

BOOL encrypt_block_impl	(	ALG_ID	algid,
		KEY_CONTEXT *	ctx,
		const BYTE *	in,
		BYTE *	out
	)

Definition at line 301 of file implglue.c.

{
    switch (algid)
    {
    case CALG_RC2:
        SymCryptRc2Encrypt( &ctx->rc2, in, out );
        break;
    case CALG_3DES:
    case CALG_3DES_112:
        SymCrypt3DesEncrypt( &ctx->des3, in, out );
        break;
    case CALG_DES:
        SymCryptDesEncrypt( &ctx->des, in, out );
        break;
    case CALG_AES:
    case CALG_AES_128:
    case CALG_AES_192:
    case CALG_AES_256:
        SymCryptAesEncrypt( &ctx->aes, in, out );
        break;
    case CALG_RSA_KEYX:
    case CALG_RSA_SIGN:
    case CALG_SSL3_SHAMD5:
        return rsa_encrypt( ctx->rsa.key, in, SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, out, SYMCRYPT_NUMBER_FORMAT_LSB_FIRST );
    default:
        SetLastError( NTE_BAD_ALGID );
        return FALSE;
    }
    return TRUE;
}

Referenced by block_encrypt(), crypt_export_simple(), RSAENH_CPDecrypt(), and RSAENH_CPEncrypt().

encrypt_stream_impl()

BOOL encrypt_stream_impl	(	ALG_ID	algid,
		KEY_CONTEXT *	ctx,
		BYTE *	inout,
		DWORD	len
	)

Definition at line 436 of file implglue.c.

{
    switch (algid)
    {
    case CALG_RC4:
        SymCryptRc4Crypt( &ctx->rc4, stream, stream, len );
        break;
    default:
        SetLastError( NTE_BAD_ALGID );
        return FALSE;
    }
    return TRUE;
}

Referenced by RSAENH_CPDecrypt(), and RSAENH_CPEncrypt().

export_private_key_impl()

BOOL export_private_key_impl	(	const KEY_CONTEXT *	ctx,
		BYTE *	dst,
		DWORD *	pubexp
	)

Definition at line 493 of file implglue.c.

{
    BYTE *modulus, *primes[2], *exponents[2], *coefficient, *private_exp;
    SIZE_T modulus_size, primes_sizes[2];
    UINT64 pubexp64;
 
    if (!ctx->rsa.key) return FALSE;
 
    modulus_size = SymCryptRsakeySizeofModulus( ctx->rsa.key );
 
    primes_sizes[0] = SymCryptRsakeySizeofPrime( ctx->rsa.key, 0 );
    primes_sizes[1] = SymCryptRsakeySizeofPrime( ctx->rsa.key, 1 );
 
    modulus = dst;
    primes[0] = modulus + modulus_size;
    primes[1] = modulus + modulus_size + primes_sizes[0];
 
    if (SymCryptRsakeyGetValue( ctx->rsa.key, modulus, modulus_size, &pubexp64, 1, primes, primes_sizes, 2,
                                SYMCRYPT_NUMBER_FORMAT_LSB_FIRST, 0 ))
    {
        SetLastError( NTE_FAIL );
        return FALSE;
    }
 
    exponents[0] = primes[1]    + primes_sizes[1];
    exponents[1] = exponents[0] + primes_sizes[0];
    coefficient  = exponents[1] + primes_sizes[1];
    private_exp  = coefficient  + primes_sizes[0];
 
    if (SymCryptRsakeyGetCrtValue( ctx->rsa.key, exponents, primes_sizes, 2, coefficient, primes_sizes[0],
                                   private_exp, modulus_size, SYMCRYPT_NUMBER_FORMAT_LSB_FIRST, 0 ))
    {
        SetLastError( NTE_FAIL );
        return FALSE;
    }
 
    *pubexp = pubexp64;
    return TRUE;
}

Referenced by crypt_export_private_key(), and duplicate_key_impl().

export_public_key_impl()

BOOL export_public_key_impl	(	const KEY_CONTEXT *	ctx,
		BYTE *	dst,
		DWORD *	pubexp
	)

Definition at line 450 of file implglue.c.

{
    BYTE *modulus = dst;
    SIZE_T modulus_size;
    UINT64 pubexp64;
 
    if (!ctx->rsa.key) return FALSE;
 
    modulus_size = SymCryptRsakeySizeofModulus( ctx->rsa.key );
 
    if (SymCryptRsakeyGetValue( ctx->rsa.key, modulus, modulus_size, &pubexp64, 1, NULL, NULL, 0,
                                SYMCRYPT_NUMBER_FORMAT_LSB_FIRST, 0 ))
    {
        SetLastError( NTE_FAIL );
        return FALSE;
    }
    *pubexp = pubexp64;
    return TRUE;
}

Referenced by crypt_export_public_key(), and duplicate_key_impl().

finalize_hash_impl()

static void finalize_hash_impl ( struct hash *  hash, BYTE *  hash_value, DWORD  hash_size  )

inlinestatic

Definition at line 61 of file implglue.h.

{
    SymCryptHashResult( hash->desc, &hash->state, hash_value, hash_size );
}

Referenced by finalize_hash(), and RSAENH_CPSetHashParam().

free_key_impl()

BOOL free_key_impl	(	ALG_ID	algid,
		KEY_CONTEXT *	ctx
	)

Definition at line 129 of file implglue.c.

{
    switch (algid)
    {
    case CALG_RSA_KEYX:
    case CALG_RSA_SIGN:
        if (ctx->rsa.key)
        {
            SymCryptRsakeyFree( ctx->rsa.key );
            ctx->rsa.key = NULL;
        }
        break;
    default:
        break;
    }
    return TRUE;
}

Referenced by destroy_hash(), and destroy_key().

hash_block_len_impl()

static DWORD hash_block_len_impl ( const struct hash *  hash )

inlinestatic

Definition at line 71 of file implglue.h.

{
    return SymCryptHashInputBlockSize( hash->desc );
}

Referenced by RSAENH_CPSetHashParam().

hash_len_impl()

static DWORD hash_len_impl ( const struct hash *  hash )

inlinestatic

Definition at line 66 of file implglue.h.

{
    return SymCryptHashResultSize( hash->desc );
}

Referenced by init_hash(), and RSAENH_CPSetHashParam().

import_private_key_impl()

BOOL import_private_key_impl	(	ALG_ID	algid,
		const BYTE *	src,
		DWORD	keylen,
		DWORD	pubexp,
		KEY_CONTEXT *	ctx
	)

Definition at line 533 of file implglue.c.

{
    const BYTE *modulus = src, *primes[2];
    SIZE_T primes_sizes[2];
    UINT64 exp64 = pubexp;
 
    ctx->rsa.flags = SYMCRYPT_FLAG_KEY_NO_FIPS;
    if (algid == CALG_RSA_KEYX) ctx->rsa.flags |= SYMCRYPT_FLAG_RSAKEY_ENCRYPT;
    else ctx->rsa.flags |= SYMCRYPT_FLAG_RSAKEY_SIGN | SYMCRYPT_FLAG_RSAKEY_ENCRYPT;
 
    if (!(ctx->rsa.key = alloc_rsa_key( keylen * 8, TRUE )))
    {
        SetLastError( NTE_FAIL );
        return FALSE;
    }
 
    primes[0] = modulus + keylen;
    primes[1] = primes[0] + keylen / 2;
 
    primes_sizes[0] = keylen / 2;
    primes_sizes[1] = keylen / 2;
 
    if (SymCryptRsakeySetValue( modulus, keylen, &exp64, 1, primes, primes_sizes, 2,
                                SYMCRYPT_NUMBER_FORMAT_LSB_FIRST, ctx->rsa.flags, ctx->rsa.key ))
    {
        SetLastError( NTE_FAIL );
        return FALSE;
    }
 
    return TRUE;
}

Referenced by duplicate_key_impl(), and import_private_key().

import_public_key_impl()

BOOL import_public_key_impl	(	ALG_ID	algid,
		const BYTE *	src,
		DWORD	keylen,
		DWORD	pubexp,
		KEY_CONTEXT *	ctx
	)

Definition at line 470 of file implglue.c.

{
    const BYTE *modulus = src;
    UINT64 exp64 = pubexp;
 
    ctx->rsa.flags = SYMCRYPT_FLAG_KEY_NO_FIPS;
    if (algid == CALG_RSA_KEYX) ctx->rsa.flags |= SYMCRYPT_FLAG_RSAKEY_ENCRYPT;
    else ctx->rsa.flags |= SYMCRYPT_FLAG_RSAKEY_SIGN | SYMCRYPT_FLAG_RSAKEY_ENCRYPT;
 
    if (!(ctx->rsa.key = alloc_rsa_key( keylen * 8, FALSE )))
    {
        SetLastError( NTE_FAIL );
        return FALSE;
    }
    if (SymCryptRsakeySetValue( modulus, keylen, &exp64, 1, NULL, NULL, 0, SYMCRYPT_NUMBER_FORMAT_LSB_FIRST,
                                ctx->rsa.flags, ctx->rsa.key ))
    {
        SetLastError( NTE_FAIL );
        return FALSE;
    }
    return TRUE;
}

Referenced by duplicate_key_impl(), and import_public_key().

init_hash_impl()

BOOL init_hash_impl	(	ALG_ID	algid,
		struct hash *	hash
	)

Definition at line 63 of file implglue.c.

{
    const SYMCRYPT_HASH *algorithms[] =
    {
        [ALG_SID_MD2] = SymCryptMd2Algorithm,
        [ALG_SID_MD4] = SymCryptMd4Algorithm,
        [ALG_SID_MD5] = SymCryptMd5Algorithm,
        [ALG_SID_SHA] = SymCryptSha1Algorithm,
        [ALG_SID_SHA_256] = SymCryptSha256Algorithm,
        [ALG_SID_SHA_384] = SymCryptSha384Algorithm,
        [ALG_SID_SHA_512] = SymCryptSha512Algorithm,
    };
 
    memset( hash, 0, sizeof(*hash) );
    if (GET_ALG_CLASS(algid) != ALG_CLASS_HASH) return TRUE;
    if (GET_ALG_SID(algid) >= ARRAY_SIZE(algorithms)) return TRUE;
    if (!(hash->desc = algorithms[GET_ALG_SID(algid)])) return TRUE;
    SymCryptHashInit( hash->desc, &hash->state );
    return TRUE;
}

Referenced by finalize_hash(), init_hash(), and RSAENH_CPSetHashParam().

new_key_impl()

BOOL new_key_impl	(	ALG_ID	algid,
		KEY_CONTEXT *	ctx,
		DWORD	keylen
	)

Definition at line 95 of file implglue.c.

{
    switch (algid)
    {
    case CALG_RSA_KEYX:
    case CALG_RSA_SIGN:
    {
        UINT64 pubexp = 65537;
 
        ctx->rsa.flags = SYMCRYPT_FLAG_KEY_NO_FIPS;
        if (algid == CALG_RSA_KEYX) ctx->rsa.flags |= SYMCRYPT_FLAG_RSAKEY_ENCRYPT;
        else ctx->rsa.flags |= SYMCRYPT_FLAG_RSAKEY_SIGN;
 
        if (!(ctx->rsa.key = alloc_rsa_key( keylen * 8, TRUE )))
        {
            SetLastError( NTE_FAIL );
            return FALSE;
        }
        if (SymCryptRsakeyGenerate( ctx->rsa.key, &pubexp, 1, ctx->rsa.flags ))
        {
            SymCryptRsakeyFree( ctx->rsa.key );
            ctx->rsa.key = NULL;
            SetLastError( NTE_FAIL );
            return FALSE;
        }
        break;
    }
    default:
        SetLastError( NTE_BAD_ALGID );
        return FALSE;
    }
    return TRUE;
}

Referenced by RSAENH_CPGenKey().

setup_key_impl()

BOOL setup_key_impl	(	ALG_ID	algid,
		KEY_CONTEXT *	ctx,
		DWORD	keylen,
		DWORD	effective_keylen,
		DWORD	saltlen,
		const BYTE *	keyvalue
	)

Definition at line 147 of file implglue.c.

{
    switch (algid)
    {
    case CALG_RC4:
        SymCryptRc4Init( &ctx->rc4, secret, keylen + saltlen );
        break;
    case CALG_RC2:
        SymCryptRc2ExpandKeyEx( &ctx->rc2, secret, keylen + saltlen,
                                effective_keylen ? effective_keylen : keylen << 3 );
        break;
    case CALG_3DES:
        SymCrypt3DesExpandKey( &ctx->des3, secret, 24 );
        break;
    case CALG_3DES_112:
        SymCrypt3DesExpandKey( &ctx->des3, secret, 16 );
        break;
    case CALG_DES:
        SymCryptDesExpandKey( &ctx->des, secret, 8 );
        break;
    case CALG_AES:
    case CALG_AES_128:
        SymCryptAesExpandKey( &ctx->aes, secret, 16 );
        break;
    case CALG_AES_192:
        SymCryptAesExpandKey( &ctx->aes, secret, 24 );
        break;
    case CALG_AES_256:
        SymCryptAesExpandKey( &ctx->aes, secret, 32 );
        break;
    }
 
    return TRUE;
}

Referenced by setup_key().

sign_hash_impl()

BOOL sign_hash_impl	(	KEY_CONTEXT *	ctx,
		const BYTE *	in,
		BYTE *	out
	)

Definition at line 426 of file implglue.c.

{
    return rsa_decrypt( ctx->rsa.key, in, SYMCRYPT_NUMBER_FORMAT_MSB_FIRST, out, SYMCRYPT_NUMBER_FORMAT_LSB_FIRST );
}

Referenced by RSAENH_CPSignHash().

update_hash_impl()

static void update_hash_impl ( struct hash *  hash, const BYTE *  data, DWORD  len  )

inlinestatic

Definition at line 56 of file implglue.h.

{
    SymCryptHashAppend( hash->desc, &hash->state, data, len );
}

Referenced by finalize_hash(), init_hash(), RSAENH_CPSetHashParam(), and update_hash().

verify_signature_impl()

BOOL verify_signature_impl	(	KEY_CONTEXT *	ctx,
		const BYTE *	in,
		BYTE *	out
	)

Definition at line 431 of file implglue.c.

{
    return rsa_encrypt( ctx->rsa.key, in, SYMCRYPT_NUMBER_FORMAT_LSB_FIRST, out, SYMCRYPT_NUMBER_FORMAT_MSB_FIRST );
}

Referenced by RSAENH_CPVerifySignature().