aes-key.c File Reference

#include "precomp.h"

Include dependency graph for aes-key.c:

Go to the source code of this file.

Functions
SYMCRYPT_NOINLINE SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptAesExpandKeyInternal (_Out_ PSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey, BOOLEAN fCreateDecryptionKeys)
SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptAesExpandKey (_Out_ PSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptAesExpandKeyEncryptOnly (_Out_ PSYMCRYPT_AES_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
VOID SYMCRYPT_CALL	SymCryptAesKeyCopy (_In_ PCSYMCRYPT_AES_EXPANDED_KEY pSrc, _Out_ PSYMCRYPT_AES_EXPANDED_KEY pDst)

Variables
static BYTE	g_SymCryptAesRoundConstant [11]
const BYTE	SymCryptAesNistTestVector128Ciphertext [16]

Function Documentation

SymCryptAesExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptAesExpandKey	(	_Out_ PSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(cbKey) PCBYTE	pbKey,
		SIZE_T	cbKey
	)

Definition at line 219 of file aes-key.c.

{
    return SymCryptAesExpandKeyInternal( pExpandedKey, pbKey, cbKey, TRUE );
}

Referenced by setup_key_impl(), SymCryptAesCmacExpandKey(), SymCryptCcmSelftest(), and SymCryptXtsAesExpandKey().

SymCryptAesExpandKeyEncryptOnly()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptAesExpandKeyEncryptOnly	(	_Out_ PSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(cbKey) PCBYTE	pbKey,
		SIZE_T	cbKey
	)

Definition at line 230 of file aes-key.c.

{
    return SymCryptAesExpandKeyInternal( pExpandedKey, pbKey, cbKey, FALSE );
}

Referenced by SymCryptRngAesDf(), SymCryptRngAesGenerateSmall(), SymCryptRngAesUpdate(), SymCryptSrtpKdfExpandKey(), and SymCryptXtsAesExpandKey().

SymCryptAesExpandKeyInternal()

SYMCRYPT_NOINLINE SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptAesExpandKeyInternal	(	_Out_ PSYMCRYPT_AES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(cbKey) PCBYTE	pbKey,
		SIZE_T	cbKey,
		BOOLEAN	fCreateDecryptionKeys
	)

Definition at line 35 of file aes-key.c.

{
    UINT32  nRounds;
    BYTE *  p;
    BYTE *  q;
    UINT32  i;
    UINT32  t;
 
    BOOL            UseSimd = FALSE;
    SYMCRYPT_ERROR  status = SYMCRYPT_NO_ERROR;
 
#if SYMCRYPT_CPU_X86
    SYMCRYPT_EXTENDED_SAVE_DATA  SaveData;
 
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE ) )
    {
        if( SymCryptSaveXmm( &SaveData ) == SYMCRYPT_NO_ERROR )
        {
            UseSimd = TRUE;
        }
    }
#elif SYMCRYPT_CPU_AMD64
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURES_FOR_AESNI_CODE ) )
    {
        UseSimd = TRUE;
    }
#elif SYMCRYPT_CPU_ARM64
    if( SYMCRYPT_CPU_FEATURES_PRESENT( SYMCRYPT_CPU_FEATURE_NEON_AES ) )
    {
        UseSimd = TRUE;
    }
#endif
 
    SYMCRYPT_SET_MAGIC( pExpandedKey );
 
    //
    // Separate code for each key size, this is significantly faster.
    // We have a number of applications that do frequent key expansions.
    //
    switch( cbKey )
    {
    case 16:
        nRounds = 10;
        pExpandedKey->lastEncRoundKey = &pExpandedKey->RoundKey[nRounds];
        pExpandedKey->lastDecRoundKey = &pExpandedKey->RoundKey[2*nRounds];
 
        memcpy( &pExpandedKey->RoundKey[0], pbKey, 16 );
 
        p = (BYTE *)&pExpandedKey->RoundKey[1];
 
        for( i=1; i<=nRounds; i++ )
        {
            SymCryptAes4Sbox( &p[-4], p, UseSimd );
            t = ROR32(SYMCRYPT_LOAD_LSBFIRST32(p), 8) ^ SYMCRYPT_LOAD_LSBFIRST32(p - 16) ^ g_SymCryptAesRoundConstant[i];
            SYMCRYPT_STORE_LSBFIRST32( p, t );     // this is a macro that re-evaluates its arguments
 
            *(UINT32 *)(p+4)  = *(UINT32 *) p    ^ *(UINT32 *)(p - 12);
            *(UINT32 *)(p+8)  = *(UINT32 *)(p+4) ^ *(UINT32 *)(p -  8);
            *(UINT32 *)(p+12) = *(UINT32 *)(p+8) ^ *(UINT32 *)(p -  4);
 
            p += 16;
        }
 
        break;
 
    case 24:
        nRounds = 12;
        pExpandedKey->lastEncRoundKey = &pExpandedKey->RoundKey[nRounds];
        pExpandedKey->lastDecRoundKey = &pExpandedKey->RoundKey[2*nRounds];
 
        memcpy( &pExpandedKey->RoundKey[0], pbKey, 24 );
 
        p = (BYTE *)&pExpandedKey->RoundKey[0] + 24;
 
        //
        // We have 12 rounds, 13 round keys, and 13*16 = 208 bytes of encryption key to generate.
        // We have 24 already, so we need 184 more.
        // Each iteration produces 24 bytes, so we need to loop 8 times.
        //
        for( i=1; i<=8; i++ )
        {
            SymCryptAes4Sbox( &p[-4], p, UseSimd );
            t = ROR32(SYMCRYPT_LOAD_LSBFIRST32(p), 8) ^ SYMCRYPT_LOAD_LSBFIRST32(p - 24) ^ g_SymCryptAesRoundConstant[i];
            SYMCRYPT_STORE_LSBFIRST32( p, t );
 
            *(UINT32 *)(p+4)  = *(UINT32 *) p     ^ *(UINT32 *)(p - 20);
            *(UINT32 *)(p+8)  = *(UINT32 *)(p+ 4) ^ *(UINT32 *)(p - 16);
            *(UINT32 *)(p+12) = *(UINT32 *)(p+ 8) ^ *(UINT32 *)(p - 12);
            *(UINT32 *)(p+16) = *(UINT32 *)(p+12) ^ *(UINT32 *)(p -  8);
            *(UINT32 *)(p+20) = *(UINT32 *)(p+16) ^ *(UINT32 *)(p -  4);
 
            p += 24;
        }
 
        break;
 
    case 32:
        nRounds = 14;
        pExpandedKey->lastEncRoundKey = &pExpandedKey->RoundKey[nRounds];
        pExpandedKey->lastDecRoundKey = &pExpandedKey->RoundKey[2*nRounds];
 
        memcpy( &pExpandedKey->RoundKey[0], pbKey, 32 );
 
        p = (BYTE *)&pExpandedKey->RoundKey[0] + 32;
 
        //
        // We have 14 rounds, 15 round keys, and 15*16 = 240 bytes of encryption key to generate.
        // We have 32 already, so we need 208 more.
        // Each iteration produces 32 bytes, so we need to loop 6.5 times.
        //
        for( i=1; i<=6; i++ )
        {
            SymCryptAes4Sbox( &p[-4], p, UseSimd );
            t = ROR32(SYMCRYPT_LOAD_LSBFIRST32(p), 8) ^ SYMCRYPT_LOAD_LSBFIRST32(p - 32) ^ g_SymCryptAesRoundConstant[i];
            SYMCRYPT_STORE_LSBFIRST32( p, t );
 
            *(UINT32 *)(p+4)  = *(UINT32 *) p       ^ *(UINT32 *)(p - 28);
            *(UINT32 *)(p+8)  = *(UINT32 *)(p +  4) ^ *(UINT32 *)(p - 24);
            *(UINT32 *)(p+12) = *(UINT32 *)(p +  8) ^ *(UINT32 *)(p - 20);
 
            SymCryptAes4Sbox( &p[12], &p[16], UseSimd );
            *(UINT32 *)(p+16) = *(UINT32 *)(p + 16) ^ *(UINT32 *)(p - 16);
 
            *(UINT32 *)(p+20) = *(UINT32 *)(p + 16) ^ *(UINT32 *)(p - 12);
            *(UINT32 *)(p+24) = *(UINT32 *)(p + 20) ^ *(UINT32 *)(p -  8);
            *(UINT32 *)(p+28) = *(UINT32 *)(p + 24) ^ *(UINT32 *)(p -  4);
 
            p += 32;
        }
 
        // We looped 6 times, so here is the half-loop
 
        SymCryptAes4Sbox( &p[-4], p, UseSimd );
        t = ROR32(SYMCRYPT_LOAD_LSBFIRST32(p), 8) ^ SYMCRYPT_LOAD_LSBFIRST32(p - 32) ^ g_SymCryptAesRoundConstant[i];
        SYMCRYPT_STORE_LSBFIRST32( p, t );
 
        *(UINT32 *)(p+4)  = *(UINT32 *) p       ^ *(UINT32 *)(p - 28);
        *(UINT32 *)(p+8)  = *(UINT32 *)(p +  4) ^ *(UINT32 *)(p - 24);
        *(UINT32 *)(p+12) = *(UINT32 *)(p +  8) ^ *(UINT32 *)(p - 20);
 
        break;
 
    default:
        status = SYMCRYPT_WRONG_KEY_SIZE;
        goto cleanup;
    }
 
 
    if( fCreateDecryptionKeys )
    {
        p = &pExpandedKey->RoundKey[0][0][0];
        q = (PBYTE)(pExpandedKey->lastDecRoundKey);
 
        // The first encryption round key is the last decryption round key
        memcpy( q, p, SYMCRYPT_AES_BLOCK_SIZE );
        p += 16;
        q -= 16;
 
        while( p < (PBYTE) pExpandedKey->lastEncRoundKey )
        {
            SymCryptAesCreateDecryptionRoundKey( p, q, UseSimd );
            q -= 16;
            p += 16;
        }
    }
 
cleanup:
 
#if SYMCRYPT_CPU_X86
    if( UseSimd )
    {
        SymCryptRestoreXmm( &SaveData );
    }
#endif
 
    return status;
}

Referenced by SymCryptAesExpandKey(), and SymCryptAesExpandKeyEncryptOnly().

SymCryptAesKeyCopy()

VOID SYMCRYPT_CALL SymCryptAesKeyCopy	(	_In_ PCSYMCRYPT_AES_EXPANDED_KEY	pSrc,
		_Out_ PSYMCRYPT_AES_EXPANDED_KEY	pDst
	)

Definition at line 240 of file aes-key.c.

{
    SYMCRYPT_CHECK_MAGIC( pSrc );
 
    *pDst = *pSrc;
    pDst->lastEncRoundKey = &pDst->RoundKey[0] + (pSrc->lastEncRoundKey - &pSrc->RoundKey[0]);
    pDst->lastDecRoundKey = &pDst->RoundKey[0] + (pSrc->lastDecRoundKey - &pSrc->RoundKey[0]);
 
    SYMCRYPT_SET_MAGIC( pDst );
}

Referenced by duplicate_key_impl(), SymCryptAesCmacKeyCopy(), and SymCryptXtsAesKeyCopy().

Variable Documentation

g_SymCryptAesRoundConstant

BYTE g_SymCryptAesRoundConstant[11]

static

Initial value:

=
{
    0, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36,
}

Definition at line 27 of file aes-key.c.

Referenced by SymCryptAesExpandKeyInternal().

SymCryptAesNistTestVector128Ciphertext

const BYTE SymCryptAesNistTestVector128Ciphertext[16]

Initial value:

= {
    0x69, 0xc4, 0xe0, 0xd8, 0x6a, 0x7b, 0x04, 0x30,
    0xd8, 0xcd, 0xb7, 0x80, 0x70, 0xb4, 0xc5, 0x5a,
}

Definition at line 257 of file aes-key.c.