--- /dev/null
+/* Copyright (c) 1998,2003-2006,2008 Apple Inc.
+ *
+ * hashTest.c - test CDSA digest functions.
+ *
+ * Revision History
+ * ----------------
+ * 4 May 2000 Doug Mitchell
+ * Ported to X/CDSA2.
+ * 12 May 1998 Doug Mitchell at Apple
+ * Created.
+ */
+/*
+ * text size = {random, from 100 bytes to 100k, in
+ * geometrical steps, i.e. the number of
+ * bytes would be 10^r, where r is random out of
+ * {2,3,4,5,6}, plus a random integer in {0,..99}};
+ *
+ * for loop_count
+ * text contents = {random data, random size as specified above};
+ * generate digest in one shot;
+ * generate digest with multiple random-sized updates;
+ * verify digests compare;
+ * for various bytes of text {
+ * corrupt text byte;
+ * generate digest in one shot;
+ * veridy digest is different;
+ * restore corrupted byte;
+ * }
+ * }
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <string.h>
+#include <Security/cssm.h>
+#include "cspwrap.h"
+#include <Security/cssm.h>
+#include <Security/cssmapple.h>
+#include "cspwrap.h"
+#include "common.h"
+
+/*
+ * Defaults.
+ */
+#define LOOPS_DEF 50
+#define MIN_EXP 2 /* for data size 10**exp */
+#define DEFAULT_MAX_EXP 3
+#define MAX_EXP 5
+#define INCR_DEFAULT 0 /* munge every incr bytes - zero means
+ * "adjust per ptext size" */
+typedef enum {
+ ALG_MD2 = 1,
+ ALG_MD5,
+ ALG_SHA1,
+ ALG_SHA224,
+ ALG_SHA256,
+ ALG_SHA384,
+ ALG_SHA512
+};
+
+#define ALG_FIRST ALG_MD2
+#define ALG_LAST ALG_SHA512
+#define MAX_DATA_SIZE (100000 + 100) /* bytes */
+#define LOOP_NOTIFY 20
+
+static void usage(char **argv)
+{
+ printf("usage: %s [options]\n", argv[0]);
+ printf(" Options:\n");
+ printf(" a=algorithm (s=SHA1; m=MD5; M=MD2; 4=SHA224; 2=SHA256; 3=SHA384; 5=SHA512; "
+ "default=all\n");
+ printf(" l=loops (default=%d; 0=forever)\n", LOOPS_DEF);
+ printf(" n=minExp (default=%d)\n", MIN_EXP);
+ printf(" x=maxExp (default=%d, max=%d)\n", DEFAULT_MAX_EXP, MAX_EXP);
+ printf(" i=increment (default=%d)\n", INCR_DEFAULT);
+ printf(" p=pauseInterval (default=0, no pause)\n");
+ printf(" z (zero data)\n");
+ printf(" I (incrementing data)\n");
+ printf(" g (good digest only)\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_FREQ 20
+
+static int doTest(CSSM_CSP_HANDLE cspHand,
+ uint32 alg,
+ CSSM_DATA_PTR ptext,
+ CSSM_BOOL verbose,
+ CSSM_BOOL quiet,
+ CSSM_BOOL mallocDigest,
+ unsigned incr,
+ CSSM_BOOL goodOnly)
+{
+ CSSM_DATA refDigest = {0, NULL};
+ CSSM_DATA testDigest = {0, NULL};
+ unsigned length;
+ unsigned byte;
+ unsigned char *data;
+ unsigned char origData;
+ unsigned char bits;
+ int rtn = 0;
+ CSSM_RETURN crtn;
+ unsigned loop = 0;
+
+ /*
+ * generate digest in one shot;
+ * generate digest with multiple random-sized updates;
+ * verify digests compare;
+ * for various bytes of ptext {
+ * corrupt ptext byte;
+ * generate digest in one shot;
+ * verify digest is different;
+ * restore corrupted byte;
+ * }
+ */
+ crtn = cspDigest(cspHand,
+ alg,
+ mallocDigest,
+ ptext,
+ &refDigest);
+ if(crtn) {
+ rtn = testError(quiet);
+ goto abort;
+ }
+ crtn = cspStagedDigest(cspHand,
+ alg,
+ mallocDigest,
+ CSSM_TRUE, // multi updates
+ ptext,
+ &testDigest);
+ if(crtn) {
+ rtn = testError(quiet);
+ goto abort;
+ }
+ if(refDigest.Length != testDigest.Length) {
+ printf("Digest length mismatch (1)\n");
+ rtn = testError(quiet);
+ goto abort;
+ }
+ if(memcmp(refDigest.Data, testDigest.Data, refDigest.Length)) {
+ printf("Digest miscompare (1)\n");
+ rtn = testError(quiet);
+ if(rtn) {
+ goto abort;
+ }
+ }
+ if(goodOnly) {
+ rtn = 0;
+ goto abort;
+ }
+ appFreeCssmData(&testDigest, CSSM_FALSE);
+ testDigest.Length = 0;
+ data = (unsigned char *)ptext->Data;
+ length = ptext->Length;
+ for(byte=0; byte<length; byte += incr) {
+ if(verbose && ((loop++ % LOG_FREQ) == 0)) {
+ printf("....byte %d\n", byte);
+ }
+ origData = data[byte];
+ /*
+ * Generate random non-zero byte
+ */
+ do {
+ bits = genRand(1, 0xff) & 0xff;
+ } while(bits == 0);
+ data[byte] ^= bits;
+ crtn = cspDigest(cspHand,
+ alg,
+ mallocDigest,
+ ptext,
+ &testDigest);
+ if(crtn) {
+ rtn = testError(quiet);
+ break;
+ }
+ if(!memcmp(refDigest.Data, testDigest.Data, refDigest.Length)) {
+ printf("Unexpected digest compare\n");
+ rtn = testError(quiet);
+ break;
+ }
+ appFreeCssmData(&testDigest, CSSM_FALSE);
+ testDigest.Length = 0;
+ data[byte] = origData;
+ }
+abort:
+ /* free digests */
+ if(refDigest.Length) {
+ appFreeCssmData(&refDigest, CSSM_FALSE);
+ }
+ if(testDigest.Length) {
+ appFreeCssmData(&testDigest, CSSM_FALSE);
+ }
+ return rtn;
+}
+
+int main(int argc, char **argv)
+{
+ int arg;
+ char *argp;
+ unsigned loop;
+ CSSM_DATA ptext;
+ CSSM_CSP_HANDLE cspHand;
+ CSSM_BOOL mallocDigest;
+ const char *algStr;
+ uint32 alg; // ALG_MD5, etc.
+ uint32 cssmAlg; // CSSM_ALGID_MD5, etc.
+ unsigned actualIncr;
+ int i;
+
+ /*
+ * User-spec'd params
+ */
+ unsigned loops = LOOPS_DEF;
+ CSSM_BOOL verbose = CSSM_FALSE;
+ unsigned minExp = MIN_EXP;
+ unsigned maxExp = DEFAULT_MAX_EXP;
+ CSSM_BOOL quiet = CSSM_FALSE;
+ unsigned incr = INCR_DEFAULT;
+ unsigned minAlg = ALG_FIRST;
+ unsigned maxAlg = ALG_LAST;
+ unsigned pauseInterval = 0;
+ dataType dt;
+ CSSM_BOOL goodOnly = CSSM_FALSE;
+ CSSM_BOOL bareCsp = CSSM_TRUE;
+
+ for(arg=1; arg<argc; arg++) {
+ argp = argv[arg];
+ switch(argp[0]) {
+ case 'a':
+ if(argp[1] != '=') {
+ usage(argv);
+ }
+ switch(argp[2]) {
+ case 's':
+ minAlg = maxAlg = ALG_SHA1;
+ break;
+ case 'm':
+ minAlg = maxAlg = ALG_MD5;
+ break;
+ case 'M':
+ minAlg = maxAlg = ALG_MD2;
+ break;
+ case '4':
+ minAlg = maxAlg = ALG_SHA224;
+ break;
+ case '2':
+ minAlg = maxAlg = ALG_SHA256;
+ break;
+ case '3':
+ minAlg = maxAlg = ALG_SHA384;
+ break;
+ case '5':
+ minAlg = maxAlg = ALG_SHA512;
+ break;
+ default:
+ usage(argv);
+ }
+ break;
+ case 'l':
+ loops = atoi(&argp[2]);
+ break;
+ case 'n':
+ minExp = atoi(&argp[2]);
+ break;
+ case 'x':
+ maxExp = atoi(&argp[2]);
+ if(maxExp > MAX_EXP) {
+ usage(argv);
+ }
+ break;
+ case 'i':
+ incr = atoi(&argp[2]);
+ break;
+ case 'p':
+ pauseInterval = atoi(&argp[2]);;
+ break;
+ case 'v':
+ verbose = CSSM_TRUE;
+ break;
+ case 'q':
+ quiet = CSSM_TRUE;
+ break;
+ case 'D':
+ bareCsp = CSSM_FALSE;
+ break;
+ case 'z':
+ dt = DT_Zero;
+ break;
+ case 'I':
+ dt = DT_Increment;
+ break;
+ case 'g':
+ goodOnly = CSSM_TRUE;
+ break;
+ case 'h':
+ default:
+ usage(argv);
+ }
+ }
+ ptext.Data = (uint8 *)CSSM_MALLOC(MAX_DATA_SIZE);
+ /* length set in test loop */
+ if(ptext.Data == NULL) {
+ printf("Insufficient heap\n");
+ exit(1);
+ }
+
+ printf("Starting hashTest; args: ");
+ for(i=1; i<argc; i++) {
+ printf("%s ", argv[i]);
+ }
+ printf("\n");
+ cspHand = cspDlDbStartup(bareCsp, NULL);
+ if(cspHand == 0) {
+ exit(1);
+ }
+
+ for(alg=minAlg; alg<=maxAlg; alg++) {
+ switch(alg) {
+ case ALG_MD5:
+ algStr = "MD5";
+ cssmAlg = CSSM_ALGID_MD5;
+ break;
+ case ALG_MD2:
+ algStr = "MD2";
+ cssmAlg = CSSM_ALGID_MD2;
+ break;
+ case ALG_SHA1:
+ algStr = "SHA1";
+ cssmAlg = CSSM_ALGID_SHA1;
+ break;
+ case ALG_SHA224:
+ algStr = "SHA224";
+ cssmAlg = CSSM_ALGID_SHA224;
+ break;
+ case ALG_SHA256:
+ algStr = "SHA256";
+ cssmAlg = CSSM_ALGID_SHA256;
+ break;
+ case ALG_SHA384:
+ algStr = "SHA384";
+ cssmAlg = CSSM_ALGID_SHA384;
+ break;
+ case ALG_SHA512:
+ algStr = "SHA512";
+ cssmAlg = CSSM_ALGID_SHA512;
+ break;
+ }
+ if(!quiet) {
+ printf("Testing alg %s\n", algStr);
+ }
+ for(loop=1; ; loop++) {
+ ptext.Length = genData(ptext.Data, minExp, maxExp, dt);
+ if(incr == 0) {
+ /* adjust increment as appropriate */
+ actualIncr = (ptext.Length / 50) + 1;
+ }
+ else {
+ actualIncr = incr;
+ }
+ /* mix up mallocing */
+ mallocDigest = (loop & 1) ? CSSM_TRUE : CSSM_FALSE;
+ if(!quiet) {
+ if(verbose || ((loop % LOOP_NOTIFY) == 0)) {
+ printf("..loop %d text size %lu mallocDigest %d\n",
+ loop, (unsigned long)ptext.Length, (int)mallocDigest);
+ }
+ }
+ if(doTest(cspHand,
+ cssmAlg,
+ &ptext,
+ verbose,
+ quiet,
+ mallocDigest,
+ actualIncr,
+ goodOnly)) {
+ exit(1);
+ }
+ if(loops && (loop == loops)) {
+ break;
+ }
+ if(pauseInterval && ((loop % pauseInterval) == 0)) {
+ fpurge(stdin);
+ printf("Hit CR to proceed: ");
+ getchar();
+ }
+ }
+ }
+ if(!quiet) {
+ printf("%s test complete\n", argv[0]);
+ }
+ return 0;
+}
projects / apple / security.git / blobdiff