+/*
+ * contextReuse.cpp
+ *
+ * Verify proper operation of symmetric CSP algorithms when CSSM_CC_HANDLE
+ * (crypto context) is reused. Tests specifically for Radar 4551700, which
+ * dealt with a problem with the Gladman AES implementation handling the
+ * same context for an encrypt followed by a decrypt; other situations
+ * are tested here (e.g. encrypt followed by another encrypt including CBC)
+ * as well as all CSP symmetric algorithms.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <Security/cssm.h>
+#include <Security/cssmapple.h>
+#include "cspwrap.h"
+#include "common.h"
+#include <string.h>
+#include "cspdlTesting.h"
+
+/*
+ * Defaults.
+ */
+#define LOOPS_DEF 200
+
+#define MIN_DATA_SIZE 8
+#define MAX_DATA_SIZE 10000 /* bytes */
+#define MAX_KEY_SIZE MAX_KEY_SIZE_RC245_BYTES /* bytes */
+#define LOOP_NOTIFY 20
+
+#define RAW_MODE CSSM_ALGMODE_ECB /* doesn't work for BSAFE */
+#define RAW_MODE_STREAM CSSM_ALGMODE_NONE
+#define COOKED_MODE CSSM_ALGMODE_CBCPadIV8
+
+#define RAW_MODE_STR "ECB"
+#define RAW_MODE_STREAM_STR "None"
+#define COOKED_MODE_STR "CBC/Pad"
+
+/*
+ * Enumerate algs our own way to allow iteration.
+ */
+typedef enum {
+ ALG_ASC = 1, // not tested - no reference available
+ ALG_DES = 1,
+ ALG_RC2,
+ ALG_RC4,
+ ALG_RC5,
+ ALG_3DES,
+ ALG_AES,
+ ALG_AES192, /* 192 bit block */
+ ALG_AES256, /* 256 bit block */
+ ALG_BFISH,
+ ALG_CAST
+} SymAlg;
+#define ALG_FIRST ALG_ASC
+#define ALG_LAST ALG_CAST
+
+static void usage(char **argv)
+{
+ printf("usage: %s [options]\n", argv[0]);
+ printf(" Options:\n");
+ printf(" a=algorithm (d=DES; 3=3DES3; 2=RC2; 4=RC4; 5=RC5; a=AES; A=AES192; \n");
+ printf(" 6=AES256; b=Blowfish; c=CAST; s=ASC; default=all)\n");
+ printf(" l=loops (default=%d; 0=forever)\n", LOOPS_DEF);
+ printf(" k=keySizeInBits\n");
+ printf(" m=maxPtextSize (default=%d)\n", MAX_DATA_SIZE);
+ printf(" n=minPtextSize (default=%d)\n", MIN_DATA_SIZE);
+ printf(" p=pauseInterval (default=0, no pause)\n");
+ printf(" D (CSP/DL; default = bare CSP)\n");
+ printf(" v(erbose)\n");
+ printf(" q(uiet)\n");
+ printf(" h(elp)\n");
+ exit(1);
+}
+
+#define LOG_STAGED_OPS 0
+#if LOG_STAGED_OPS
+#define soprintf(s) printf s
+#else
+#define soprintf(s)
+#endif
+
+/*
+ * Multipurpose encrypt. Like cspStagedEncrypt(), but it takes a
+ * context handle and doesn't have as many options.
+ */
+static CSSM_RETURN stagedEncrypt(
+ CSSM_CSP_HANDLE cspHand,
+ CSSM_CC_HANDLE cryptHand,
+ uint32 algorithm, // CSSM_ALGID_FEED, etc.
+ uint32 cipherBlockSizeBytes,// optional
+ const CSSM_DATA *iv, // init vector, optional
+ const CSSM_DATA *ptext,
+ CSSM_DATA_PTR ctext, // mallocd by caller, must be big enough!
+ CSSM_BOOL multiUpdates) // false:single update, true:multi updates
+{
+ CSSM_RETURN crtn;
+ CSSM_SIZE bytesEncrypted; // per update
+ CSSM_SIZE bytesEncryptedTotal = 0;
+ CSSM_RETURN ocrtn = CSSM_OK; // 'our' crtn
+ unsigned toMove; // remaining
+ unsigned thisMove; // bytes to encrypt on this update
+ CSSM_DATA thisPtext; // running ptr into ptext
+ CSSM_DATA thisCtext; // running ptr into ctext
+ CSSM_BOOL restoreErr = CSSM_FALSE;
+ CSSM_RETURN savedErr = CSSM_OK;
+ CSSM_SIZE ctextLen;
+
+ if(cipherBlockSizeBytes) {
+ crtn = AddContextAttribute(cryptHand,
+ CSSM_ATTRIBUTE_BLOCK_SIZE,
+ sizeof(uint32),
+ CAT_Uint32,
+ NULL,
+ cipherBlockSizeBytes);
+ if(crtn) {
+ printError("CSSM_UpdateContextAttributes", crtn);
+ ocrtn = crtn;
+ goto abort;
+ }
+ }
+
+ thisPtext = *ptext;
+ thisCtext = *ctext;
+ memset(ctext->Data, 0, ctext->Length);
+ ctextLen = ctext->Length;
+
+ crtn = CSSM_EncryptDataInit(cryptHand);
+ if(crtn) {
+ printError("CSSM_EncryptDataInit", crtn);
+ ocrtn = crtn;
+ goto abort;
+ }
+
+ toMove = ptext->Length;
+ while(toMove) {
+ if(multiUpdates) {
+ thisMove = genRand(1, toMove);
+ }
+ else {
+ /* just do one pass thru this loop */
+ thisMove = toMove;
+ }
+ thisPtext.Length = thisMove;
+ crtn = CSSM_EncryptDataUpdate(cryptHand,
+ &thisPtext,
+ 1,
+ &thisCtext,
+ 1,
+ &bytesEncrypted);
+ if(crtn) {
+ printError("CSSM_EncryptDataUpdate", crtn);
+ ocrtn = crtn;
+ goto abort;
+ }
+ soprintf(("*** EncryptDataUpdate: ptextLen 0x%x bytesEncrypted 0x%x\n",
+ (unsigned)thisMove, (unsigned)bytesEncrypted));
+
+ // NOTE: We return the proper length in ctext....
+ ctextLen -= bytesEncrypted; // bump out ptr
+ thisCtext.Length = ctextLen;
+ thisCtext.Data += bytesEncrypted;
+ bytesEncryptedTotal += bytesEncrypted;
+ thisPtext.Data += thisMove; // bump in ptr
+ toMove -= thisMove;
+ }
+ /* OK, one more */
+ crtn = CSSM_EncryptDataFinal(cryptHand, &thisCtext);
+ if(crtn) {
+ printError("CSSM_EncryptDataFinal", crtn);
+ savedErr = crtn;
+ restoreErr = CSSM_TRUE;
+ goto abort;
+ }
+ soprintf(("*** EncryptDataFinal: bytesEncrypted 0x%x\n",
+ (unsigned)thisCtext.Length));
+ bytesEncryptedTotal += thisCtext.Length;
+ ctext->Length = bytesEncryptedTotal;
+abort:
+ if(restoreErr) {
+ /* give caller the error from the encrypt */
+ ocrtn = savedErr;
+ }
+ return ocrtn;
+}
+
+/*
+ * Multipurpose decrypt. Like cspStagedDecrypt(), but it takes a
+ * context handle and doesn't have as many options.
+ */
+CSSM_RETURN stagedDecrypt(
+ CSSM_CSP_HANDLE cspHand,
+ CSSM_CC_HANDLE cryptHand,
+ uint32 algorithm, // CSSM_ALGID_FEED, etc.
+ uint32 cipherBlockSizeBytes,// optional
+ const CSSM_DATA *iv, // init vector, optional
+ const CSSM_DATA *ctext,
+ CSSM_DATA_PTR ptext, // mallocd by caller, must be big enough!
+ CSSM_BOOL multiUpdates) // false:single update, true:multi updates
+{
+ CSSM_RETURN crtn;
+ CSSM_SIZE bytesDecrypted; // per update
+ CSSM_SIZE bytesDecryptedTotal = 0;
+ CSSM_RETURN ocrtn = CSSM_OK; // 'our' crtn
+ unsigned toMove; // remaining
+ unsigned thisMove; // bytes to decrypt on this update
+ CSSM_DATA thisCtext; // running ptr into ptext
+ CSSM_DATA thisPtext; // running ptr into ctext
+ CSSM_SIZE ptextLen;
+
+ if(cipherBlockSizeBytes) {
+ crtn = AddContextAttribute(cryptHand,
+ CSSM_ATTRIBUTE_BLOCK_SIZE,
+ sizeof(uint32),
+ CAT_Uint32,
+ NULL,
+ cipherBlockSizeBytes);
+ if(crtn) {
+ printError("CSSM_UpdateContextAttributes", crtn);
+ ocrtn = crtn;
+ goto abort;
+ }
+ }
+
+ thisCtext = *ctext;
+ thisPtext = *ptext;
+ memset(ptext->Data, 0, ptext->Length);
+ ptextLen = ptext->Length;
+
+ crtn = CSSM_DecryptDataInit(cryptHand);
+ if(crtn) {
+ printError("CSSM_DecryptDataInit", crtn);
+ ocrtn = crtn;
+ goto abort;
+ }
+
+ toMove = ctext->Length;
+ while(toMove) {
+ if(multiUpdates) {
+ thisMove = genRand(1, toMove);
+ }
+ else {
+ /* just do one pass thru this loop */
+ thisMove = toMove;
+ }
+ thisCtext.Length = thisMove;
+ crtn = CSSM_DecryptDataUpdate(cryptHand,
+ &thisCtext,
+ 1,
+ &thisPtext,
+ 1,
+ &bytesDecrypted);
+ if(crtn) {
+ printError("CSSM_DecryptDataUpdate", crtn);
+ ocrtn = crtn;
+ goto abort;
+ }
+ soprintf(("*** DecryptDataUpdate: ctextLen 0x%x bytesDecrypted 0x%x\n",
+ (unsigned)thisMove, (unsigned)bytesDecrypted));
+
+ // NOTE: We return the proper length in ptext....
+ ptextLen -= bytesDecrypted; // bump out ptr
+ thisPtext.Length = ptextLen;
+ thisPtext.Data += bytesDecrypted;
+ bytesDecryptedTotal += bytesDecrypted;
+ thisCtext.Data += thisMove; // bump in ptr
+ toMove -= thisMove;
+ }
+ /* OK, one more */
+ crtn = CSSM_DecryptDataFinal(cryptHand, &thisPtext);
+ if(crtn) {
+ printError("CSSM_DecryptDataFinal", crtn);
+ ocrtn = crtn;
+ goto abort;
+ }
+ soprintf(("*** DecryptDataFinal: bytesEncrypted 0x%x\n",
+ (unsigned)thisPtext.Length));
+ bytesDecryptedTotal += thisPtext.Length;
+ ptext->Length = bytesDecryptedTotal;
+abort:
+ return ocrtn;
+}
+
+static int doTest(
+ CSSM_CSP_HANDLE cspHand,
+ const CSSM_DATA *ptext,
+ const CSSM_DATA *ctext1,
+ const CSSM_DATA *ctext2,
+ const CSSM_DATA *rptext,
+ const CSSM_DATA *keyData,
+ const CSSM_DATA *iv,
+ uint32 keyAlg, // CSSM_ALGID_xxx of the key
+ uint32 encrAlg, // encrypt/decrypt
+ uint32 encrMode,
+ uint32 padding,
+ uint32 keySizeInBits,
+ uint32 cipherBlockSizeBytes,
+ CSSM_BOOL quiet)
+{
+ CSSM_DATA lctext1;
+ CSSM_DATA lctext2;
+ CSSM_DATA lrptext;
+ int rtn = 0;
+ CSSM_RETURN crtn;
+ CSSM_CC_HANDLE ccHand1 = 0;
+ CSSM_CC_HANDLE ccHand2 = 0;
+ CSSM_KEY key1;
+ CSSM_KEY key2;
+ uint8 dummy[cipherBlockSizeBytes];
+ CSSM_DATA dummyData = {cipherBlockSizeBytes, dummy};
+
+ /*
+ * generate two equivalent keys key1 and key2;
+ * generate two CC handles ccHand1, ccHand2;
+ * encrypt dummy data with ccHand1 to get it cooked;
+ * encrypt ptext with ccHand1 ==> ctext1;
+ * encrypt ptext with ccHand2 ==> ctext2;
+ * Compare ctext1 and ctext2;
+ * decrypt ctext1 with ccHand1, compare with ptext;
+ */
+ crtn = cspGenSymKeyWithBits(cspHand, keyAlg, CSSM_KEYUSE_ANY,
+ keyData, keySizeInBits / 8, &key1);
+ if(crtn) {
+ return crtn;
+ }
+ crtn = cspGenSymKeyWithBits(cspHand, keyAlg, CSSM_KEYUSE_ANY,
+ keyData, keySizeInBits / 8, &key2);
+ if(crtn) {
+ return crtn;
+ }
+ ccHand1 = genCryptHandle(cspHand,
+ encrAlg,
+ encrMode,
+ padding,
+ &key1,
+ NULL, // pubKey
+ iv,
+ 0, // effectiveKeySizeInBits
+ 0); // rounds
+ if(ccHand1 == 0) {
+ return CSSMERR_CSP_INTERNAL_ERROR;
+ }
+ ccHand2 = genCryptHandle(cspHand,
+ encrAlg,
+ encrMode,
+ padding,
+ &key2,
+ NULL, // pubKey
+ iv,
+ 0, // effectiveKeySizeInBits
+ 0); // rounds
+ if(ccHand2 == 0) {
+ return CSSMERR_CSP_INTERNAL_ERROR;
+ }
+
+ /* dummy encrypt to heat up ccHand1 */
+ appGetRandomBytes(dummy, sizeof(dummy));
+ lctext1 = *ctext1;
+ crtn = stagedEncrypt(cspHand, ccHand1, encrAlg, cipherBlockSizeBytes,
+ iv, &dummyData, &lctext1, CSSM_FALSE);
+ if(crtn) {
+ return crtn;
+ }
+
+ /* encrypt ptext with ccHand1 and ccHand2, compare ctext */
+ lctext1 = *ctext1;
+ crtn = stagedEncrypt(cspHand, ccHand1, encrAlg, cipherBlockSizeBytes,
+ iv, ptext, &lctext1, CSSM_TRUE);
+ if(crtn) {
+ return crtn;
+ }
+ lctext2 = *ctext2;
+ crtn = stagedEncrypt(cspHand, ccHand2, encrAlg, cipherBlockSizeBytes,
+ iv, ptext, &lctext2, CSSM_TRUE);
+ if(crtn) {
+ return crtn;
+ }
+ if(!appCompareCssmData(&lctext1, &lctext2)) {
+ printf("***Ciphertext miscompare\n");
+ if(testError(quiet)) {
+ return 1;
+ }
+ }
+
+ /* decrypt with ccHand1, compare with ptext */
+ lrptext = *rptext;
+ crtn = stagedDecrypt(cspHand, ccHand1, encrAlg, cipherBlockSizeBytes,
+ iv, &lctext1, &lrptext, CSSM_TRUE);
+ if(crtn) {
+ return crtn;
+ }
+ if(!appCompareCssmData(&lctext1, &lctext2)) {
+ printf("***Plaintext miscompare\n");
+ if(testError(quiet)) {
+ return 1;
+ }
+ }
+
+ if(ccHand1) {
+ CSSM_DeleteContext(ccHand1);
+ }
+ if(ccHand2) {
+ CSSM_DeleteContext(ccHand2);
+ }
+ return rtn;
+}
+
+
+int main(int argc, char **argv)
+{
+ int arg;
+ char *argp;
+ unsigned loop;
+ CSSM_DATA ptext;
+ CSSM_DATA ctext1;
+ CSSM_DATA ctext2;
+ CSSM_DATA rptext;
+ CSSM_CSP_HANDLE cspHand;
+ const char *algStr;
+ uint32 keyAlg; // CSSM_ALGID_xxx of the key
+ uint32 encrAlg; // CSSM_ALGID_xxx of encr/decr
+ unsigned currAlg; // ALG_xxx
+ uint32 keySizeInBits;
+ int rtn = 0;
+ CSSM_DATA keyData;
+ CSSM_DATA initVector;
+ uint32 minTextSize;
+ uint32 rawMode;
+ uint32 cookedMode;
+ const char *rawModeStr;
+ const char *cookedModeStr;
+ uint32 algBlockSizeBytes;
+
+ /*
+ * User-spec'd params
+ */
+ CSSM_BOOL keySizeSpec = CSSM_FALSE; // false: use rand key size
+ unsigned minAlg = ALG_FIRST;
+ unsigned maxAlg = ALG_LAST;
+ unsigned loops = LOOPS_DEF;
+ CSSM_BOOL verbose = CSSM_FALSE;
+ CSSM_BOOL quiet = CSSM_FALSE;
+ unsigned pauseInterval = 0;
+ uint32 padding;
+ CSSM_BOOL bareCsp = CSSM_TRUE;
+ unsigned maxPtextSize = MAX_DATA_SIZE;
+ unsigned minPtextSize = MIN_DATA_SIZE;
+
+ for(arg=1; arg<argc; arg++) {
+ argp = argv[arg];
+ switch(argp[0]) {
+ case 'a':
+ if(argp[1] != '=') {
+ usage(argv);
+ }
+ switch(argp[2]) {
+ case 'd':
+ minAlg = maxAlg = ALG_DES;
+ break;
+ case '3':
+ minAlg = maxAlg = ALG_3DES;
+ break;
+ case '2':
+ minAlg = maxAlg = ALG_RC2;
+ break;
+ case '4':
+ minAlg = maxAlg = ALG_RC4;
+ break;
+ case '5':
+ minAlg = maxAlg = ALG_RC5;
+ break;
+ case 'a':
+ minAlg = maxAlg = ALG_AES;
+ break;
+ case 'A':
+ minAlg = maxAlg = ALG_AES192;
+ break;
+ case '6':
+ minAlg = maxAlg = ALG_AES256;
+ break;
+ case 'b':
+ minAlg = maxAlg = ALG_BFISH;
+ break;
+ case 'c':
+ minAlg = maxAlg = ALG_CAST;
+ break;
+ case 's':
+ minAlg = maxAlg = ALG_ASC;
+ break;
+ default:
+ usage(argv);
+ }
+ break;
+ case 'l':
+ loops = atoi(&argp[2]);
+ break;
+ case 'k':
+ keySizeInBits = atoi(&argp[2]);
+ keySizeSpec = CSSM_TRUE;
+ break;
+ case 'v':
+ verbose = CSSM_TRUE;
+ break;
+ case 'D':
+ bareCsp = CSSM_FALSE;
+ break;
+ case 'm':
+ maxPtextSize = atoi(&argp[2]);
+ break;
+ case 'n':
+ minPtextSize = atoi(&argp[2]);
+ break;
+ case 'q':
+ quiet = CSSM_TRUE;
+ break;
+ case 'p':
+ pauseInterval = atoi(&argp[2]);;
+ break;
+ case 'h':
+ default:
+ usage(argv);
+ }
+ }
+ ptext.Data = (uint8 *)CSSM_MALLOC(maxPtextSize);
+ if(ptext.Data == NULL) {
+ printf("Insufficient heap space\n");
+ exit(1);
+ }
+ /* ptext length set in test loop */
+ appSetupCssmData(&ctext1, 2 * maxPtextSize);
+ appSetupCssmData(&ctext2, 2 * maxPtextSize);
+ appSetupCssmData(&rptext, 2 * maxPtextSize);
+
+ keyData.Data = (uint8 *)CSSM_MALLOC(MAX_KEY_SIZE);
+ if(keyData.Data == NULL) {
+ printf("Insufficient heap space\n");
+ exit(1);
+ }
+ keyData.Length = MAX_KEY_SIZE;
+
+ initVector.Data = (uint8 *)"someStrangeInitVect";
+
+ testStartBanner("contextReuse", argc, argv);
+
+ cspHand = cspDlDbStartup(bareCsp, NULL);
+ if(cspHand == 0) {
+ exit(1);
+ }
+ if(pauseInterval) {
+ fpurge(stdin);
+ printf("Top of test; hit CR to proceed: ");
+ getchar();
+ }
+ for(currAlg=minAlg; currAlg<=maxAlg; currAlg++) {
+ /* some default values... */
+ padding = CSSM_PADDING_PKCS5;
+ rawMode = RAW_MODE;
+ cookedMode = COOKED_MODE;
+ rawModeStr = RAW_MODE_STR;
+ cookedModeStr = COOKED_MODE_STR;
+ padding = CSSM_PADDING_PKCS5;
+
+ switch(currAlg) {
+ case ALG_DES:
+ encrAlg = keyAlg = CSSM_ALGID_DES;
+ algStr = "DES";
+ algBlockSizeBytes = 8;
+ break;
+ case ALG_3DES:
+ /* currently the only one with different key and encr algs */
+ keyAlg = CSSM_ALGID_3DES_3KEY;
+ encrAlg = CSSM_ALGID_3DES_3KEY_EDE;
+ algStr = "3DES";
+ algBlockSizeBytes = 8;
+ break;
+ case ALG_RC2:
+ encrAlg = keyAlg = CSSM_ALGID_RC2;
+ algStr = "RC2";
+ algBlockSizeBytes = 8;
+ break;
+ case ALG_RC4:
+ encrAlg = keyAlg = CSSM_ALGID_RC4;
+ algStr = "RC4";
+ algBlockSizeBytes = 0;
+ rawMode = RAW_MODE_STREAM;
+ cookedMode = RAW_MODE_STREAM;
+ rawModeStr = RAW_MODE_STREAM_STR;
+ cookedModeStr = RAW_MODE_STREAM_STR;
+ break;
+ case ALG_RC5:
+ encrAlg = keyAlg = CSSM_ALGID_RC5;
+ algStr = "RC5";
+ algBlockSizeBytes = 8;
+ break;
+ case ALG_AES:
+ encrAlg = keyAlg = CSSM_ALGID_AES;
+ algStr = "AES";
+ algBlockSizeBytes = 16;
+ break;
+ case ALG_AES192:
+ encrAlg = keyAlg = CSSM_ALGID_AES;
+ algStr = "AES192";
+ algBlockSizeBytes = 24;
+ break;
+ case ALG_AES256:
+ encrAlg = keyAlg = CSSM_ALGID_AES;
+ algStr = "AES256";
+ algBlockSizeBytes = 32;
+ break;
+ case ALG_BFISH:
+ encrAlg = keyAlg = CSSM_ALGID_BLOWFISH;
+ algStr = "Blowfish";
+ algBlockSizeBytes = 8;
+ break;
+ case ALG_CAST:
+ encrAlg = keyAlg = CSSM_ALGID_CAST;
+ algStr = "CAST";
+ algBlockSizeBytes = 8;
+ break;
+ }
+
+ /* assume for now all algs require IV */
+ initVector.Length = algBlockSizeBytes ? algBlockSizeBytes : 8;
+
+ if(!quiet || verbose) {
+ printf("Testing alg %s\n", algStr);
+ }
+ for(loop=1; ; loop++) {
+ /* mix up raw/cooked */
+ uint32 mode;
+ const char *modeStr;
+ CSSM_BOOL paddingEnabled;
+
+ if(loop & 1) {
+ mode = rawMode;
+ modeStr = rawModeStr;
+ }
+ else {
+ mode = cookedMode;
+ modeStr = cookedModeStr;
+ }
+ switch(mode) {
+ case CSSM_ALGMODE_CBCPadIV8:
+ paddingEnabled = CSSM_TRUE;
+ break;
+ default:
+ /* all others - right? */
+ paddingEnabled = CSSM_FALSE;
+ break;
+ }
+ minTextSize = minPtextSize; // default
+ if(!paddingEnabled && algBlockSizeBytes && (minTextSize < algBlockSizeBytes)) {
+ /* i.e., no padding, adjust min ptext size */
+ minTextSize = algBlockSizeBytes;
+ }
+ simpleGenData(&ptext, minTextSize, maxPtextSize);
+ if(!paddingEnabled && algBlockSizeBytes) {
+ /* align ptext */
+ ptext.Length = (ptext.Length / algBlockSizeBytes) * algBlockSizeBytes;
+ }
+
+ simpleGenData(&keyData, MAX_KEY_SIZE, MAX_KEY_SIZE);
+
+ if(!keySizeSpec) {
+ /* random but byte-aligned */
+ keySizeInBits = randKeySizeBits(keyAlg, OT_Encrypt);
+ keySizeInBits = (keySizeInBits + 7) & ~7;
+ }
+ /* else constant, spec'd by user, may be 0 (default per alg) */
+ if(!quiet) {
+ if(verbose || ((loop % LOOP_NOTIFY) == 0)) {
+ if(algBlockSizeBytes) {
+ printf("..loop %d text size %lu keySizeBits %u"
+ " blockSize %u mode %s\n",
+ loop, (unsigned long)ptext.Length, (unsigned)keySizeInBits,
+ (unsigned)algBlockSizeBytes, modeStr);
+ }
+ else {
+ printf("..loop %d text size %lu keySizeBits %u"
+ " mode %s\n",
+ loop, (unsigned long)ptext.Length, (unsigned)keySizeInBits,
+ modeStr);
+ }
+ }
+ }
+
+ if(doTest(cspHand,
+ &ptext,
+ &ctext1,
+ &ctext2,
+ &rptext,
+ &keyData,
+ &initVector,
+ keyAlg,
+ encrAlg,
+ mode,
+ padding,
+ keySizeInBits,
+ algBlockSizeBytes,
+ quiet)) {
+ rtn = 1;
+ break;
+ }
+ if(pauseInterval && ((loop % pauseInterval) == 0)) {
+ char c;
+ fpurge(stdin);
+ printf("Hit CR to proceed, q to abort: ");
+ c = getchar();
+ if(c == 'q') {
+ goto testDone;
+ }
+ }
+ if(loops && (loop == loops)) {
+ break;
+ }
+ } /* main loop */
+ if(rtn) {
+ break;
+ }
+
+ } /* for algs */
+
+testDone:
+ cspShutdown(cspHand, bareCsp);
+ if(pauseInterval) {
+ fpurge(stdin);
+ printf("ModuleDetach/Unload complete; hit CR to exit: ");
+ getchar();
+ }
+ if((rtn == 0) && !quiet) {
+ printf("%s test complete\n", argv[0]);
+ }
+ CSSM_FREE(ptext.Data);
+ CSSM_FREE(keyData.Data);
+ return rtn;
+}
+
+
projects / apple / security.git / blobdiff