3des.c File Reference

#include "precomp.h"

Include dependency graph for 3des.c:

Go to the source code of this file.

Macros
#define	SWAP_BITS_WITHIN_UINT32(_value, _shift, _mask)
#define	SWAP_BITS_BETWEEN_UINT32(_v1, _v2, _shift, _mask)
#define	F(L, R, keyptr)

Functions
	SYMCRYPT_ALIGN_AT (256) const
SYMCRYPT_ERROR SYMCRYPT_CALL	SymCryptDesExpandKey (_Out_ PSYMCRYPT_DES_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
VOID SYMCRYPT_CALL	SymCryptDesEncrypt (_In_ PCSYMCRYPT_DES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_DES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_DES_BLOCK_SIZE) PBYTE pbDst)
VOID SYMCRYPT_CALL	SymCryptDesDecrypt (_In_ PCSYMCRYPT_DES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_DES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_DES_BLOCK_SIZE) PBYTE pbDst)
VOID SYMCRYPT_CALL	SymCrypt3DesCbcEncrypt (_In_ PCSYMCRYPT_3DES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_3DES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
VOID SYMCRYPT_CALL	SymCrypt3DesCbcDecrypt (_In_ PCSYMCRYPT_3DES_EXPANDED_KEY pExpandedKey, _Inout_updates_(SYMCRYPT_3DES_BLOCK_SIZE) PBYTE pbChainingValue, _In_reads_(cbData) PCBYTE pbSrc, _Out_writes_(cbData) PBYTE pbDst, SIZE_T cbData)
VOID SYMCRYPT_CALL	SymCryptDesExpandSingleKey (_Out_writes_bytes_(128) UINT32 expandedKeyTable[16][2], _In_reads_(8) PCBYTE pKey)
SYMCRYPT_NOINLINE SYMCRYPT_ERROR SYMCRYPT_CALL	SymCrypt3DesExpandKey (_Out_ PSYMCRYPT_3DES_EXPANDED_KEY pExpandedKey, _In_reads_(cbKey) PCBYTE pbKey, SIZE_T cbKey)
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL	SymCrypt3DesEncrypt (_In_ PCSYMCRYPT_3DES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_3DES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_3DES_BLOCK_SIZE) PBYTE pbDst)
SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL	SymCrypt3DesDecrypt (_In_ PCSYMCRYPT_3DES_EXPANDED_KEY pExpandedKey, _In_reads_(SYMCRYPT_3DES_BLOCK_SIZE) PCBYTE pbSrc, _Out_writes_(SYMCRYPT_3DES_BLOCK_SIZE) PBYTE pbDst)
VOID SYMCRYPT_CALL	SymCryptDesSetOddParity (_Inout_updates_(cbData) PBYTE pbData, _In_ SIZE_T cbData)
VOID SYMCRYPT_CALL	SymCryptDesSelftest (void)
VOID SYMCRYPT_CALL	SymCrypt3DesSelftest (void)

Variables
const SYMCRYPT_BLOCKCIPHER	SymCrypt3DesBlockCipher_default
const SYMCRYPT_BLOCKCIPHER	SymCryptDesBlockCipher_default
const PCSYMCRYPT_BLOCKCIPHER	SymCrypt3DesBlockCipher = &SymCrypt3DesBlockCipher_default
const PCSYMCRYPT_BLOCKCIPHER	SymCryptDesBlockCipher = &SymCryptDesBlockCipher_default
static const BYTE	SP800_67Key [24]
static const BYTE	des3KnownPlaintext [8]
static const BYTE	des3KnownCiphertext [8]
static const BYTE	desKnownCiphertext [8]

Macro Definition Documentation

F

#define F	(		L,
			R,
			keyptr
	)

Value:

    { \
    Ta = keyptr[0] ^ R; \
    Tb = keyptr[1] ^ R; \
    Tb = ROR32(Tb, 4); \
    L ^= *(UINT32 *)((PBYTE)SymCryptDesSpbox[0] + ( Ta     & 0xfc)); \
    L ^= *(UINT32 *)((PBYTE)SymCryptDesSpbox[1] + ( Tb     & 0xfc)); \
    L ^= *(UINT32 *)((PBYTE)SymCryptDesSpbox[2] + ((Ta>> 8)& 0xfc)); \
    L ^= *(UINT32 *)((PBYTE)SymCryptDesSpbox[3] + ((Tb>> 8)& 0xfc)); \
    L ^= *(UINT32 *)((PBYTE)SymCryptDesSpbox[4] + ((Ta>>16)& 0xfc)); \
    L ^= *(UINT32 *)((PBYTE)SymCryptDesSpbox[5] + ((Tb>>16)& 0xfc)); \
    L ^= *(UINT32 *)((PBYTE)SymCryptDesSpbox[6] + ((Ta>>24)& 0xfc)); \
    L ^= *(UINT32 *)((PBYTE)SymCryptDesSpbox[7] + ((Tb>>24)& 0xfc)); }

Definition at line 335 of file 3des.c.

SWAP_BITS_BETWEEN_UINT32

#define SWAP_BITS_BETWEEN_UINT32	(		_v1,
			_v2,
			_shift,
			_mask
	)

Value:

{ \
    UINT32  _tmp; \
    _tmp = ((_v1) ^ ((_v2) >> (_shift))) & (_mask); \
    _v1 ^= _tmp; \
    _v2 ^= (_tmp << (_shift )); \
}

SWAP_BITS_WITHIN_UINT32

#define SWAP_BITS_WITHIN_UINT32	(		_value,
			_shift,
			_mask
	)

Value:

{ \
    UINT32  _tmp; \
    _tmp = ((_value) ^ ((_value) >> (_shift))) & (_mask ); \
    _value = (_value) ^ _tmp ^ (_tmp << (_shift)); \
}

Function Documentation

SymCrypt3DesCbcDecrypt()

VOID SYMCRYPT_CALL SymCrypt3DesCbcDecrypt	(	_In_ PCSYMCRYPT_3DES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_3DES_BLOCK_SIZE) PBYTE	pbChainingValue,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Definition at line 180 of file 3des.c.

{
    SYMCRYPT_ASSERT( SymCrypt3DesBlockCipher->blockSize == SYMCRYPT_3DES_BLOCK_SIZE );
    SymCryptCbcDecrypt( SymCrypt3DesBlockCipher, pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
}

SymCrypt3DesCbcEncrypt()

VOID SYMCRYPT_CALL SymCrypt3DesCbcEncrypt	(	_In_ PCSYMCRYPT_3DES_EXPANDED_KEY	pExpandedKey,
		_Inout_updates_(SYMCRYPT_3DES_BLOCK_SIZE) PBYTE	pbChainingValue,
		_In_reads_(cbData) PCBYTE	pbSrc,
		_Out_writes_(cbData) PBYTE	pbDst,
		SIZE_T	cbData
	)

Definition at line 167 of file 3des.c.

{
    SYMCRYPT_ASSERT( SymCrypt3DesBlockCipher->blockSize == SYMCRYPT_3DES_BLOCK_SIZE );
    SymCryptCbcEncrypt( SymCrypt3DesBlockCipher, pExpandedKey, pbChainingValue, pbSrc, pbDst, cbData );
}

SymCrypt3DesDecrypt()

SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCrypt3DesDecrypt	(	_In_ PCSYMCRYPT_3DES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(SYMCRYPT_3DES_BLOCK_SIZE) PCBYTE	pbSrc,
		_Out_writes_(SYMCRYPT_3DES_BLOCK_SIZE) PBYTE	pbDst
	)

Definition at line 478 of file 3des.c.

{
    UINT32   L, R, Ta, Tb;
    int r;
 
    SYMCRYPT_CHECK_MAGIC( pExpandedKey );
 
    R = SYMCRYPT_LOAD_LSBFIRST32( pbSrc );
    L = SYMCRYPT_LOAD_LSBFIRST32( pbSrc + 4 );
 
    R = ROL32(R, 4);
    Ta = (L ^ R) & 0xf0f0f0f0;
    L ^= Ta;
    R ^= Ta;
 
    L = ROL32(L, 20);
    Ta = (L ^ R) & 0xfff0000f;
    L ^= Ta;
    R ^= Ta;
 
    L = ROL32(L, 14);
    Ta = (L ^ R) & 0x33333333;
    L ^= Ta;
    R ^= Ta;
 
    R = ROL32(R, 22);
    Ta = (L ^ R) & 0x03fc03fc;
    L ^= Ta;
    R ^= Ta;
 
    R = ROL32(R, 9);
    Ta = (L ^ R) & 0xaaaaaaaa;
    L ^= Ta;
    R ^= Ta;
 
    L = ROL32(L, 1);
 
 
    // Decrypt with key 2
    for( r=14; r>=0; r -= 2 )
    {
        F( L, R, pExpandedKey->roundKey[2][r+1] );
        F( R, L, pExpandedKey->roundKey[2][r  ] );
    }
 
    // Encrypt with key 1
    for( r=0; r<16; r += 2 )
    {
        F( R, L, pExpandedKey->roundKey[1][r  ] );
        F( L, R, pExpandedKey->roundKey[1][r+1] );
    }
 
    // Decrypt with key 0
    for( r=14; r>=0; r -= 2 )
    {
        F( L, R, pExpandedKey->roundKey[0][r+1] );
        F( R, L, pExpandedKey->roundKey[0][r  ] );
    }
 
    /* Inverse permutation, also from Hoey via Outerbridge and Schneier */
 
    R = ROR32(R, 1);
    Ta = (L ^ R) & 0xaaaaaaaa;
    L ^= Ta;
    R ^= Ta;
 
    L = ROR32(L, 9);
    Ta = (L ^ R) & 0x03fc03fc;
    L ^= Ta;
    R ^= Ta;
 
    L = ROR32(L, 22);
    Ta = (L ^ R) & 0x33333333;
    L ^= Ta;
    R ^= Ta;
 
    R = ROR32(R, 14);
    Ta = (L ^ R) & 0xfff0000f;
    L ^= Ta;
    R ^= Ta;
 
    R = ROR32(R, 20);
    Ta = (L ^ R) & 0xf0f0f0f0;
    L ^= Ta;
    R ^= Ta;
 
    L = ROR32(L, 4);
 
    SYMCRYPT_STORE_LSBFIRST32( pbDst, L );
    SYMCRYPT_STORE_LSBFIRST32( pbDst + 4, R );
}

Referenced by decrypt_block_impl(), SymCrypt3DesSelftest(), and SymCryptDesDecrypt().

SymCrypt3DesEncrypt()

SYMCRYPT_NOINLINE VOID SYMCRYPT_CALL SymCrypt3DesEncrypt	(	_In_ PCSYMCRYPT_3DES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(SYMCRYPT_3DES_BLOCK_SIZE) PCBYTE	pbSrc,
		_Out_writes_(SYMCRYPT_3DES_BLOCK_SIZE) PBYTE	pbDst
	)

Definition at line 358 of file 3des.c.

{
    UINT32   L, R, Ta, Tb;
    int r;
 
    SYMCRYPT_CHECK_MAGIC( pExpandedKey );
 
    R = SYMCRYPT_LOAD_LSBFIRST32( pbSrc );
    L = SYMCRYPT_LOAD_LSBFIRST32( pbSrc + 4 );
 
    //
    // Hoey's wonderful initial permutation algorithm, from Outerbridge
    // (see Schneier p 478)
    //
    // The algorithm we use is derived (through several intermediate forms) from the mentioned source.
    // But the algorithm cannot be copyrighted, only patented, and if there were any patents
    // they have expired by now.
    // The expression of the algorithm in code is purely MS generated,
    // within the confines of implementing the algorithm in the best way such that even a simple
    // compiler will create good code.
    //
 
    R = ROL32(R, 4);
    Ta = (L ^ R) & 0xf0f0f0f0;
    L ^= Ta;
    R ^= Ta;
 
    L = ROL32(L, 20);
    Ta = (L ^ R) & 0xfff0000f;
    R ^= Ta;
    L ^= Ta;
 
    L = ROL32(L,14);
    Ta = (L ^ R) & 0x33333333;
    R ^= Ta;
    L ^= Ta;
 
    R = ROL32(R, 22);
    Ta = (L ^ R) & 0x03fc03fc;
    R ^= Ta;
    L ^= Ta;
 
    R = ROL32(R, 9);
    Ta = (L ^ R) & 0xaaaaaaaa;
    R ^= Ta;
    L ^= Ta;
 
    L = ROL32(L, 1);
 
    //
    // First: encryption
    //
    for( r=0; r<16; r += 2 )
    {
        F( L, R, pExpandedKey->roundKey[0][r  ] );
        F( R, L, pExpandedKey->roundKey[0][r+1] );
    }
 
    //
    // Second: decryption
    // Note that L and R are swapped here, and the round counter counts down.
    //
    for( r=14; r>=0; r -= 2 )
    {
        F( R, L, pExpandedKey->roundKey[1][r+1] );
        F( L, R, pExpandedKey->roundKey[1][r  ] );
    }
 
    //
    // Third: encryption
    //
    for( r=0; r<16; r += 2 )
    {
        F( L, R, pExpandedKey->roundKey[2][r  ] );
        F( R, L, pExpandedKey->roundKey[2][r+1] );
    }
 
    R = ROR32(R, 1);
    Ta = (L ^ R) & 0xaaaaaaaa;
    R ^= Ta;
    L ^= Ta;
 
    L = ROR32(L, 9);
    Ta = (L ^ R) & 0x03fc03fc;
    R ^= Ta;
    L ^= Ta;
 
    L = ROR32(L, 22);
    Ta = (L ^ R) & 0x33333333;
    R ^= Ta;
    L ^= Ta;
 
    R = ROR32(R, 14);
    Ta = (L ^ R) & 0xfff0000f;
    R ^= Ta;
    L ^= Ta;
 
    R = ROR32(R, 20);
    Ta = (L ^ R) & 0xf0f0f0f0;
    R ^= Ta;
    L ^= Ta;
 
    L = ROR32(L, 4);
 
    SYMCRYPT_STORE_LSBFIRST32( pbDst, L );
    SYMCRYPT_STORE_LSBFIRST32( pbDst + 4, R );
}

Referenced by encrypt_block_impl(), SymCrypt3DesSelftest(), and SymCryptDesEncrypt().

SymCrypt3DesExpandKey()

SYMCRYPT_NOINLINE SYMCRYPT_ERROR SYMCRYPT_CALL SymCrypt3DesExpandKey	(	_Out_ PSYMCRYPT_3DES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(cbKey) PCBYTE	pbKey,
		SIZE_T	cbKey
	)

Definition at line 295 of file 3des.c.

{
    SIZE_T keyIndex = 0;
    int i;
 
    if( cbKey != 8 && cbKey != 16 && cbKey != 24 )
    {
        return SYMCRYPT_WRONG_KEY_SIZE;
    }
 
    //
    // A loop that goes over the provided key as a circular buffer provides
    // the right result with the least complexity.
    // This is inefficient for the cases cbKey=8 and cbKey=16, but those should
    // not be used anyway.
    //
    for( i=0; i<3; i++ )
    {
        SYMCRYPT_ASSERT( keyIndex <= cbKey - 8 );       // help PreFast
        SymCryptDesExpandSingleKey( pExpandedKey->roundKey[i], pbKey + keyIndex );
        keyIndex = (keyIndex + 8) % cbKey;
    }
 
    SYMCRYPT_SET_MAGIC( pExpandedKey );
 
    return SYMCRYPT_NO_ERROR;
}

Referenced by setup_key_impl(), SymCrypt3DesSelftest(), and SymCryptDesExpandKey().

SymCrypt3DesSelftest()

VOID SYMCRYPT_CALL SymCrypt3DesSelftest

(

void

)

Definition at line 656 of file 3des.c.

{
    BYTE                        buf[SYMCRYPT_3DES_BLOCK_SIZE];
    SYMCRYPT_3DES_EXPANDED_KEY  key;
 
    if( SymCrypt3DesExpandKey( &key, SP800_67Key, 24 ) != SYMCRYPT_NO_ERROR )
    {
        SymCryptFatal( 'des3' );
    }
 
    SymCrypt3DesEncrypt( &key, des3KnownPlaintext, buf );
 
    SymCryptInjectError( buf, SYMCRYPT_3DES_BLOCK_SIZE );
 
    if( memcmp( buf, des3KnownCiphertext, SYMCRYPT_3DES_BLOCK_SIZE ) != 0 )
    {
        SymCryptFatal( 'des4' );
    }
 
    SymCrypt3DesDecrypt( &key, des3KnownCiphertext, buf );
 
    SymCryptInjectError( buf, SYMCRYPT_3DES_BLOCK_SIZE );
 
    if( memcmp( buf, des3KnownPlaintext, SYMCRYPT_3DES_BLOCK_SIZE ) != 0 )
    {
        SymCryptFatal( 'des5' );
    }
}

SYMCRYPT_ALIGN_AT()

SYMCRYPT_ALIGN_AT

(

256

)

const

Definition at line 78 of file 3des.c.

{ \
    UINT32  _tmp; \
    _tmp = ((_value) ^ ((_value) >> (_shift))) & (_mask ); \
    _value = (_value) ^ _tmp ^ (_tmp << (_shift)); \
}
 
//
// The SWAP_BITS_BETWEEN_UINT32 macro swaps bits between two UINT32 values
// SWAP_BITS_BETWEEN_UINT32( _v1, _v2, _shift, _mask )
// swaps bits in _v1 selected by _mask with bits in _v2 selected by _mask << _shift
//
 
#define SWAP_BITS_BETWEEN_UINT32( _v1, _v2, _shift, _mask ) \
{ \
    UINT32  _tmp; \
    _tmp = ((_v1) ^ ((_v2) >> (_shift))) & (_mask); \
    _v1 ^= _tmp; \
    _v2 ^= (_tmp << (_shift )); \
}
 
//
// For each round, a bit that states whether the key schedule shift registers are clocked twice
// The data is straight from the standard.
//
static const BYTE SymCryptDesDoubleShift[16]={0,0,1,1,1,1,1,1,0,1,1,1,1,1,1,0};

SymCryptDesDecrypt()

VOID SYMCRYPT_CALL SymCryptDesDecrypt	(	_In_ PCSYMCRYPT_DES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(SYMCRYPT_DES_BLOCK_SIZE) PCBYTE	pbSrc,
		_Out_writes_(SYMCRYPT_DES_BLOCK_SIZE) PBYTE	pbDst
	)

Definition at line 152 of file 3des.c.

{
    SymCrypt3DesDecrypt( &pExpandedKey->threeDes, pbSrc, pbDst );
}

Referenced by decrypt_block_impl(), SymCryptDesSelftest(), and SymCryptDesxDecrypt().

SymCryptDesEncrypt()

VOID SYMCRYPT_CALL SymCryptDesEncrypt	(	_In_ PCSYMCRYPT_DES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(SYMCRYPT_DES_BLOCK_SIZE) PCBYTE	pbSrc,
		_Out_writes_(SYMCRYPT_DES_BLOCK_SIZE) PBYTE	pbDst
	)

Definition at line 142 of file 3des.c.

{
    SymCrypt3DesEncrypt( &pExpandedKey->threeDes, pbSrc, pbDst );
}

Referenced by encrypt_block_impl(), SymCryptDesSelftest(), and SymCryptDesxEncrypt().

SymCryptDesExpandKey()

SYMCRYPT_ERROR SYMCRYPT_CALL SymCryptDesExpandKey	(	_Out_ PSYMCRYPT_DES_EXPANDED_KEY	pExpandedKey,
		_In_reads_(cbKey) PCBYTE	pbKey,
		SIZE_T	cbKey
	)

Definition at line 124 of file 3des.c.

{
    if( cbKey != 8 )
    {
        //
        // cbKey should be a compile-time constant in most cases,
        // so this should be optimized away
        //
        return SYMCRYPT_WRONG_KEY_SIZE;
    }
    return SymCrypt3DesExpandKey( &pExpandedKey->threeDes, pbKey, cbKey );
}

Referenced by setup_key_impl(), SymCryptDesSelftest(), and SymCryptDesxExpandKey().

SymCryptDesExpandSingleKey()

VOID SYMCRYPT_CALL SymCryptDesExpandSingleKey	(	_Out_writes_bytes_(128) UINT32	expandedKeyTable[16][2],
		_In_reads_(8) PCBYTE	pKey
	)

Definition at line 195 of file 3des.c.

{
    UINT32 Cr, Dr;      // The C_r D_r values of FIPS 43 for round value r
    UINT32 r;           // round
    UINT32 K1, K2;      // round keys after the permuted choice 2
    UINT32 tmp;
 
    //
    // We follow the FIPS 43 flow quite closely and have not optimized the key expansion much.
    // Key expansion is not performance-critical.
    //
 
    // Load the key
    Cr = SYMCRYPT_LOAD_LSBFIRST32( pKey );
    Dr = SYMCRYPT_LOAD_LSBFIRST32( pKey + 4 );
 
    //
    // The Permuted Choice 1 can be done mostly with a sequence of bit swaps.
    // The algorithm we use is derived from our earlier implementation and might potentially
    // derive from an external source.
    // But the algorithm cannot be copyrighted, only patented, and if there were any patents
    // they have expired by now.
    // The expression of the algorithm in code is purely MS generated, and so not encumbered
    // by external copyrights.
    // This algorithm is really just a transposition of the bits when viewed as an 8x8 matrix
    // with an additional permutation on the output side.
    //
    SWAP_BITS_BETWEEN_UINT32( Cr, Dr, 4, 0x0f0f0f0f );
    SWAP_BITS_WITHIN_UINT32( Dr, 18, 0x00003333 );
    SWAP_BITS_WITHIN_UINT32( Cr, 18, 0x00003333 );
    SWAP_BITS_BETWEEN_UINT32( Cr, Dr, 1, 0x55555555 );
    SWAP_BITS_BETWEEN_UINT32( Dr, Cr, 8, 0x00ff00ff );
    SWAP_BITS_BETWEEN_UINT32( Cr, Dr, 1, 0x55555555 );
    SWAP_BITS_WITHIN_UINT32( Dr, 16, 0xff );
 
    // Have to re-arrange C and D a tiny bit so that each contains 28 bits and we throw away 8 bits
    Dr = (Dr & 0x00ffffff) | ((Cr & 0xf0000000 ) >> 4 );
    Cr = (Cr & 0x0fffffff);
 
    for( r = 0; r < 16; r++)
    {
        //
        // Cr and Dr are the two key shift registers, they are rotated once or twice for each round.
        //
 
        if( SymCryptDesDoubleShift[ r ] ) {
            Cr = ((Cr >> 2) | (Cr << 26));
            Dr = ((Dr >> 2) | (Dr << 26));
        } else {
            Cr = ((Cr >> 1) | (Cr << 27));
            Dr = ((Dr >> 1) | (Dr << 27));
        }
 
        Cr &= 0x0fffffff;
        Dr &= 0x0fffffff;
 
        //
        // The Permuted Choice 2 is done using table lookups
        // Not all bits of C and D are used, so we cut those out using shifts and masks,
        // and then index 6 bits at a time into lookup tables that implement the bit relocation.
        //
 
        K1 = SymCryptDesKeySelect[0][ (Cr      )&0x3f                     ] |
             SymCryptDesKeySelect[1][((Cr >>  6)&0x03) | ((Cr >>  7)&0x3c)] |
             SymCryptDesKeySelect[2][((Cr >> 13)&0x0f) | ((Cr >> 14)&0x30)] |
             SymCryptDesKeySelect[3][((Cr >> 20)&0x01) | ((Cr >> 21)&0x06) | ((Cr >> 22)&0x38)];
 
        K2 = SymCryptDesKeySelect[4][ (Dr      )&0x3f                     ] |
             SymCryptDesKeySelect[5][((Dr >>  7)&0x03) | ((Dr >>  8)&0x3c)] |
             SymCryptDesKeySelect[6][ (Dr >> 15)&0x3f                     ] |
             SymCryptDesKeySelect[7][((Dr >> 21)&0x0f) | ((Dr >> 22)&0x30)];
 
        //
        // After this we still have to swap the halves of K1 and K2, that is done below
        // as part of the formatting of the round key
        //
 
        //
        // So far we have recreated the round keys per the standard.
        // The round keys are stored rotated by 2 as the encrypt/decrypt code finds that easier.
        // We could update the tables to do this, but key expansion is not used that frequently,
        // and it is not worth the effort to update the tables.
        //
        // We don't worry about extraneous bits in unused positions as the F function masks out unused bits.
        //
 
        tmp = ((K2 << 16) | (K1 & 0x0000ffff)) ;
        expandedKeyTable[r][0] = ROL32(tmp, 2);
 
        tmp = ((K1 >> 16) | (K2 & 0xffff0000));
        expandedKeyTable[r][1] = ROL32(tmp, 6);
    }
}

Referenced by SymCrypt3DesExpandKey().

SymCryptDesSelftest()

VOID SYMCRYPT_CALL SymCryptDesSelftest

(

void

)

Definition at line 624 of file 3des.c.

{
    BYTE                        buf[SYMCRYPT_DES_BLOCK_SIZE];
    SYMCRYPT_DES_EXPANDED_KEY   key;
 
    if( SymCryptDesExpandKey( &key, SP800_67Key, 8 ) != SYMCRYPT_NO_ERROR )
    {
        SymCryptFatal( 'desa' );
    }
 
    SymCryptDesEncrypt( &key, des3KnownPlaintext, buf );
 
    SymCryptInjectError( buf, SYMCRYPT_DES_BLOCK_SIZE );
 
    if( memcmp( buf, desKnownCiphertext, SYMCRYPT_DES_BLOCK_SIZE ) != 0 )
    {
        SymCryptFatal( 'desb' );
    }
 
    SymCryptDesDecrypt( &key, desKnownCiphertext, buf );
 
    SymCryptInjectError( buf, SYMCRYPT_DES_BLOCK_SIZE );
 
    if( memcmp( buf, des3KnownPlaintext, SYMCRYPT_DES_BLOCK_SIZE ) != 0 )
    {
        SymCryptFatal( 'desc' );
    }
}

SymCryptDesSetOddParity()

VOID SYMCRYPT_CALL SymCryptDesSetOddParity	(	_Inout_updates_(cbData) PBYTE	pbData,
		_In_ SIZE_T	cbData
	)

Definition at line 577 of file 3des.c.

{
    SIZE_T i;
    BYTE b, t;
    for( i=0; i<cbData; i++ )
    {
        // We obey the read-once write-once rule
        b = *pbData;
 
        t = b ^ (b>>4);     // parity(b) = parity( t & 0xf )
        t ^= t>>2;          //           = parity( t & 0x3 )
        t ^= t>>1;          //           = parity( t & 0x1 )
        *pbData++ = b ^ (t&1) ^ 1;
    }
}

Variable Documentation

des3KnownCiphertext

const BYTE des3KnownCiphertext[8]

static

Initial value:

= {
    0x31, 0x4F, 0x83, 0x27, 0xFA, 0x7A, 0x09, 0xA8,
}

Definition at line 613 of file 3des.c.

Referenced by SymCrypt3DesSelftest().

des3KnownPlaintext

const BYTE des3KnownPlaintext[8]

static

Initial value:

= {
    0x4E, 0x6F, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74,
}

Definition at line 609 of file 3des.c.

Referenced by SymCrypt3DesSelftest(), and SymCryptDesSelftest().

desKnownCiphertext

const BYTE desKnownCiphertext[8]

static

Initial value:

= {
    0x3F, 0xA4, 0x0E, 0x8A, 0x98, 0x4D, 0x48, 0x15,
}

Definition at line 617 of file 3des.c.

Referenced by SymCryptDesSelftest().

SP800_67Key

const BYTE SP800_67Key[24]

static

Initial value:

= {
    0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
    0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01,
    0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23,
}

Definition at line 603 of file 3des.c.

Referenced by SymCrypt3DesSelftest(), and SymCryptDesSelftest().

SymCrypt3DesBlockCipher

const PCSYMCRYPT_BLOCKCIPHER SymCrypt3DesBlockCipher = &SymCrypt3DesBlockCipher_default

Definition at line 75 of file 3des.c.

Referenced by SymCrypt3DesCbcDecrypt(), and SymCrypt3DesCbcEncrypt().

SymCrypt3DesBlockCipher_default

const SYMCRYPT_BLOCKCIPHER SymCrypt3DesBlockCipher_default

Initial value:

= {
    SymCrypt3DesExpandKey,  
    SymCrypt3DesEncrypt,    
    SymCrypt3DesDecrypt,    
    NULL,                   
    NULL,                   
    NULL,                   
    NULL,                   
    NULL,                   
    NULL,                   
    NULL,                   
    NULL,                   
    8,                      
    sizeof( SYMCRYPT_3DES_EXPANDED_KEY ), 
}

Definition at line 43 of file 3des.c.

SymCryptDesBlockCipher

const PCSYMCRYPT_BLOCKCIPHER SymCryptDesBlockCipher = &SymCryptDesBlockCipher_default

Definition at line 76 of file 3des.c.

SymCryptDesBlockCipher_default

const SYMCRYPT_BLOCKCIPHER SymCryptDesBlockCipher_default

Initial value:

= {
    SymCryptDesExpandKey,   
    SymCryptDesEncrypt,     
    SymCryptDesDecrypt,     
    NULL,                   
    NULL,                   
    NULL,                   
    NULL,                   
    NULL,                   
    NULL,                   
    NULL,                   
    NULL,                   
    8,                      
    sizeof( SYMCRYPT_DES_EXPANDED_KEY ), 
}

Definition at line 59 of file 3des.c.