X-Git-Url: https://git.saurik.com/apple/security.git/blobdiff_plain/80e2389990082500d76eb566d4946be3e786c3ef..d8f41ccd20de16f8ebe2ccc84d47bf1cb2b26bbb:/SecurityTests/clxutils/threadTest/desTest.cpp diff --git a/SecurityTests/clxutils/threadTest/desTest.cpp b/SecurityTests/clxutils/threadTest/desTest.cpp new file mode 100644 index 00000000..0cd82d82 --- /dev/null +++ b/SecurityTests/clxutils/threadTest/desTest.cpp @@ -0,0 +1,296 @@ +/* + * Simple DES encrypt/decrypt test using raw BSAFE + */ +#include "testParams.h" +#include +#include +#include +#include +#include +#include +#include + +/* for memory leak debug only, with only one thread running */ +#define DO_PAUSE 0 +#define SAFE_RAND_DATA 0 + +#define PTEXT_SIZE 1024 +#define KEY_SIZE_BITS 64 +#define KEY_SIZE_BYTES (KEY_SIZE_BITS / 8) +#define DES_BLOCK_SIZE 8 + +static B_ALGORITHM_METHOD *BSAFE_ALGORITHM_CHOOSER[] = { + &AM_MD5_RANDOM, + &AM_MD, + &AM_MD5, + &AM_CBC_ENCRYPT, + &AM_CBC_DECRYPT, + &AM_OFB_ENCRYPT, + &AM_OFB_DECRYPT, + &AM_DES_DECRYPT, + &AM_DES_ENCRYPT, + (B_ALGORITHM_METHOD *)NULL_PTR +}; + +/* generate DES key */ +static int desGenKey( + const TestParams *testParams, + B_KEY_OBJ *desKey) +{ + int brtn; + uint8 keyBytes[KEY_SIZE_BYTES]; + CSSM_DATA keyData = {KEY_SIZE_BYTES, keyBytes}; + + B_DestroyKeyObject(desKey); + brtn = B_CreateKeyObject(desKey); + if(brtn) { + printf("***Error on B_CreateKeyObject (%d)\n", brtn); + return 1; + } + #if SAFE_RAND_DATA + threadGetRandData(testParams, &keyData, KEY_SIZE_BYTES); + #else + simpleGenData(&keyData, KEY_SIZE_BYTES, KEY_SIZE_BYTES); + #endif + + brtn = B_SetKeyInfo(*desKey, KI_DES8, (POINTER)keyBytes); + if(brtn) { + printf("***Error on B_SetKeyInfo (%d)\n", brtn); + return 1; + } + + return 0; + +} + +/* common code to set up encrypt/decrypt */ +static int desEncDecSetup( + ITEM *iv, + B_BLK_CIPHER_W_FEEDBACK_PARAMS *spec, + B_ALGORITHM_OBJ *alg) +{ + int brtn; + + spec->encryptionMethodName = POINTER("des"); + spec->feedbackMethodName = POINTER("cbc"); + spec->feedbackParams = POINTER(iv); + spec->paddingParams = NULL_PTR; + spec->encryptionParams = NULL_PTR; + spec->paddingMethodName = POINTER("pad"); + + brtn = B_CreateAlgorithmObject(alg); + if(brtn) { + printf("***B_CreateAlgorithmObject error (%d)\n", brtn); + return 1; + } + brtn = B_SetAlgorithmInfo(*alg, AI_FeedbackCipher, (POINTER)spec); + if(brtn) { + printf("***B_SetAlgorithmInfo error (%d)\n", brtn); + return 1; + } + return 0; +} + +static int desEncrypt( + TestParams *testParams, + B_KEY_OBJ desKey, + uint8 *initVector, + CSSM_DATA *ptext, + CSSM_DATA *ctext) +{ + ITEM iv; + B_BLK_CIPHER_W_FEEDBACK_PARAMS spec; + B_ALGORITHM_OBJ alg = NULL; + int brtn; + unsigned actLen; + unsigned remCtext = ctext->Length; + + iv.data = initVector; + iv.len = DES_BLOCK_SIZE; + brtn = desEncDecSetup(&iv, &spec, &alg); + if(brtn) { + return brtn; + } + brtn = B_EncryptInit(alg, + desKey, + BSAFE_ALGORITHM_CHOOSER, + (A_SURRENDER_CTX *)NULL_PTR); + if(brtn) { + printf("***B_EncryptInit error (%d)\n", brtn); + return brtn; + } + brtn = B_EncryptUpdate(alg, + ctext->Data, + &actLen, + remCtext, + ptext->Data, + ptext->Length, + (B_ALGORITHM_OBJ)NULL_PTR, + (A_SURRENDER_CTX *)NULL_PTR); + if(brtn) { + printf("***B_EncryptUpdate error (%d)\n", brtn); + return brtn; + } + remCtext -= actLen; + ctext->Length = actLen; + brtn = B_EncryptFinal(alg, + ctext->Data + actLen, + &actLen, + remCtext, + (B_ALGORITHM_OBJ)NULL_PTR, + (A_SURRENDER_CTX *)NULL_PTR); + if(brtn) { + printf("***B_EncryptFinal error (%d)\n", brtn); + return brtn; + } + ctext->Length += actLen; + B_DestroyAlgorithmObject (&alg); + return 0; +} + +static int desDecrypt( + TestParams *testParams, + B_KEY_OBJ desKey, + uint8 *initVector, + CSSM_DATA *ctext, + CSSM_DATA *ptext) +{ + ITEM iv; + B_BLK_CIPHER_W_FEEDBACK_PARAMS spec; + B_ALGORITHM_OBJ alg = NULL; + int brtn; + unsigned actLen; + unsigned remPtext = ptext->Length; + + iv.data = initVector; + iv.len = DES_BLOCK_SIZE; + brtn = desEncDecSetup(&iv, &spec, &alg); + if(brtn) { + return brtn; + } + brtn = B_DecryptInit(alg, + desKey, + BSAFE_ALGORITHM_CHOOSER, + (A_SURRENDER_CTX *)NULL_PTR); + if(brtn) { + printf("***B_DecryptInit error (%d)\n", brtn); + return brtn; + } + brtn = B_DecryptUpdate(alg, + ptext->Data, + &actLen, + remPtext, + ctext->Data, + ctext->Length, + (B_ALGORITHM_OBJ)NULL_PTR, + (A_SURRENDER_CTX *)NULL_PTR); + if(brtn) { + printf("***B_DecryptUpdate error (%d)\n", brtn); + return brtn; + } + remPtext -= actLen; + ptext->Length = actLen; + brtn = B_DecryptFinal(alg, + ptext->Data + actLen, + &actLen, + remPtext, + (B_ALGORITHM_OBJ)NULL_PTR, + (A_SURRENDER_CTX *)NULL_PTR); + if(brtn) { + printf("***B_DecryptFinal error (%d)\n", brtn); + return brtn; + } + ptext->Length += actLen; + B_DestroyAlgorithmObject (&alg); + return 0; +} + +int desInit(TestParams *testParams) +{ + /* nothing for now */ + return 0; +} + +int desTest(TestParams *testParams) +{ + unsigned loop; + CSSM_RETURN crtn; + CSSM_DATA ptext = {0, NULL}; + CSSM_DATA ctext = {0, NULL}; + CSSM_DATA rptext = {0, NULL}; + B_KEY_OBJ desKey = NULL; + uint8 *initVector = (uint8 *)"someStrangeInitVect"; + int rtn; + + ptext.Data = (uint8 *)CSSM_MALLOC(PTEXT_SIZE); + ptext.Length = PTEXT_SIZE; + rptext.Data = (uint8 *)CSSM_MALLOC(PTEXT_SIZE); + rptext.Length = PTEXT_SIZE; + ctext.Data = (uint8 *)CSSM_MALLOC(PTEXT_SIZE + DES_BLOCK_SIZE); + ctext.Length = PTEXT_SIZE + DES_BLOCK_SIZE; + + for(loop=0; loopnumLoops; loop++) { + if(testParams->verbose) { + printf("symTest thread %d: loop %d\n", + testParams->threadNum, loop); + } + else if(!testParams->quiet) { + printChar(testParams->progressChar); + } + + /* random plaintext */ + #if SAFE_RAND_DATA + crtn = threadGetRandData(testParams, &ptext, PTEXT_SIZE); + if(crtn) { + return 1; + } + #else + simpleGenData(&ptext, PTEXT_SIZE, PTEXT_SIZE); + #endif + + /* cook up a key */ + rtn = desGenKey(testParams, &desKey); + if(rtn) { + return 1; + } + + /* encrypt, decrypt */ + ctext.Length = PTEXT_SIZE + DES_BLOCK_SIZE; + rtn = desEncrypt(testParams, + desKey, + initVector, + &ptext, + &ctext); + if(rtn) { + return 1; + } + rptext.Length = PTEXT_SIZE + DES_BLOCK_SIZE; + rtn = desDecrypt(testParams, + desKey, + initVector, + &ctext, + &rptext); + if(crtn) { + return 1; + } + + /* compare */ + if(ptext.Length != rptext.Length) { + printf("Ptext length mismatch: expect %d, got %d\n", + ptext.Length, rptext.Length); + return 1; + } + if(memcmp(ptext.Data, rptext.Data, ptext.Length)) { + printf("***data miscompare\n"); + return 1; + } + + #if DO_PAUSE + fpurge(stdin); + printf("Hit CR to proceed: "); + getchar(); + #endif + } + return 0; +} +