src/rxkad/tcrypt.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 #include <afsconfig.h>
  11 #include <afs/param.h>
  12 #include <afs/stds.h>
  13
  14 #include <roken.h>
  15
  16 #include "fcrypt.h"
  17
  18
  19 #ifdef TCRYPT
  20 extern int ROUNDS;
  21 #else
  22 #define ROUNDS 16
  23 #endif
  24
  25 struct ktc_encryptionKey {
  26     char data[8];
  27 };
  28
  29 void
  30 print_msg(text, msg, length)
  31      char *text;
  32      afs_int32 msg[];
  33      int length;
  34 {
  35     int i;
  36     unsigned char *msgtext = (unsigned char *)msg;
  37     int cksum;
  38
  39     if (length % 8 != 0) {
  40         printf("Length of message (%d) incorrect\n", length);
  41         return;
  42     }
  43     printf("%s\n", text);
  44     for (i = 0; i < length; i += 8) {
  45         unsigned char *m = msgtext + i;
  46         printf("%02x%02x%02x%02x %02x%02x%02x%02x", m[0], m[1], m[2], m[3],
  47                m[4], m[5], m[6], m[7]);
  48         printf("  ");
  49     }
  50     cksum = 0;
  51     for (i = 0; i < length; i++)
  52         cksum += *(i + msgtext);
  53     printf(" (%4x)\n", cksum & 0xffff);
  54 }
  55
  56 static int total_diff, minimum_diff, number_diff;
  57
  58 compare(orig, chgd)
  59      afs_uint32 orig[2];
  60      afs_uint32 chgd[2];
  61 {
  62     afs_uint32 temp;
  63     int diff = 0;
  64
  65     for (temp = orig[0] ^ chgd[0]; temp; temp >>= 1)
  66         diff += temp & 1;
  67     for (temp = orig[1] ^ chgd[1]; temp; temp >>= 1)
  68         diff += temp & 1;
  69     printf("%.8x %.8x  (%d)\n", chgd[0], chgd[1], diff);
  70     number_diff++;
  71     total_diff += diff;
  72     minimum_diff = (diff < minimum_diff) ? diff : minimum_diff;
  73 }
  74
  75 #include "AFS_component_version_number.c"
  76
  77 int
  78 main(argc, argv)
  79      int argc;
  80      char *argv[];
  81 {
  82     struct ktc_encryptionKey key;
  83     fc_KeySchedule schedule;
  84     afs_int32 e[2];
  85     afs_int32 d[2];
  86     afs_int32 c[2];
  87     int i;
  88     int iterations;
  89     int for_time = (argc > 1) && (strcmp(argv[1], "time") == 0);
  90     int for_time_key = (argc > 1) && (strcmp(argv[1], "time_key") == 0);
  91     int for_cbc = (argc > 1) && (strcmp(argv[1], "cbc") == 0);
  92
  93     if (for_time || for_time_key) {
  94         if (argc == 3)
  95             iterations = atoi(argv[2]);
  96         else
  97             iterations = 10000;
  98     }
  99
 100     if (for_time)
 101         for (i = 0; i < iterations; i++)
 102             fc_ecb_encrypt(e, d, schedule, 1);
 103     else if (for_time_key)
 104         for (i = 0; i < iterations; i++)
 105             fc_keysched(&key, schedule);
 106     else if (for_cbc) {
 107         afs_int32 msg[10];
 108         afs_int32 out[10];
 109         afs_int32 dec[10];
 110         afs_uint32 xor[2];
 111
 112         for (i = 0; i < 10; i++)
 113             msg[i] = htonl(i);
 114         memcpy(&key, "abcdefgh", sizeof(struct ktc_encryptionKey));
 115         fc_keysched(&key, schedule);
 116         print_msg("Starting msg is:", msg, sizeof(msg));
 117         memcpy(xor, &key, 2 * sizeof(afs_int32));
 118         fc_cbc_encrypt(msg, out, sizeof(msg), schedule, &key, ENCRYPT);
 119         memcpy(xor, &key, 2 * sizeof(afs_int32));
 120         fc_cbc_encrypt(out, dec, sizeof(msg), schedule, &key, DECRYPT);
 121         if (memcmp(msg, dec, sizeof(msg)) != 0)
 122             printf("Encryption FAILED!\n");
 123         print_msg("Encrypted is:", out, sizeof(out));
 124         print_msg("Decrypted is:", dec, sizeof(dec));
 125     } else {
 126         int rounds;
 127 #ifndef TCRYPT
 128         printf
 129             ("Number of rounds is fixed at %d; try recompiling w/ -DTCRYPT=1\n",
 130              ROUNDS);
 131 #endif
 132         e[0] = 0x11111111;
 133         e[1] = 0xaaaaaaaa;
 134         memcpy(&key, "abcdefgh", sizeof(struct ktc_encryptionKey));
 135         for (rounds = 2; rounds <= MAXROUNDS; rounds += 2) {
 136 #ifdef TCRYPT
 137             ROUNDS = rounds;
 138 #endif
 139             printf("\n  ROUNDS = %d\n", ROUNDS);
 140             total_diff = 0;
 141             minimum_diff = 64;
 142             number_diff = 0;
 143
 144             fc_keysched(&key, schedule);
 145             fc_ecb_encrypt(e, d, schedule, 1);
 146
 147             printf("Checking data bits\n");
 148             for (i = 1; i; i <<= 1) {
 149                 e[0] ^= i;
 150                 fc_ecb_encrypt(e, c, schedule, 1);
 151                 compare(d, c);
 152                 e[0] ^= i;
 153                 e[1] ^= i;
 154                 fc_ecb_encrypt(e, c, schedule, 1);
 155                 compare(d, c);
 156                 e[1] ^= i;
 157             }
 158             printf("Checking key bits\n");
 159             for (i = 0; i < 56; i++) {
 160                 unsigned char *keyByte;
 161                 keyByte = ((unsigned char *)(&key)) + i / 7;
 162                 *keyByte ^= (2 << (i % 7));
 163                 fc_keysched(&key, schedule);
 164                 fc_ecb_encrypt(e, c, schedule, 1);
 165                 compare(d, c);
 166                 *keyByte ^= (2 << (i % 7));
 167             }
 168             print_msg("clear: ", e, sizeof(e));
 169
 170             print_msg("Encrypted: ", d, sizeof(d));
 171
 172             fc_keysched(&key, schedule);
 173             fc_ecb_encrypt(d, e, schedule, 0);
 174             print_msg("De-encrypted: ", e, sizeof(e));
 175             printf("Rounds=%d, average diff = %d bits, minimum diff = %d\n",
 176                    ROUNDS, total_diff / number_diff, minimum_diff);
 177         }
 178     }
 179 }