sim.c

破解des算法的程序

/*
 *   Run the system for one clock cycle and update the state.
 */
void RunClock(void) {
  int i,j,k,b;
  unsigned char key[7], m[8], c[8];

  for (i = 0; i < 24; i++) {
    if (STARTUP_DELAY[i] > 0) {
      STARTUP_DELAY[i]--;
      if (STARTUP_DELAY[i] == 0)
        STARTUP_DELAY[i] = -1;               /* prevent stop if 1st C0=match */
    }
  }

  /* DES CLOCK 5: Plaintext vector result from last DES is ready. */
  if (DES_POSITION == 5) {
    for (i = 0; i < 24; i++) {               /* i = search engine            */
      k = 0;                                 /* k = result of byte lookups   */
      for (j = 0; j < 8; j++) {              /* j = byte idx                 */
        b = WORKING_PTXT[8*i+j];             /* b = byte value               */
        if (STATE[b/8] & (1 << (b%8)))       /* check plaintext vector       */
          k = (k >> 1) | 128;                /*   match = load 1 in k msb    */
        else                                 /*                              */
          k = (k >> 1) | 0;                  /*   no match = load 0 into k   */
      }
      k |= STATE[REG_PTXT_BYTE_MASK];        /* set bits where bytemask=1    */
      MATCH[i] = (unsigned char)((k == 255) ? 1 : 0);

      if ((STATE[REG_SEARCH_STATUS(i)] & 1) == 0 || STARTUP_DELAY[i] > 0) {
        /* If search not active, key delta = 0 and do C0 next */
        WORKING_KDELTA[i] = 0;
        WORKING_NEXT_SELECTOR[i] = 1;
      } else if (k != 0xFF || (STATE[REG_SEARCH_STATUS(i)] & 2) ||
              STARTUP_DELAY[i] < 0) {
        /* If no match or CURRENTLY doing C1 or first DES result,
         *     key delta = 1 and do C0 next.
         */
        WORKING_KDELTA[i] = 1;
        WORKING_NEXT_SELECTOR[i] = 0;
        if (k==0xFF)
          printKeyInfo(stderr, "ALERT: Skip match while doing C1 ", i);
        if (k == 0xFF && STARTUP_DELAY[i] < 0)
          printKeyInfo(stderr, "ALERT:    (C1 above is startup phantom.)", i);
      } else if (WORKING_LAST_SELECTOR[i] == 0) {
        /* If doing C0 and got a match from C0, back up and do C1 */
        WORKING_KDELTA[i] = -1;
        WORKING_NEXT_SELECTOR[i] = 1;
        printKeyInfo(stderr, "ALERT: Match C0; will backup for C1 ", i);
      } else {
        /* If doing C0 and got a match from C1, halt */
        STATE[REG_SEARCH_STATUS(i)] &= (255-1);
        WORKING_KDELTA[i] = 0;
        WORKING_NEXT_SELECTOR[i] = 1;
        printKeyInfo(stderr, "ALERT: Matched C1; halting ", i);
      }
      if (STARTUP_DELAY[i] < 0)
        STARTUP_DELAY[i]++;
    }
  }

  if (DES_POSITION == 15) {
    for (i = 0; i < 24; i++) {
      memcpy(THIS_KEY+i*7, NEXT_KEY+i*7, 7);
      memcpy(NEXT_KEY+i*7, STATE+REG_SEARCH_KEY(i), 7);
    }
  }

  /* END OF DES CYCLE: Extract results */
  if (DES_POSITION == CLOCKS_PER_DES-1) {
    for (i = 0; i < 24; i++) {

      /* Do the DES decryption */
      for (j = 0; j < 7; j++)
        key[j] = THIS_KEY[i*7+(6-j)];
      for (j = 0; j < 8; j++)
        c[j] = WORKING_CTXT[8*i+7-j];
      desDecrypt(m, c, key);
      for (j = 0; j < 8; j++) {
        WORKING_PTXT[8*i+7-j] = m[j];
        RAW_DES_OUT[8*i+7-j] = m[j];
      }

      if (STATE[REG_SEARCHINFO] & 2) {                     /* if extraXOR    */
        WORKING_PTXT[8*i+4] ^= WORKING_PTXT[8*i+0];        /*    L = L xor R */
        WORKING_PTXT[8*i+5] ^= WORKING_PTXT[8*i+1];        /*      "         */
        WORKING_PTXT[8*i+6] ^= WORKING_PTXT[8*i+2];        /*      "         */
        WORKING_PTXT[8*i+7] ^= WORKING_PTXT[8*i+3];        /*      "         */
      }
      if ((STATE[REG_SEARCH_STATUS(i)] & 2) == 0) {         /* if c0,        */
        WORKING_PTXT[8*i+0] ^= STATE[REG_PTXT_XOR_MASK+0];  /* do ptxtXorMsk */
        WORKING_PTXT[8*i+1] ^= STATE[REG_PTXT_XOR_MASK+1];  /*      "        */
        WORKING_PTXT[8*i+2] ^= STATE[REG_PTXT_XOR_MASK+2];  /*      "        */
        WORKING_PTXT[8*i+3] ^= STATE[REG_PTXT_XOR_MASK+3];  /*      "        */
        WORKING_PTXT[8*i+4] ^= STATE[REG_PTXT_XOR_MASK+4];  /*      "        */
        WORKING_PTXT[8*i+5] ^= STATE[REG_PTXT_XOR_MASK+5];  /*      "        */
        WORKING_PTXT[8*i+6] ^= STATE[REG_PTXT_XOR_MASK+6];  /*      "        */
        WORKING_PTXT[8*i+7] ^= STATE[REG_PTXT_XOR_MASK+7];
      } else {                                              /* if c1         */
        if (STATE[REG_SEARCHINFO] & 1) {                    /* if useCBC     */
          WORKING_PTXT[8*i+0] ^= STATE[REG_CIPHERTEXT0+0];  /* xor with c0   */
          WORKING_PTXT[8*i+1] ^= STATE[REG_CIPHERTEXT0+1];  /*      "        */
          WORKING_PTXT[8*i+2] ^= STATE[REG_CIPHERTEXT0+2];  /*      "        */
          WORKING_PTXT[8*i+3] ^= STATE[REG_CIPHERTEXT0+3];  /*      "        */
          WORKING_PTXT[8*i+4] ^= STATE[REG_CIPHERTEXT0+4];  /*      "        */
          WORKING_PTXT[8*i+5] ^= STATE[REG_CIPHERTEXT0+5];  /*      "        */
          WORKING_PTXT[8*i+6] ^= STATE[REG_CIPHERTEXT0+6];  /*      "        */
          WORKING_PTXT[8*i+7] ^= STATE[REG_CIPHERTEXT0+7];  /*      "        */
        }
      }

      /* Update ciphertext selector (state & last) */
      WORKING_LAST_SELECTOR[i] = (STATE[0x47+8*i] & 2) ? 1 : 0;
      STATE[0x47+8*i] &= 0xFD;                      /* select ciphertext 0   */
      if (WORKING_NEXT_SELECTOR[i])                 /* ... unless we want c1 */
        STATE[0x47+8*i] |= 2;                       /* ... then select c1    */
    }
  }

  /* LAST DES CLOCK: Load in the updated key */
  if (DES_POSITION == 14) {
    for (i = 0; i < 24; i++) {
      if (WORKING_KDELTA[i] == 1) {                    /*   if key delta = 1 */
        increment32(STATE+REG_SEARCH_KEY(i));
      }
      if (WORKING_KDELTA[i] == -1) {                  /*   if key delta = -1 */
        decrement32(STATE+REG_SEARCH_KEY(i));
      }
    }
  }

  /* DES CLOCK 0: Latch in new working keys and working ciphertexts */
  if (DES_POSITION == 0) {
    for (i = 0; i < 24; i++) {                          /* i = search engine */
      /* pick between ctxt 0 and ctxt 1? */
      if ((STATE[REG_SEARCH_STATUS(i)] & 2) == 0 && STARTUP_DELAY[i] == 0)
        memcpy(WORKING_CTXT+8*i, STATE+REG_CIPHERTEXT0, 8);       /* copy c0 */
      else
        memcpy(WORKING_CTXT+8*i, STATE+REG_CIPHERTEXT1, 8);       /* copy c1 */
    }
  }

  /* Update ChipAllActive, board all active */
  j = 1;
  for (i = 0; i < 24; i++)
    j &= STATE[0x47+i*8];
  j = (j & 1) ? 1 : 0;
  STATE[REG_SEARCHINFO] &= (255-4);        /* set ChipAllActive              */
  STATE[REG_SEARCHINFO] |= (4*j);          /*    "                           */
  if ((STATE[REG_SEARCHINFO] & 16) == 0)   /* If board all active enable = 0 */
    ALLACTIVE_OUT = ALLACTIVE_IN;
  else
    ALLACTIVE_OUT = ALLACTIVE_IN & j;
  STATE[REG_SEARCHINFO] &= (255-8);                  /* set board all active */
  STATE[REG_SEARCHINFO] |= (8*ALLACTIVE_OUT);        /* set board all active */

  /* Do any pending updates and update DES cycle position */
  if (PENDING_UPDATE_ADDR1 >= 0)
    STATE[PENDING_UPDATE_ADDR1] = PENDING_UPDATE_DATA1;
  PENDING_UPDATE_ADDR1 = PENDING_UPDATE_ADDR2;
  PENDING_UPDATE_DATA1 = PENDING_UPDATE_DATA2;
  PENDING_UPDATE_ADDR2 = PENDING_UPDATE_ADDR3;
  PENDING_UPDATE_DATA2 = PENDING_UPDATE_DATA3;
  PENDING_UPDATE_ADDR3 = -1;
  DES_POSITION = (DES_POSITION + 1) % CLOCKS_PER_DES;
}


static void desDecrypt(unsigned char m[8], unsigned char c[8],
        unsigned char k[7]) {
  bool key[56], message[64];
  int i;

#ifdef DEBUG
  printf("DES_DECRYPT(k="); for (i=0; i<7;i++) printf("%02X",k[i]);
  printf(", c="); for (i=0; i<8;i++) printf("%02X",c[i]);
#endif

  for (i = 0; i < 56; i++)
    key[55-i] = ((k[i/8] << (i & 7)) & 128) ? 1 : 0;
  for (i = 0; i < 64; i++)
    message[63-i] = ((c[i/8] << (i & 7)) & 128) ? 1 : 0;
  DecryptDES(key, message, message, 0);
  for (i = 0; i < 8; i++)
    m[i] = 0;
  for (i = 0; i < 64; i++)
    if (message[63-i])
      m[i/8] |= 128 >> (i%8);

#ifdef DEBUG
  printf(")=");
  for (i=0; i<8;i++)
    printf("%02X",m[i]);
  printf(", clk=%ld\n",CLOCK_COUNTER);
#endif

}




static void printKeyInfo(FILE *outDev, char *preamble, int searchUnit) {
  fprintf(outDev, preamble);
  fprintf(outDev, "(K=%02X%02X%02X%02X%02X%02X%02X, clk=%ld, searchUnit=%d)\n",
                STATE[0x40+8*searchUnit+6],STATE[0x40+8*searchUnit+5],
                STATE[0x40+8*searchUnit+4],STATE[0x40+8*searchUnit+3],
                STATE[0x40+8*searchUnit+2],STATE[0x40+8*searchUnit+1],
                STATE[0x40+8*searchUnit+0], CLOCK_COUNTER, searchUnit);

  printf(preamble);
  printf("(K=%02X%02X%02X%02X%02X%02X%02X, clk=%ld, searchUnit=%d)\n",
                STATE[0x40+8*searchUnit+6],STATE[0x40+8*searchUnit+5],
                STATE[0x40+8*searchUnit+4],STATE[0x40+8*searchUnit+3],
                STATE[0x40+8*searchUnit+2],STATE[0x40+8*searchUnit+1],
                STATE[0x40+8*searchUnit+0], CLOCK_COUNTER, searchUnit);

}


static void increment32(unsigned char *num) {
  if ((++(num[0])) == 0)
    if ((++(num[1])) == 0)
      if ((++(num[2])) == 0)
        ++(num[3]);
}


static void decrement32(unsigned char *num) {
  if (((num[0])--) == 0)
    if (((num[1])--) == 0)
      if (((num[2])--) == 0)
        (num[3])--;
}