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