aes_main.cpp

RC2算法源代码

     the Monte Carlo test (binary string)
 */
void
FormNewKey (char *K, int b, BYTE *secondToLast, BYTE *last)
{
  BYTE bsK[32]; /* binary string K */
  int k;

  /* first convert K to a binary string */
  for (k=0; k < b; ++k) {
    bsK[k] = HEX_TO_DIGIT (K[2*k]);
    bsK[k] <<= 4;
    bsK[k] |= HEX_TO_DIGIT (K[2*k+1]);
  }

  /* now combine bsK with secondToLast and Last */
  if (b >= 16 && b <= 32) {
    for (k=0; k < b-16; ++k)
      bsK[k] ^= secondToLast[k+32-b];
    for (; k < b; ++k)
      bsK[k] ^= last[k-(b-16)];
  }
  else if (b < 16) {
    for (k=0; k < b; ++k)
      bsK[k] ^= last[k+16-b];
  }
  else {
    printf ("ERROR!  MCT requies b <= 32\n");
    exit(1);
  }

  /* Now convert the new key back to a hexadecimal string */
  for (k=0; k < b; ++k) {
    K[2*k] = HEX (((bsK[k]>>4)&15));
    K[2*k+1] = HEX (bsK[k]&15);
  }

}



/* Monte Carlo Test - ECB Encryption
   (b = key bytes)
 */
void
MCT1 (FILE *fp, int b)
{
  char *K;
  keyInstance S;
  int i, j, k;
  BYTE pt[BLOCKSIZE/8], ct[BLOCKSIZE/8], ib[BLOCKSIZE/8];
  cipherInstance ci;

  K = (char *) malloc (2*b);

  /* set the plaintext to all 0's */
  for (k=0; k<BLOCKSIZE/8; ++k)
    pt[k] = 0;

  /* set the key to all 0's */
  memset (K, '0', 2*b);
  
  fprintf (fp, "==========\n\n");
  fprintf (fp, "KEYSIZE=%d\n\n", 8*b);

  for (i=0; i < 400; ++i) {
    fprintf (fp, "I=%d\n",i);
    fprintf (fp, "KEY=");
    outputKey (fp, K, 2*b);
    fprintf (fp, "\n");
    fprintf (fp, "PT=");
    outputBlock (fp, pt);
    fprintf (fp, "\n");

    makeKey (&S, DIR_ENCRYPT, b*8, K);
    cipherInit (&ci, MODE_ECB, "");

    for (j = 0; j < 10000; ++j) {

      for (k=0; k < BLOCKSIZE/8; ++k)
        ib[k] = pt[k];

      blockEncrypt (&ci, &S, ib, 128, ct);

      for (k=0; k < BLOCKSIZE/8; ++k)
        pt[k] = ct[k];
    }

    /* at end of loop:
        pt has the last ciphertext
        ib has second to last ciphertext
     */
    fprintf (fp, "CT=");
    outputBlock (fp, pt);
    fprintf (fp, "\n\n");

    /* form new key
     */
    FormNewKey (K, b, ib, pt);

    /* The plaintext for the next loop is the ciphertext that
       was just output.  This is already stored in pt.
     */
  }

  free (K);
}


/* Monte Carlo Test - ECB Decryption
   (b = key bytes)
 */
void
MCT2 (FILE *fp, int b)
{
  char *K;
  keyInstance S;
  int i, j, k;
  BYTE pt[BLOCKSIZE/8], ct[BLOCKSIZE/8], ib[BLOCKSIZE/8];
  cipherInstance ci;

  K = (char *) malloc (2*b);

  /* set the plaintext to all 0's */
  for (k=0; k<BLOCKSIZE/8; ++k)
    ct[k] = 0;

  /* set the key to all 0's */
  memset (K, '0', 2*b);

  fprintf (fp, "==========\n\n");
  fprintf (fp, "KEYSIZE=%d\n\n", 8*b);

  for (i=0; i < 400; ++i) {
    fprintf (fp, "I=%d\n",i);
    fprintf (fp, "KEY=");
    outputKey (fp, K, 2*b);
    fprintf (fp, "\n");
    fprintf (fp, "CT=");
    outputBlock (fp, ct);
    fprintf (fp, "\n");

    makeKey (&S, DIR_DECRYPT, b*8, K);
    cipherInit (&ci, MODE_ECB, "");

    for (j = 0; j < 10000; ++j) {

      for (k=0; k < BLOCKSIZE/8; ++k)
        ib[k] = ct[k];

      blockDecrypt (&ci, &S, ct, 128, pt);
 
      for (k=0; k < BLOCKSIZE/8; ++k)
        ct[k] = pt[k]; 

    }

    fprintf (fp, "PT=");
    outputBlock (fp, pt);
    fprintf (fp, "\n\n");

    /* form new key
     */
    FormNewKey (K, b, ib, pt);

    /* The ciphertext for the next loop is the plaintext that
       was just output.  This is already stored in ct.
     */
  }

  free (K);

}



/* Monte Carlo Test - CBC Encryption
   (b = key bytes)
 */
void
MCT3 (FILE *fp, int b)
{
  char *K;
  keyInstance S;
  int i, j, k;
  BYTE pt[BLOCKSIZE/8], ct[BLOCKSIZE/8], ib[BLOCKSIZE/8];
  BYTE cv[BLOCKSIZE/8], iv[BLOCKSIZE/8];
  cipherInstance ci;

  /* choose an initial value */
  for (k=0; k < BLOCKSIZE/8; ++k)
    iv[k] = 0x0;

  K = (char *) malloc (2*b);

  /* set the plaintext to all 0's */
  for (k=0; k<BLOCKSIZE/8; ++k)
    pt[k] = 0;

  /* set the key to all 0's */
  memset (K, '0', 2*b);
  
  fprintf (fp, "==========\n\n");
  fprintf (fp, "KEYSIZE=%d\n\n", 8*b);

  for (i=0; i < 400; ++i) {

    if (i==0) {
      for (k=0; k < BLOCKSIZE/8; ++k)
        cv[k] = iv[k];
    }

    fprintf (fp, "I=%d\n",i);
    fprintf (fp, "KEY=");
    outputKey (fp, K, 2*b);
    fprintf (fp, "\n");
    fprintf (fp, "IV=");
    outputBlock (fp, cv);
    fprintf (fp, "\n");
    fprintf (fp, "PT=");
    outputBlock (fp, pt);
    fprintf (fp, "\n");

    makeKey (&S, DIR_ENCRYPT, b*8, K);
    cipherInit (&ci, MODE_ECB, "");

    for (j = 0; j < 10000; ++j) {
      for (k=0; k < BLOCKSIZE/8; ++k)
        ib[k] = (BYTE) (pt[k] ^ cv[k]);

      blockEncrypt (&ci, &S, ib, 128, ct);

      if (j==0) {
        for (k=0; k < BLOCKSIZE/8; ++k)
          pt[k] = cv[k];
      }
      else {
        /* cv holds the ciphertext from the previous round */
        for (k=0; k < BLOCKSIZE/8; ++k)
          pt[k] = cv[k];
      }

      for (k=0; k < BLOCKSIZE/8; ++k)
        cv[k] = ct[k];

    }

    fprintf (fp, "CT=");
    outputBlock (fp, ct);
    fprintf (fp, "\n\n");

    /* form new key
     */
    FormNewKey (K, b, pt, ct);

    for (k=0; k < BLOCKSIZE/8; ++k) {
      cv[k] = ct[k];
    }

  }

  free (K);
}


/* Monte Carlo Test - CBC Decryption
   (b = key bytes)
 */
void
MCT4 (FILE *fp, int b)
{
  char *K;
  keyInstance S;
  int i, j, k;
  BYTE pt[BLOCKSIZE/8], ct[BLOCKSIZE/8], ib[BLOCKSIZE/8];
  BYTE cv[BLOCKSIZE/8], iv[BLOCKSIZE/8], ob[BLOCKSIZE/8];
  cipherInstance ci;

  /* choose an initial value */
  for (k=0; k < BLOCKSIZE/8; ++k)
    iv[k] = 0x0;

  K = (char *) malloc (2*b);

  /* set the plaintext to all 0's */
  for (k=0; k<BLOCKSIZE/8; ++k)
    ct[k] = 0;

  /* set the key to all 0's */
  memset (K, '0', 2*b);
  
  fprintf (fp, "==========\n\n");
  fprintf (fp, "KEYSIZE=%d\n\n", 8*b);

  for (i=0; i < 400; ++i) {

    if (i==0) {
      for (k=0; k < BLOCKSIZE/8; ++k)
        cv[k] = iv[k];
    }

    fprintf (fp, "I=%d\n",i);
    fprintf (fp, "KEY=");
    outputKey (fp, K, 2*b);
    fprintf (fp, "\n");
    fprintf (fp, "IV=");
    outputBlock (fp, cv);
    fprintf (fp, "\n");
    fprintf (fp, "CT=");
    outputBlock (fp, ct);
    fprintf (fp, "\n");

    makeKey (&S, DIR_DECRYPT, b*8, K);
    cipherInit (&ci, MODE_ECB, "");

    for (j = 0; j < 10000; ++j) {
      for (k=0; k < BLOCKSIZE/8; ++k)
        ib[k] = ct[k];

      blockDecrypt (&ci, &S, ib, 128, ob);

      for (k=0; k < BLOCKSIZE/8; ++k)
        pt[k] = (BYTE) (ob[k] ^ cv[k]);

      for (k=0; k < BLOCKSIZE/8; ++k)
        cv[k] = ct[k];

      /* cv holds the ciphertext from the previous round */
      for (k=0; k < BLOCKSIZE/8; ++k)
        ct[k] = pt[k];
    }

    fprintf (fp, "PT=");
    outputBlock (fp, pt);
    fprintf (fp, "\n\n");

    FormNewKey (K, b, cv, pt);

  }

  free (K);

}