static int selfTest( void )
{
const CAPABILITY_INFO *capabilityInfo = getBlowfishCapability();
BYTE keyData[ BLOWFISH_EXPANDED_KEYSIZE + 8 ];
BYTE *plain1 = ( BYTE * ) "BLOWFISH";
BYTE *key1 = ( BYTE * ) "abcdefghijklmnopqrstuvwxyz";
BYTE cipher1[] = { 0x32, 0x4E, 0xD0, 0xFE, 0xF4, 0x13, 0xA2, 0x03 };
BYTE plain2[] = { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 };
BYTE *key2 = ( BYTE * ) "Who is John Galt?";
BYTE cipher2[] = { 0xCC, 0x91, 0x73, 0x2B, 0x80, 0x22, 0xF6, 0x84 };
BYTE plain3[] = { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 };
BYTE key3[] = { 0x41, 0x79, 0x6E, 0xA0, 0x52, 0x61, 0x6E, 0xE4 };
BYTE cipher3[] = { 0xE1, 0x13, 0xF4, 0x10, 0x2C, 0xFC, 0xCE, 0x43 };
int status;
/* Test the Blowfish implementation */
status = testCipher( capabilityInfo, keyData, key1,
strlen( ( char * ) key1 ), plain1, cipher1 );
if( cryptStatusOK( status ) )
status = testCipher( capabilityInfo, keyData, key2,
strlen( ( char * ) key2 ), plain2, cipher2 );
if( cryptStatusOK( status ) )
status = testCipher( capabilityInfo, keyData, key3, 8, plain3,
cipher3 );
return( status );
}
static int testLoop( const DES_TEST *testDES, int iterations )
{
const CAPABILITY_INFO *capabilityInfo = get3DESCapability();
BYTE keyData[ DES3_KEYSIZE + 8 ];
int i, status;
for( i = 0; i < iterations; i++ )
{
BYTE desKeyData[ ( DES_BLOCKSIZE * 3 ) + 8 ];
memcpy( desKeyData, testDES[ i ].key, DES_BLOCKSIZE );
memcpy( desKeyData + DES_BLOCKSIZE, testDES[ i ].key,
DES_BLOCKSIZE );
memcpy( desKeyData + ( DES_BLOCKSIZE * 2 ), testDES[ i ].key,
DES_BLOCKSIZE );
/* The self-test uses weak keys, which means they'll be rejected by
the key-load function if it checks for these. For the OpenSSL
DES implementation we can kludge around this by temporarily
clearing the global des_check_key value, but for other
implementations some alternative workaround will be necessary */
des_check_key = FALSE;
status = testCipher( capabilityInfo, keyData, desKeyData,
DES_BLOCKSIZE * 3, testDES[ i ].plaintext,
testDES[ i ].ciphertext );
des_check_key = TRUE;
if( cryptStatusError( status ) )
return( status );
}
return( CRYPT_OK );
}
static int selfTest( void )
{
const CAPABILITY_INFO *capabilityInfo = getRC2Capability();
BYTE keyData[ RC2_EXPANDED_KEYSIZE + 8 ];
int i, status;
for( i = 0; i < sizeof( testRC2 ) / sizeof( struct RC2_TEST ); i++ )
{
status = testCipher( capabilityInfo, keyData, testRC2[ i ].key,
16, testRC2[ i ].plaintext,
testRC2[ i ].ciphertext );
if( cryptStatusError( status ) )
return( status );
}
return( CRYPT_OK );
}
static int selfTest( void )
{
const CAPABILITY_INFO *capabilityInfo = getIDEACapability();
BYTE keyData[ IDEA_EXPANDED_KEYSIZE + 8 ];
int i, status;
memset( keyData, 0, IDEA_EXPANDED_KEYSIZE ); /* Keep static analysers happy */
for( i = 0; i < sizeof( testIdea ) / sizeof( IDEA_TEST ); i++ )
{
status = testCipher( capabilityInfo, keyData, testIdea[ i ].key,
16, testIdea[ i ].plaintext,
testIdea[ i ].ciphertext );
if( cryptStatusError( status ) )
return( status );
}
return( CRYPT_OK );
}
static int selfTest( void )
{
#if 0
/* ECB */
static const BYTE FAR_BSS mctECBKey[] = \
{ 0x8D, 0x2E, 0x60, 0x36, 0x5F, 0x17, 0xC7, 0xDF, 0x10, 0x40, 0xD7, 0x50, 0x1B, 0x4A, 0x7B, 0x5A };
static const BYTE FAR_BSS mctECBPT[] = \
{ 0x59, 0xB5, 0x08, 0x8E, 0x6D, 0xAD, 0xC3, 0xAD, 0x5F, 0x27, 0xA4, 0x60, 0x87, 0x2D, 0x59, 0x29 };
/* CBC */
static const BYTE FAR_BSS mctCBCKey[] = \
{ 0x9D, 0xC2, 0xC8, 0x4A, 0x37, 0x85, 0x0C, 0x11, 0x69, 0x98, 0x18, 0x60, 0x5F, 0x47, 0x95, 0x8C };
static const BYTE FAR_BSS mctCBCIV[] = \
{ 0x25, 0x69, 0x53, 0xB2, 0xFE, 0xAB, 0x2A, 0x04, 0xAE, 0x01, 0x80, 0xD8, 0x33, 0x5B, 0xBE, 0xD6 };
static const BYTE FAR_BSS mctCBCPT[] = \
{ 0x2E, 0x58, 0x66, 0x92, 0xE6, 0x47, 0xF5, 0x02, 0x8E, 0xC6, 0xFA, 0x47, 0xA5, 0x5A, 0x2A, 0xAB };
/* OFB */
static const BYTE FAR_BSS mctOFBKey[] = \
{ 0xB1, 0x1E, 0x4E, 0xCA, 0xE2, 0xE7, 0x1E, 0x14, 0x14, 0x5D, 0xD7, 0xDB, 0x26, 0x35, 0x65, 0x2F };
static const BYTE FAR_BSS mctOFBIV[] = \
{ 0xAD, 0xD3, 0x2B, 0xF8, 0x20, 0x4C, 0x33, 0x33, 0x9C, 0x54, 0xCD, 0x58, 0x58, 0xEE, 0x0D, 0x13 };
static const BYTE FAR_BSS mctOFBPT[] = \
{ 0x73, 0x20, 0x49, 0xE8, 0x9D, 0x74, 0xFC, 0xE7, 0xC5, 0xA4, 0x96, 0x64, 0x04, 0x86, 0x8F, 0xA6 };
/* CFB-128 */
static const BYTE FAR_BSS mctCFBKey[] = \
{ 0x71, 0x15, 0x11, 0x93, 0x1A, 0x15, 0x62, 0xEA, 0x73, 0x29, 0x0A, 0x8B, 0x0A, 0x37, 0xA3, 0xB4 };
static const BYTE FAR_BSS mctCFBIV[] = \
{ 0x9D, 0xCE, 0x23, 0xFD, 0x2D, 0xF5, 0x36, 0x0F, 0x79, 0x9C, 0xF1, 0x79, 0x84, 0xE4, 0x7C, 0x8D };
static const BYTE FAR_BSS mctCFBPT[] = \
{ 0xF0, 0x66, 0xBE, 0x4B, 0xD6, 0x71, 0xEB, 0xC1, 0xC4, 0xCF, 0x3C, 0x00, 0x8E, 0xF2, 0xCF, 0x18 };
#endif /* 0 */
const CAPABILITY_INFO *capabilityInfo = getAESCapability();
BYTE keyData[ AES_EXPANDED_KEYSIZE + 8 ];
int i, status;
/* The AES code requires 16-byte alignment for data structures, before
we try anything else we make sure that the compiler voodoo required
to handle this has worked */
if( aes_test_alignment_detection( 16 ) != EXIT_SUCCESS )
return( CRYPT_ERROR_FAILED );
for( i = 0; i < sizeof( testAES ) / sizeof( AES_TEST ); i++ )
{
status = testCipher( capabilityInfo, keyData, testAES[ i ].key,
testAES[ i ].keySize, testAES[ i ].plaintext,
testAES[ i ].ciphertext );
if( cryptStatusError( status ) )
return( status );
}
#if 0 /* OK */
staticInitContext( &contextInfo, CONTEXT_CONV, capabilityInfo,
&contextData, sizeof( CONV_INFO ), keyData );
status = mct( &contextInfo, capabilityInfo, mctECBKey, 16,
NULL, mctECBPT );
staticDestroyContext( &contextInfo );
if( cryptStatusError( status ) )
return( CRYPT_ERROR_FAILED );
#endif
#if 0 /* OK */
staticInitContext( &contextInfo, CONTEXT_CONV, capabilityInfo,
&contextData, sizeof( CONV_INFO ), keyData );
status = mct( &contextInfo, capabilityInfo, mctCBCKey, 16,
mctCBCIV, mctCBCPT );
staticDestroyContext( &contextInfo );
if( cryptStatusError( status ) )
return( CRYPT_ERROR_FAILED );
#endif
return( CRYPT_OK );
}
