void testSet() {
u8 data1[1024], data2[1024];
u8 *result;
printf("sce_paf_private_memset:\n");
resetData(data1, data2);
result = sce_paf_private_memset(data1, 2, 256);
printf("2: %d vs %d, %d\n", checksumData(data1), checksumData(data2), result == data1);
resetData(data1, data2);
result = sce_paf_private_memset(data1, 255, 1);
printf("255: %d vs %d, %d\n", checksumData(data1), checksumData(data2), result == data1);
resetData(data1, data2);
result = sce_paf_private_memset(data1, 1024, 1);
printf("1024: %d vs %d, %d\n", checksumData(data1), checksumData(data2), result == data1);
resetData(data1, data2);
result = sce_paf_private_memset(data1, 255, 0);
printf("0 bytes long: %d vs %d, %d\n", checksumData(data1), checksumData(data2), result == data1);
printf("NULL 0 bytes long: %08X\n", (unsigned int) sce_paf_private_memset(NULL, 1024, 0));
printf("Invalid 0 bytes long: %08X\n", (unsigned int) sce_paf_private_memset((u8 *) 0xDEADBEEF, 1024, 0));
}
void testCopy() {
u8 data1[1024], data2[1024];
u8 *result;
printf("sce_paf_private_memcpy:\n");
resetData(data1, data2);
result = sce_paf_private_memcpy(data1, data2, 256);
printf("256: %d vs %d, %d\n", checksumData(data1), checksumData(data2), result == data1);
resetData(data1, data2);
result = sce_paf_private_memcpy(data1, data2, 1);
printf("1: %d vs %d, %d\n", checksumData(data1), checksumData(data2), result == data1);
resetData(data1, data2);
result = sce_paf_private_memcpy(data1, data2, 0);
printf("0: %d vs %d, %d\n", checksumData(data1), checksumData(data2), result == data1);
resetData(data1, data2);
sce_paf_private_memcpy(data1, data2, 16);
result = sce_paf_private_memcpy(data1 + 16, data1, 240);
printf("Overlapping: %d vs %d, %d\n", checksumData(data1), checksumData(data2), result == data1 + 16);
printf("NULL -> NULL 0 bytes long: %08X\n", (unsigned int) sce_paf_private_memcpy(NULL, NULL, 0));
printf("Invalid -> Invalid 0 bytes long: %08X\n", (unsigned int) sce_paf_private_memcpy((u8 *) 0xDEADBEEF, (u8 *) 0xDEADBEEF, 0));
}
CHECK_RETVAL \
int checkDHdata( void )
{
HASHFUNCTION_ATOMIC hashFunctionAtomic;
BYTE hashValue[ 20 + 8 ];
getHashAtomicParameters( CRYPT_ALGO_SHA1, 0, &hashFunctionAtomic, NULL );
/* Generate/check the SHA-1 values for the primes. This doesn't cover
all of the data, but is needed to bootstrap the full check because
only the hashes of the primes have been published */
#if 0
hashFunctionAtomic( hashValue, 20, dh1024SSL + 2, sizeof( dh1024SSL ) - 5 );
hashFunctionAtomic( hashValue, 20, dh1536SSL + 2, sizeof( dh1536SSL ) - 5 );
hashFunctionAtomic( hashValue, 20, dh2048SSL + 2, sizeof( dh2048SSL ) - 5 );
hashFunctionAtomic( hashValue, 20, dh3072SSL + 2, sizeof( dh3072SSL ) - 5 );
#endif /* 0 */
/* Check the SHA-1 values for the DH data */
hashFunctionAtomic( hashValue, 20, dh1024SSL, sizeof( dh1024SSL ) );
if( memcmp( hashValue, \
"\x46\xF4\x47\xC3\x69\x00\x6F\x22\x91\x0E\x24\xF5\x73\x68\xE6\xF7", 16 ) )
retIntError();
hashFunctionAtomic( hashValue, 20, dh1536SSL, sizeof( dh1536SSL ) );
if( memcmp( hashValue, \
"\xA3\xEC\x2F\x85\xC7\xD3\x74\xD2\x56\x53\x22\xED\x53\x87\x6F\xDC", 16 ) )
retIntError();
hashFunctionAtomic( hashValue, 20, dh2048SSL, sizeof( dh2048SSL ) );
if( memcmp( hashValue, \
"\x0E\x8E\x49\x9F\xD9\x18\x02\xCB\x5D\x42\x03\xA5\xE1\x67\x51\xDB", 16 ) )
retIntError();
hashFunctionAtomic( hashValue, 20, dh3072SSL, sizeof( dh3072SSL ) );
if( memcmp( hashValue, \
"\x8F\x4A\x19\xEF\x85\x1D\x91\xEA\x18\xE8\xB8\xB9\x9F\xF0\xFD\xF8", 16 ) )
retIntError();
/* Now that we've verified that the DH data is valid, calculate a
checksum for each value to allow it to be quickly checked before it's
loaded into a context */
dh1024checksum = checksumData( dh1024SSL, sizeof( dh1024SSL ) );
dh1536checksum = checksumData( dh1536SSL, sizeof( dh1536SSL ) );
dh2048checksum = checksumData( dh2048SSL, sizeof( dh2048SSL ) );
dh3072checksum = checksumData( dh3072SSL, sizeof( dh3072SSL ) );
return( CRYPT_OK );
}
static int checksumMemHdr( INOUT MEM_INFO_HEADER *memHdrPtr )
{
const int memHdrChecksum = memHdrPtr->checksum;
int checksum;
memHdrPtr->checksum = 0;
checksum = checksumData( memHdrPtr, MEM_INFO_HEADERSIZE );
memHdrPtr->checksum = memHdrChecksum;
return( checksum );
}
static void setMemChecksum( INOUT MEM_INFO_HEADER *memHdrPtr )
{
MEM_INFO_TRAILER *memTrlPtr;
assert( isWritePtr( memHdrPtr, sizeof( MEM_INFO_HEADER * ) ) );
memHdrPtr->checksum = 0; /* Set mutable members to zero */
memHdrPtr->checksum = checksumData( memHdrPtr, MEM_INFO_HEADERSIZE );
memTrlPtr = ( MEM_INFO_TRAILER * ) \
( ( BYTE * ) memHdrPtr + memHdrPtr->size - MEM_INFO_TRAILERSIZE );
memTrlPtr->checksum = memHdrPtr->checksum;
}
whether we have an optimal or suboptimal implementation of a
fundamentally broken mechanism like CRLs.
The value is either a serialNumber or a hash of some form (issuerID,
certHash), we don't bother distinguishing the exact type since the
chances of a hash collision are virtually nonexistant */
CHECK_RETVAL STDC_NONNULL_ARG( ( 1, 2, 3 ) ) \
static int findRevocationEntry( const REVOCATION_INFO *listPtr,
OUT_OPT_PTR REVOCATION_INFO **insertPoint,
IN_BUFFER( valueLength ) const void *value,
IN_LENGTH_SHORT const int valueLength,
const BOOLEAN sortEntries )
{
const REVOCATION_INFO *prevElement = NULL;
const int idCheck = checksumData( value, valueLength );
int iterationCount;
assert( isReadPtr( listPtr, sizeof( REVOCATION_INFO ) ) );
assert( isWritePtr( insertPoint, sizeof( REVOCATION_INFO * ) ) );
assert( isReadPtr( value, valueLength ) );
REQUIRES( valueLength > 0 && valueLength < MAX_INTLENGTH_SHORT );
/* Clear return value */
*insertPoint = NULL;
/* Find the correct place in the list to insert the new element and check
for duplicates. If requested we sort the entries by serial number
(or more generally data value) for no adequately explored reason
(some implementations can optimise the searching of CRLs based on
CHECK_RETVAL \
int loadDHcontext( IN_HANDLE const CRYPT_CONTEXT iDHContext,
IN_LENGTH_SHORT_OPT const int requestedKeySize )
{
MESSAGE_DATA msgData;
const void *keyData;
const int actualKeySize = \
( requestedKeySize < 128 + 8 ) ? bitsToBytes( 1024 ) : \
( requestedKeySize < 192 + 8 ) ? bitsToBytes( 1536 ) : \
( requestedKeySize < 256 + 8 ) ? bitsToBytes( 2048 ) : \
( requestedKeySize < 384 + 8 ) ? bitsToBytes( 3072 ) : \
0;
int keyDataLength, keyDataChecksum;
REQUIRES( isHandleRangeValid( iDHContext ) );
REQUIRES( requestedKeySize >= MIN_PKCSIZE && \
requestedKeySize <= CRYPT_MAX_PKCSIZE );
/* Load the built-in DH key value that corresponds best to the client's
requested key size. We allow for a bit of slop to avoid having
something like a 1025-bit requested key size lead to the use of a
1536-bit key value.
In theory we should probably generate a new DH key each time:
status = krnlSendMessage( iDHContext, IMESSAGE_SETATTRIBUTE,
( MESSAGE_CAST ) &requestedKeySize,
CRYPT_CTXINFO_KEYSIZE );
if( cryptStatusOK( status ) )
status = krnlSendMessage( iDHContext, IMESSAGE_CTX_GENKEY,
NULL, FALSE );
however because the handshake is set up so that the client (rather
than the server) chooses the key size we can't actually perform the
generation until we're in the middle of the handshake. This means
that the server will grind to a halt during each handshake as it
generates a new key of whatever size takes the client's fancy (it
also leads to a nice potential DoS attack on the server). To avoid
this problem we use fixed keys of various common sizes.
As late as 2014 Java still can't handle DH keys over 1024 bits (it
only allows keys ranging from 512-1024 bits):
java.security.InvalidAlgorithmParameterException: Prime size must be
multiple of 64, and can only range from 512 to 1024 (inclusive)
so if you need to talk to a system built in Java you need to hardcode
the key size below to 1024 bits, the largest size that Java will
allow */
switch( actualKeySize )
{
case bitsToBytes( 1024 ):
keyData = dh1024SSL;
keyDataLength = sizeof( dh1024SSL );
keyDataChecksum = dh1024checksum;
break;
case bitsToBytes( 1536 ):
keyData = dh1536SSL;
keyDataLength = sizeof( dh1536SSL );
keyDataChecksum = dh1536checksum;
break;
case bitsToBytes( 2048 ):
keyData = dh2048SSL;
keyDataLength = sizeof( dh2048SSL );
keyDataChecksum = dh2048checksum;
break;
case bitsToBytes( 3072 ):
default: /* Hier ist der mast zu ende */
keyData = dh3072SSL;
keyDataLength = sizeof( dh3072SSL );
keyDataChecksum = dh3072checksum;
break;
}
/* Make sure that the key data hasn't been corrupted */
if( keyDataChecksum != checksumData( keyData, keyDataLength ) )
{
DEBUG_DIAG(( "Fixed DH value for %d-bit key has been corrupted",
bytesToBits( actualKeySize ) ));
retIntError();
}
/* Load the fixed DH key into the context */
setMessageData( &msgData, ( MESSAGE_CAST ) keyData, keyDataLength );
return( krnlSendMessage( iDHContext, IMESSAGE_SETATTRIBUTE_S, &msgData,
CRYPT_IATTRIBUTE_KEY_SSL ) );
}
