release/src/router/dropbear/libtomcrypt/testprof/katja_test.c

   1 #include <tomcrypt_test.h>
   2
   3 #ifdef MKAT
   4
   5 int katja_test(void)
   6 {
   7    unsigned char in[1024], out[1024], tmp[1024];
   8    katja_key     key, privKey, pubKey;
   9    int           hash_idx, prng_idx, stat, stat2, size;
  10    unsigned long kat_msgsize, len, len2, cnt;
  11    static unsigned char lparam[] = { 0x01, 0x02, 0x03, 0x04 };
  12
  13    hash_idx = find_hash("sha1");
  14    prng_idx = find_prng("yarrow");
  15    if (hash_idx == -1 || prng_idx == -1) {
  16       fprintf(stderr, "katja_test requires SHA1 and yarrow");
  17       return 1;
  18    }
  19
  20 for (size = 1024; size <= 2048; size += 256) {
  21
  22    /* make 10 random key */
  23    for (cnt = 0; cnt < 10; cnt++) {
  24       DO(katja_make_key(&yarrow_prng, prng_idx, size/8, &key));
  25       if (mp_count_bits(key.N) < size - 7) {
  26          fprintf(stderr, "katja_%d key modulus has %d bits\n", size, mp_count_bits(key.N));
  27
  28 len = mp_unsigned_bin_size(key.N);
  29 mp_to_unsigned_bin(key.N, tmp);
  30  fprintf(stderr, "N == \n");
  31 for (cnt = 0; cnt < len; ) {
  32    fprintf(stderr, "%02x ", tmp[cnt]);
  33    if (!(++cnt & 15)) fprintf(stderr, "\n");
  34 }
  35
  36 len = mp_unsigned_bin_size(key.p);
  37 mp_to_unsigned_bin(key.p, tmp);
  38  fprintf(stderr, "p == \n");
  39 for (cnt = 0; cnt < len; ) {
  40    fprintf(stderr, "%02x ", tmp[cnt]);
  41    if (!(++cnt & 15)) fprintf(stderr, "\n");
  42 }
  43
  44 len = mp_unsigned_bin_size(key.q);
  45 mp_to_unsigned_bin(key.q, tmp);
  46  fprintf(stderr, "\nq == \n");
  47 for (cnt = 0; cnt < len; ) {
  48    fprintf(stderr, "%02x ", tmp[cnt]);
  49    if (!(++cnt & 15)) fprintf(stderr, "\n");
  50 }
  51  fprintf(stderr, "\n");
  52
  53
  54          return 1;
  55       }
  56       if (cnt != 9) {
  57          katja_free(&key);
  58       }
  59    }
  60    /* encrypt the key (without lparam) */
  61    for (cnt = 0; cnt < 4; cnt++) {
  62    for (kat_msgsize = 1; kat_msgsize <= 42; kat_msgsize++) {
  63       /* make a random key/msg */
  64       yarrow_read(in, kat_msgsize, &yarrow_prng);
  65
  66       len  = sizeof(out);
  67       len2 = kat_msgsize;
  68
  69       DO(katja_encrypt_key(in, kat_msgsize, out, &len, NULL, 0, &yarrow_prng, prng_idx, hash_idx, &key));
  70       /* change a byte */
  71       out[8] ^= 1;
  72       DO(katja_decrypt_key(out, len, tmp, &len2, NULL, 0, hash_idx, &stat2, &key));
  73       /* change a byte back */
  74       out[8] ^= 1;
  75       if (len2 != kat_msgsize) {
  76          fprintf(stderr, "\nkatja_decrypt_key mismatch len %lu (first decrypt)", len2);
  77          return 1;
  78       }
  79
  80       len2 = kat_msgsize;
  81       DO(katja_decrypt_key(out, len, tmp, &len2, NULL, 0, hash_idx, &stat, &key));
  82       if (!(stat == 1 && stat2 == 0)) {
  83          fprintf(stderr, "katja_decrypt_key failed");
  84          return 1;
  85       }
  86       if (len2 != kat_msgsize || memcmp(tmp, in, kat_msgsize)) {
  87          unsigned long x;
  88          fprintf(stderr, "\nkatja_decrypt_key mismatch, len %lu (second decrypt)\n", len2);
  89          fprintf(stderr, "Original contents: \n");
  90          for (x = 0; x < kat_msgsize; ) {
  91              fprintf(stderr, "%02x ", in[x]);
  92              if (!(++x % 16)) {
  93                 fprintf(stderr, "\n");
  94              }
  95          }
  96          fprintf(stderr, "\n");
  97          fprintf(stderr, "Output contents: \n");
  98          for (x = 0; x < kat_msgsize; ) {
  99              fprintf(stderr, "%02x ", out[x]);
 100              if (!(++x % 16)) {
 101                 fprintf(stderr, "\n");
 102              }
 103          }
 104          fprintf(stderr, "\n");
 105          return 1;
 106       }
 107    }
 108    }
 109
 110    /* encrypt the key (with lparam) */
 111    for (kat_msgsize = 1; kat_msgsize <= 42; kat_msgsize++) {
 112       len  = sizeof(out);
 113       len2 = kat_msgsize;
 114       DO(katja_encrypt_key(in, kat_msgsize, out, &len, lparam, sizeof(lparam), &yarrow_prng, prng_idx, hash_idx, &key));
 115       /* change a byte */
 116       out[8] ^= 1;
 117       DO(katja_decrypt_key(out, len, tmp, &len2, lparam, sizeof(lparam), hash_idx, &stat2, &key));
 118       if (len2 != kat_msgsize) {
 119          fprintf(stderr, "\nkatja_decrypt_key mismatch len %lu (first decrypt)", len2);
 120          return 1;
 121       }
 122       /* change a byte back */
 123       out[8] ^= 1;
 124
 125       len2 = kat_msgsize;
 126       DO(katja_decrypt_key(out, len, tmp, &len2, lparam, sizeof(lparam), hash_idx, &stat, &key));
 127       if (!(stat == 1 && stat2 == 0)) {
 128          fprintf(stderr, "katja_decrypt_key failed");
 129          return 1;
 130       }
 131       if (len2 != kat_msgsize || memcmp(tmp, in, kat_msgsize)) {
 132          fprintf(stderr, "katja_decrypt_key mismatch len %lu", len2);
 133          return 1;
 134       }
 135    }
 136
 137 #if 0
 138
 139    /* sign a message (unsalted, lower cholestorol and Atkins approved) now */
 140    len = sizeof(out);
 141    DO(katja_sign_hash(in, 20, out, &len, &yarrow_prng, prng_idx, hash_idx, 0, &key));
 142
 143 /* export key and import as both private and public */
 144    len2 = sizeof(tmp);
 145    DO(katja_export(tmp, &len2, PK_PRIVATE, &key));
 146    DO(katja_import(tmp, len2, &privKey));
 147    len2 = sizeof(tmp);
 148    DO(katja_export(tmp, &len2, PK_PUBLIC, &key));
 149    DO(katja_import(tmp, len2, &pubKey));
 150
 151    /* verify with original */
 152    DO(katja_verify_hash(out, len, in, 20, hash_idx, 0, &stat, &key));
 153    /* change a byte */
 154    in[0] ^= 1;
 155    DO(katja_verify_hash(out, len, in, 20, hash_idx, 0, &stat2, &key));
 156
 157    if (!(stat == 1 && stat2 == 0)) {
 158       fprintf(stderr, "katja_verify_hash (unsalted, origKey) failed, %d, %d", stat, stat2);
 159       katja_free(&key);
 160       katja_free(&pubKey);
 161       katja_free(&privKey);
 162       return 1;
 163    }
 164
 165    /* verify with privKey */
 166    /* change a byte */
 167    in[0] ^= 1;
 168    DO(katja_verify_hash(out, len, in, 20, hash_idx, 0, &stat, &privKey));
 169    /* change a byte */
 170    in[0] ^= 1;
 171    DO(katja_verify_hash(out, len, in, 20, hash_idx, 0, &stat2, &privKey));
 172
 173    if (!(stat == 1 && stat2 == 0)) {
 174       fprintf(stderr, "katja_verify_hash (unsalted, privKey) failed, %d, %d", stat, stat2);
 175       katja_free(&key);
 176       katja_free(&pubKey);
 177       katja_free(&privKey);
 178       return 1;
 179    }
 180
 181    /* verify with pubKey */
 182    /* change a byte */
 183    in[0] ^= 1;
 184    DO(katja_verify_hash(out, len, in, 20, hash_idx, 0, &stat, &pubKey));
 185    /* change a byte */
 186    in[0] ^= 1;
 187    DO(katja_verify_hash(out, len, in, 20, hash_idx, 0, &stat2, &pubKey));
 188
 189    if (!(stat == 1 && stat2 == 0)) {
 190       fprintf(stderr, "katja_verify_hash (unsalted, pubkey) failed, %d, %d", stat, stat2);
 191       katja_free(&key);
 192       katja_free(&pubKey);
 193       katja_free(&privKey);
 194       return 1;
 195    }
 196
 197    /* sign a message (salted) now (use privKey to make, pubKey to verify) */
 198    len = sizeof(out);
 199    DO(katja_sign_hash(in, 20, out, &len, &yarrow_prng, prng_idx, hash_idx, 8, &privKey));
 200    DO(katja_verify_hash(out, len, in, 20, hash_idx, 8, &stat, &pubKey));
 201    /* change a byte */
 202    in[0] ^= 1;
 203    DO(katja_verify_hash(out, len, in, 20, hash_idx, 8, &stat2, &pubKey));
 204
 205    if (!(stat == 1 && stat2 == 0)) {
 206       fprintf(stderr, "katja_verify_hash (salted) failed, %d, %d", stat, stat2);
 207       katja_free(&key);
 208       katja_free(&pubKey);
 209       katja_free(&privKey);
 210       return 1;
 211    }
 212 #endif
 213
 214    katja_free(&key);
 215    katja_free(&pubKey);
 216    katja_free(&privKey);
 217 }
 218
 219    /* free the key and return */
 220    return 0;
 221 }
 222
 223 #else
 224
 225 int katja_test(void)
 226 {
 227    fprintf(stderr, "NOP");
 228    return 0;
 229 }
 230
 231 #endif