--- /dev/null
+/*
+ * ccOneShot.c - Ensure that one-shot CommonDigest routines behave correctly.
+ *
+ * Written 3/31/06 by Doug Mitchell.
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include "common.h"
+#include <string.h>
+#include <CommonCrypto/CommonDigest.h>
+#include <openssl/hmac.h>
+
+/*
+ * Defaults.
+ */
+#define LOOPS_DEF 200
+#define MIN_DATA_SIZE 1
+#define MAX_DATA_SIZE 10000 /* bytes */
+#define LOOP_NOTIFY 20
+
+/*
+ * Enumerate algs our own way to allow iteration.
+ */
+typedef enum {
+ ALG_MD2 = 1,
+ ALG_MD4,
+ ALG_MD5,
+ ALG_SHA1,
+ ALG_SHA224,
+ ALG_SHA256,
+ ALG_SHA384,
+ ALG_SHA512
+} HashAlg;
+#define ALG_FIRST ALG_MD2
+#define ALG_LAST ALG_SHA512
+
+static void usage(char **argv)
+{
+ printf("usage: %s [options]\n", argv[0]);
+ printf(" Options:\n");
+ printf(" l=loops (default %d)\n", LOOPS_DEF);
+ printf(" q(uiet)\n");
+ printf(" h(elp)\n");
+ exit(1);
+}
+
+/* the context pointers are void * here for polymorphism later on */
+typedef int (*initFcn)(void *ctx);
+typedef int (*updateFcn)(void *ctx, const void *data, CC_LONG len);
+typedef int (*finalFcn)(unsigned char *md, void *ctx);
+typedef unsigned char (*oneShotFcn)(const void *data, CC_LONG len, unsigned char *md);
+
+typedef struct {
+ HashAlg alg;
+ const char *algName;
+ size_t digestSize;
+ initFcn init;
+ updateFcn update;
+ finalFcn final;
+ oneShotFcn oneShot;
+} CommonDigestInfo;
+
+/* casts are necessary to cover the void* context args */
+static const CommonDigestInfo digests[] =
+{
+ { ALG_MD2, "MD2", CC_MD2_DIGEST_LENGTH,
+ (initFcn)CC_MD2_Init, (updateFcn)CC_MD2_Update,
+ (finalFcn)CC_MD2_Final, (oneShotFcn)CC_MD2
+ },
+ { ALG_MD4, "MD4", CC_MD4_DIGEST_LENGTH,
+ (initFcn)CC_MD4_Init, (updateFcn)CC_MD4_Update,
+ (finalFcn)CC_MD4_Final, (oneShotFcn)CC_MD4
+ },
+ { ALG_MD5, "MD5", CC_MD5_DIGEST_LENGTH,
+ (initFcn)CC_MD5_Init, (updateFcn)CC_MD5_Update,
+ (finalFcn)CC_MD5_Final, (oneShotFcn)CC_MD5
+ },
+ { ALG_SHA1, "SHA1", CC_SHA1_DIGEST_LENGTH,
+ (initFcn)CC_SHA1_Init, (updateFcn)CC_SHA1_Update,
+ (finalFcn)CC_SHA1_Final, (oneShotFcn)CC_SHA1
+ },
+ { ALG_SHA224, "SHA224", CC_SHA224_DIGEST_LENGTH,
+ (initFcn)CC_SHA224_Init, (updateFcn)CC_SHA224_Update,
+ (finalFcn)CC_SHA224_Final, (oneShotFcn)CC_SHA224
+ },
+ { ALG_SHA256, "SHA256", CC_SHA256_DIGEST_LENGTH,
+ (initFcn)CC_SHA256_Init, (updateFcn)CC_SHA256_Update,
+ (finalFcn)CC_SHA256_Final, (oneShotFcn)CC_SHA256
+ },
+ { ALG_SHA384, "SHA384", CC_SHA384_DIGEST_LENGTH,
+ (initFcn)CC_SHA384_Init, (updateFcn)CC_SHA384_Update,
+ (finalFcn)CC_SHA384_Final, (oneShotFcn)CC_SHA384
+ },
+ { ALG_SHA512, "SHA512", CC_SHA512_DIGEST_LENGTH,
+ (initFcn)CC_SHA512_Init, (updateFcn)CC_SHA512_Update,
+ (finalFcn)CC_SHA512_Final, (oneShotFcn)CC_SHA512
+ },
+};
+#define NUM_DIGESTS (sizeof(digests) / sizeof(digests[0]))
+
+static const CommonDigestInfo *findDigestInfo(unsigned alg)
+{
+ unsigned dex;
+ for(dex=0; dex<NUM_DIGESTS; dex++) {
+ if((unsigned)(digests[dex].alg) == alg) {
+ return &digests[dex];
+ }
+ }
+ return NULL;
+}
+
+
+/*
+ * These consts let us allocate context and digest buffers for
+ * any arbitrary algorithm.
+ */
+#define MAX_DIGEST_SIZE 64
+#define MAX_CONTEXT_SIZE sizeof(CC_SHA512_CTX)
+
+/* staged digest with random updates */
+static void doStaged(
+ const CommonDigestInfo *digestInfo,
+ const unsigned char *ptext,
+ unsigned ptextLen,
+ unsigned char *md)
+{
+ char ctx[MAX_CONTEXT_SIZE];
+ unsigned thisMove;
+
+ digestInfo->init(ctx);
+ while(ptextLen) {
+ thisMove = genRand(1, ptextLen);
+ digestInfo->update(ctx, ptext, thisMove);
+ ptext += thisMove;
+ ptextLen -= thisMove;
+ }
+ digestInfo->final(md, ctx);
+}
+
+static int doTest(
+ const CommonDigestInfo *digestInfo,
+ const unsigned char *ptext,
+ unsigned ptextLen,
+ bool quiet)
+{
+ unsigned char mdStaged[MAX_DIGEST_SIZE];
+ unsigned char mdOneShot[MAX_DIGEST_SIZE];
+
+ digestInfo->oneShot(ptext, ptextLen, mdOneShot);
+ doStaged(digestInfo, ptext, ptextLen, mdStaged);
+ if(memcmp(mdStaged, mdOneShot, digestInfo->digestSize)) {
+ printf("***Digest miscompare for %s\n", digestInfo->algName);
+ if(testError(quiet)) {
+ return 1;
+ }
+ }
+ return 0;
+}
+
+int main(int argc, char **argv)
+{
+ int arg;
+ char *argp;
+ unsigned loop;
+ uint8 *ptext;
+ size_t ptextLen;
+ unsigned currAlg;
+ const CommonDigestInfo *digestInfo;
+ int rtn = 0;
+ int i;
+
+ /*
+ * User-spec'd params
+ */
+ unsigned loops = LOOPS_DEF;
+ bool quiet = false;
+
+ for(arg=1; arg<argc; arg++) {
+ argp = argv[arg];
+ switch(argp[0]) {
+ case 'l':
+ loops = atoi(&argp[2]);
+ break;
+ case 'q':
+ quiet = true;
+ break;
+ case 'h':
+ default:
+ usage(argv);
+ }
+ }
+ ptext = (uint8 *)malloc(MAX_DATA_SIZE);
+ if(ptext == NULL) {
+ printf("Insufficient heap space\n");
+ exit(1);
+ }
+ /* ptext length set in test loop */
+
+ printf("Starting ccOneShot; args: ");
+ for(i=1; i<argc; i++) {
+ printf("%s ", argv[i]);
+ }
+ printf("\n");
+
+ for(currAlg=ALG_FIRST; currAlg<=ALG_LAST; currAlg++) {
+ digestInfo = findDigestInfo(currAlg);
+ if(!quiet) {
+ printf("Testing alg %s\n", digestInfo->algName);
+ }
+ for(loop=1; ; loop++) {
+ ptextLen = genRand(MIN_DATA_SIZE, MAX_DATA_SIZE);
+ appGetRandomBytes(ptext, ptextLen);
+ if(!quiet) {
+ if((loop % LOOP_NOTIFY) == 0) {
+ printf("..loop %d ptextLen %lu\n",
+ loop, (unsigned long)ptextLen);
+ }
+ }
+
+ if(doTest(digestInfo, ptext, ptextLen, quiet)) {
+ rtn = 1;
+ break;
+ }
+ if(loops && (loop == loops)) {
+ break;
+ }
+ } /* main loop */
+ if(rtn) {
+ break;
+ }
+
+ } /* for algs */
+
+ if((rtn == 0) && !quiet) {
+ printf("%s test complete\n", argv[0]);
+ }
+ free(ptext);
+ return rtn;
+}
+
+
projects / apple / security.git / blobdiff