SecurityTests/cspxutils/randTest/randTest.c

   1 /*
   2  * Simple interactive CSP RNG exerciser.
   3  */
   4 #include <stdlib.h>
   5 #include <stdio.h>
   6 #include <time.h>
   7 #include <Security/cssm.h>
   8 #include <Security/cssmapple.h>
   9 #include "cspwrap.h"
  10 #include "common.h"
  11
  12 #define RAND_ALG                CSSM_ALGID_APPLE_YARROW
  13 #define BUFSIZE                 32
  14
  15 static void usage(char **argv)
  16 {
  17         printf("usage: %s [options]\n", argv[0]);
  18         printf("Options:\n");
  19         printf("  D (CSP/DL; default = bare CSP)\n");
  20         exit(1);
  21 }
  22
  23 static void dumpBuf(uint8 *buf,
  24         unsigned len)
  25 {
  26         unsigned i;
  27
  28         printf("   ");
  29         for(i=0; i<len; i++) {
  30                 printf("%02X  ", buf[i]);
  31                 if((i % 8) == 7) {
  32                         printf("\n   ");
  33                 }
  34         }
  35         printf("\n");
  36 }
  37
  38 void doGenRand(
  39         CSSM_CSP_HANDLE                 cspHand,
  40         CSSM_CC_HANDLE                  ccHand,         // 0 ==> gen a new one
  41                                                                                 // else use this
  42         CSSM_CRYPTO_DATA_PTR    seed,           // optional
  43         unsigned                                len,
  44         CSSM_BOOL                               weMalloc)
  45 {
  46         CSSM_RETURN                             crtn;
  47         CSSM_DATA                               data = {0, NULL};
  48
  49         /* optional existing context */
  50         if(ccHand == 0) {
  51                 crtn = CSSM_CSP_CreateRandomGenContext(
  52                         cspHand,
  53                         RAND_ALG,
  54                         seed,
  55                         len,
  56                         &ccHand);
  57                 if(crtn) {
  58                         printError("CSSM_CSP_CreateRandomGenContext", crtn);
  59                         return;
  60                 }
  61         }
  62
  63         /* who mallocs the data? */
  64         if(weMalloc) {
  65                 data.Data = (uint8 *)appMalloc(len, NULL);
  66                 if(data.Data == NULL) {
  67                         printf("***malloc failure\n");
  68                         return;
  69                 }
  70                 data.Length = len;
  71         }
  72
  73         /* go for it */
  74         crtn = CSSM_GenerateRandom(ccHand, &data);
  75         if(crtn) {
  76                 printError("CSSM_GenerateRandom", crtn);
  77                 return;
  78         }
  79
  80         dumpBuf(data.Data, data.Length);
  81         appFree(data.Data, NULL);
  82         return;
  83 }
  84
  85 #define SEED_SIZE       32
  86
  87 /*
  88  * CryptoData callback for optional random seed.
  89  */
  90 CSSM_RETURN seedCallback(
  91         CSSM_DATA_PTR OutData,
  92         void *CallerCtx)
  93 {
  94         int i, j;
  95         static unsigned char    seed[SEED_SIZE];
  96
  97         OutData->Length = SEED_SIZE;
  98         OutData->Data = seed;
  99         for(i=SEED_SIZE, j=0; i>0; i--, j++) {
 100                 seed[j] = i;
 101         }
 102         return CSSM_OK;
 103 }
 104
 105 int main(int argc, char **argv)
 106 {
 107         int                                             arg;
 108         char                                    *argp;
 109         CSSM_CSP_HANDLE                 cspHand;
 110         CSSM_CC_HANDLE                  ccHand = 0;
 111         CSSM_RETURN                             crtn;
 112         CSSM_BOOL                               bareCsp = CSSM_TRUE;
 113         char                                    resp = 'n';
 114                                                 // initial op = get random data
 115         CSSM_BOOL                               weMalloc = CSSM_FALSE;
 116         unsigned char                   seed[SEED_SIZE];
 117         CSSM_CRYPTO_DATA                cseed;
 118         int                                     i;
 119         unsigned                                reqLen = 16;
 120         CSSM_BOOL                               explicitSeed;
 121
 122         for(arg=1; arg<argc; arg++) {
 123                 argp = argv[arg];
 124             switch(argv[arg][0]) {
 125                         case 'D':
 126                                 bareCsp = CSSM_FALSE;
 127                                 break;
 128                         default:
 129                                 usage(argv);
 130                 }
 131         }
 132         cspHand = cspDlDbStartup(bareCsp, NULL);
 133         if(cspHand == 0) {
 134                 exit(1);
 135         }
 136
 137         /* set up for explicit seed */
 138         cseed.Param.Length = SEED_SIZE;
 139         cseed.Param.Data = seed;
 140         for(i=0; i<SEED_SIZE; i++) {
 141                 seed[i] = i;
 142         }
 143         cseed.Callback = NULL;
 144         cseed.CallerCtx = NULL;
 145         explicitSeed = CSSM_TRUE;
 146
 147         while(1) {
 148                 printf(" g   Get random data w/seed\n");
 149                 printf(" n   Get random data w/o seed\n");
 150                 printf(" c   Get random data using current context\n");
 151                 printf(" m   we malloc (current: %s)\n",
 152                         weMalloc ? "True" : "False");
 153                 printf(" M   CSP mallocs\n");
 154                 printf(" s   seed via explicit data (current: %d)\n", (int)explicitSeed);
 155                 printf(" S   seed via callback\n");
 156                 printf(" q   quit\n");
 157                 fpurge(stdin);
 158                 printf("\ncommand me: ");
 159         nextChar:
 160                 resp = getchar();
 161                 if(resp == 'q') {
 162                         break;
 163                 }
 164                 switch(resp) {
 165                         case 'g':
 166                                 if(ccHand != 0) {
 167                                         crtn = CSSM_DeleteContext(ccHand);
 168                                         if(crtn) {
 169                                                 printError("CSSM_DeleteContext", crtn);
 170                                         }
 171                                         ccHand = 0;
 172                                 }
 173                                 doGenRand(cspHand, ccHand, &cseed, reqLen, weMalloc);
 174                                 break;
 175                         case 'n':
 176                                 if(ccHand != 0) {
 177                                         crtn = CSSM_DeleteContext(ccHand);
 178                                         if(crtn) {
 179                                                 printError("CSSM_DeleteContext", crtn);
 180                                         }
 181                                         ccHand = 0;
 182                                 }
 183                                 doGenRand(cspHand, ccHand, NULL, reqLen, weMalloc);
 184                                 break;
 185                         case 'c':
 186                                 doGenRand(cspHand, ccHand, NULL, reqLen, weMalloc);
 187                                 break;
 188                         case 'm':
 189                                 weMalloc = CSSM_TRUE;
 190                                 break;
 191                         case 'M':
 192                                 weMalloc = CSSM_FALSE;
 193                                 break;
 194                         case 'l':
 195                                 printf("New length: ");
 196                                 scanf("%d", &reqLen);
 197                                 break;
 198                         case 's':
 199                                 /* explicit seed - presence of callback is the determinant */
 200                                 cseed.Callback = NULL;
 201                                 explicitSeed = CSSM_TRUE;
 202                                 break;
 203                         case 'S':
 204                                 /* seed by calllback */
 205                                 cseed.Callback = seedCallback;
 206                                 explicitSeed = CSSM_FALSE;
 207                                 break;
 208                         case '\n':
 209                                 goto nextChar;
 210                         default:
 211                                 printf("Huh?\n");
 212                 }
 213         }
 214         if((crtn = CSSM_ModuleDetach(cspHand))) {
 215                 printError("CSSM_ModuleDetach", crtn);
 216                 exit(1);
 217         }
 218         return 0;
 219 }