/*
 * Copyright 2000, International Business Machines Corporation and others.
 * All Rights Reserved.
 * 
 * This software has been released under the terms of the IBM Public
 * License.  For details, see the LICENSE file in the top-level source
 * directory or online at http://www.openafs.org/dl/license10.html
 */

/*
 * Revision 2.2  90/08/20  10:19:23
 * Cleanup.
 * Remove dependence on auth.h
 * 
 * Revision 2.1  90/08/07  19:33:42
 * Start with clean version to sync test and dev trees.
 * */

#include <afs/param.h>
#include <afs/stds.h>
#include <sys/types.h>
#include <netinet/in.h>
#include "fcrypt.h"


#ifdef TCRYPT
extern int ROUNDS;
#else
#define ROUNDS 16
#endif

struct ktc_encryptionKey {
    char data[8];
};

void print_msg (text, msg, length)
  char *text;
  afs_int32  msg[];
  int	length;
{   int i;
    unsigned char *msgtext = (unsigned char *)msg;
    int cksum;

    if (length % 8 != 0) {
	printf ("Length of message (%d) incorrect\n", length);
	return;
    }
    printf ("%s\n", text);
    for (i=0; i<length; i+=8) {
	unsigned char *m = msgtext+i;
	printf ("%02x%02x%02x%02x %02x%02x%02x%02x",
		m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7]);
	printf ("  ");
    }
    cksum = 0;
    for (i=0; i<length; i++) cksum += *(i + msgtext);
    printf (" (%4x)\n", cksum&0xffff);
}

static int total_diff, minimum_diff, number_diff;

compare (orig, chgd)
  afs_uint32 orig[2];
  afs_uint32 chgd[2];
{   afs_uint32 temp;
    int           diff = 0;

    for (temp = orig[0] ^ chgd[0]; temp; temp >>= 1) diff += temp&1;
    for (temp = orig[1] ^ chgd[1]; temp; temp >>= 1) diff += temp&1;
    printf ("%.8x %.8x  (%d)\n", chgd[0], chgd[1], diff);
    number_diff++;
    total_diff += diff;
    minimum_diff = (diff<minimum_diff) ? diff : minimum_diff;
}

#include "AFS_component_version_number.c"

int main (argc, argv)
  int   argc;
  char *argv[];
{
    struct ktc_encryptionKey key;
    fc_KeySchedule  schedule;
    afs_int32 e[2];
    afs_int32 d[2];
    afs_int32 c[2];
    int  i;
    int  iterations;
    int  for_time = (argc > 1) && (strcmp(argv[1], "time") == 0);
    int  for_time_key = (argc > 1) && (strcmp(argv[1], "time_key") == 0);
    int	 for_cbc = (argc > 1) && (strcmp(argv[1], "cbc") == 0);

    if (for_time || for_time_key) {
	if (argc == 3) iterations = atoi(argv[2]);
	else iterations = 10000;
    }

    if (for_time)
	for (i=0; i<iterations; i++) fc_ecb_encrypt (e,d,schedule, 1);
    else if (for_time_key)
	for (i=0; i<iterations; i++) fc_keysched (&key, schedule);
    else if (for_cbc) {
	afs_int32 msg[10];
	afs_int32 out[10];
	afs_int32 dec[10];
	afs_uint32 xor[2];

	for (i=0; i<10; i++) msg[i]=htonl(i);
	bcopy ("abcdefgh", &key, sizeof(struct ktc_encryptionKey));
	fc_keysched (&key, schedule);
	print_msg ("Starting msg is:", msg, sizeof(msg));
	bcopy(&key, xor, 2*sizeof(afs_int32));
	fc_cbc_encrypt (msg, out, sizeof(msg), schedule, &key, ENCRYPT);
	bcopy(&key, xor, 2*sizeof(afs_int32));
	fc_cbc_encrypt (out, dec, sizeof(msg), schedule, &key, DECRYPT);
	if (bcmp (msg, dec, sizeof(msg)) != 0)
	    printf ("Encryption FAILED!\n");
	print_msg ("Encrypted is:", out, sizeof(out));
	print_msg ("Decrypted is:", dec, sizeof(dec));
    }
    else {
	int rounds;
#ifndef TCRYPT
	printf ("Number of rounds is fixed at %d; try recompiling w/ -DTCRYPT=1\n", ROUNDS);
#endif
	e[0] = 0x11111111;
	e[1] = 0xaaaaaaaa;
	bcopy ("abcdefgh", &key, sizeof(struct ktc_encryptionKey));
	for (rounds=2; rounds<=MAXROUNDS; rounds +=2) {
#ifdef TCRYPT
	    ROUNDS = rounds;
#endif
	    printf ("\n  ROUNDS = %d\n", ROUNDS);
	    total_diff = 0;
	    minimum_diff = 64;
	    number_diff = 0;
	    
	    fc_keysched (&key, schedule);
	    fc_ecb_encrypt (e, d, schedule, 1);
	    
	    printf ("Checking data bits\n");
	    for (i=1; i; i<<=1) {
		e[0] ^= i;
		fc_ecb_encrypt (e, c, schedule, 1);
		compare (d,c);
		e[0] ^= i;
		e[1] ^= i;
		fc_ecb_encrypt (e, c, schedule, 1);
		compare (d,c);
		e[1] ^= i;
	    }
	    printf ("Checking key bits\n");
	    for (i=0; i<56; i++) {
		unsigned char *keyByte;
		keyByte = ((unsigned char *)(&key)) + i/7;
		*keyByte ^= (2 << (i%7));
		fc_keysched (&key, schedule);
		fc_ecb_encrypt (e, c, schedule, 1);
		compare (d,c);
		*keyByte ^= (2 << (i%7));
	    }
	    print_msg ("clear: ", e, sizeof(e));
	    
	    print_msg ("Encrypted: ", d, sizeof(d));
	    
	    fc_keysched (&key, schedule);
	    fc_ecb_encrypt (d, e, schedule, 0);
	    print_msg ("De-encrypted: ", e, sizeof(e));
	    printf ("Rounds=%d, average diff = %d bits, minimum diff = %d\n",
		    ROUNDS, total_diff/number_diff, minimum_diff);
	}
    }
}
