testvec.c

破解des算法的程序

  /* Make a final pass reading all the registers */
  for (i = 255; i >= 0; i--)
    readout[i] = RunSimulator_CheckRegister(i);
  /* scan stopped units */
  for (i = 0; i < 24; i++) {
    if ((readout[REG_SEARCH_STATUS(i)] & 1) == 0) {              /* stalled? */
      goodKey[6] = RunSimulator_CheckRegister(REG_SEARCH_KEY(i)+0);
      goodKey[5] = RunSimulator_CheckRegister(REG_SEARCH_KEY(i)+1);
      goodKey[4] = RunSimulator_CheckRegister(REG_SEARCH_KEY(i)+2);
      goodKey[3] = RunSimulator_CheckRegister(REG_SEARCH_KEY(i)+3);
      goodKey[2] = RunSimulator_CheckRegister(REG_SEARCH_KEY(i)+4);
      goodKey[1] = RunSimulator_CheckRegister(REG_SEARCH_KEY(i)+5);
      goodKey[0] = RunSimulator_CheckRegister(REG_SEARCH_KEY(i)+6);
      RunSimulator_SetRegister(REG_SEARCH_STATUS(i), 1);          /* restart */
      fprintf(stderr, "****** Full match in unit %d; extracted k = ", i);
      for (j = 0; j < 7; j++) {
        fprintf(stderr, "%02X", goodKey[j]);
        printf("%02X", goodKey[j]);
      }
      fprintf(stderr, "\n");
    }
  }
}



void GetUserInfo(unsigned char plaintextVector[32],
        unsigned char plaintextXorMask[8],
        unsigned char ciphertext0[8], unsigned char ciphertext1[8],
        unsigned char *plaintextByteMask, int *useCBC, int *extraXor,
        int *randomVector, unsigned char startKey[7], long *totalClocks) {
  char buffer[1024];
  unsigned char tmp[512];
  int i;

  printf("Enter plaintextVector values: ");
  gets(buffer);
  i = hex2bin(buffer, tmp);
  if (i <= 0 || i >= 256)
    EXIT_ERR("Must have at least 1 plaintextVector entry and at most 255.\n");
  memset(plaintextVector, 0, 32);
  while (i--)
    plaintextVector[tmp[i]/8] |= (1 << (tmp[i] % 8));

  printf("    Enter plaintext xor mask: ");
  gets(buffer);
  i = hex2bin(buffer, tmp);
  if (i != 8)
    EXIT_ERR("Must have 8 plaintext xor mask bytes.");
  memcpy(plaintextXorMask, tmp, 8);

  printf("          Enter ciphertext 0: ");
  gets(buffer);
  i = hex2bin(buffer, tmp);
  if (i != 8)
    EXIT_ERR("Must have 8 bytes in ciphertext 0.");
  memcpy(ciphertext0, tmp, 8);

  printf("          Enter ciphertext 1: ");
  gets(buffer);
  i = hex2bin(buffer, tmp);
  if (i != 8)
    EXIT_ERR("Must have 8 bytes in ciphertext 1.");
  memcpy(ciphertext1, tmp, 8);

  printf("   Enter plaintext byte mask: ");
  gets(buffer);
  i = hex2bin(buffer, tmp);
  if (i != 1)
    EXIT_ERR("Plaintext byte mask is 1 byte long.");
  *plaintextByteMask = tmp[0];

  printf("       Enter useCBC (0 or 1): ");
  gets(buffer);
  i = hex2bin(buffer, tmp);
  if (i != 1 || tmp[0] > 1)
    EXIT_ERR("Must enter 0 or 1 for useCBC.");
  *useCBC = tmp[0];

  printf("     Enter extraXor (0 or 1): ");
  gets(buffer);
  i = hex2bin(buffer, tmp);
  if (i != 1 || tmp[0] > 1)
    EXIT_ERR("Must enter 0 or 1 for extraXor.");
  *extraXor = tmp[0];

  printf(" Enter randomVector (0=randomize, 1=user input, >1=seed): ");
  gets(buffer);
  i = hex2bin(buffer, tmp);
  if (i != 1)
    EXIT_ERR("Must enter 0=randomize 1=use input, >1=value for prng seed).");
  *randomVector = tmp[0];

  printf("          Enter starting key: ");
  gets(buffer);
  if (hex2bin(buffer, tmp) != 7)
    EXIT_ERR("Must enter 7 hex bytes as the key.\n");
  memcpy(startKey, tmp, 7);

  printf("      Enter number of clocks: ");
  gets(buffer);
  sscanf(buffer, "%ld", totalClocks);
  if (*totalClocks < 1 || *totalClocks > 1000000000L)
    EXIT_ERR("Must have between 1 and 1 billion clocks.\n");

  printHexString("\n  PtxtVector = ", plaintextVector, 32);
  printHexString(" PtxtXorMask = ", plaintextXorMask, 8);
  printHexString("Ciphertext 0 = ", ciphertext0, 8);
  printHexString("Ciphertext 1 = ", ciphertext1, 8);
  printHexString("PtxtByteMask = ", plaintextByteMask, 1);
  printf(        "      useCBC = %d\n", *useCBC);
  printf(        "    extraXor = %d\n", *extraXor);
  printf(        "randomVector = %x\n", *randomVector);
  printHexString("Starting key = ", startKey, 7);
  printf(        "Total clocks = %ld\n\n", *totalClocks);
}


void LoadState(unsigned char plaintextVector[32],
        unsigned char plaintextXorMask[8],
        unsigned char ciphertext0[8], unsigned char ciphertext1[8],
        unsigned char plaintextByteMask, int useCBC, int extraXor,
        unsigned char startKey[7]) {
  int i;

  for (i = 0; i < 32; i++)
    RunSimulator_SetRegister(REG_PTXT_VECTOR + i, plaintextVector[i]);
  for (i = 0; i < 8; i++)
    RunSimulator_SetRegister(REG_PTXT_XOR_MASK + i, plaintextXorMask[7-i]);
  for (i = 0; i < 8; i++)
    RunSimulator_SetRegister(REG_CIPHERTEXT0 + i, ciphertext0[7-i]);
  for (i = 0; i < 8; i++)
    RunSimulator_SetRegister(REG_CIPHERTEXT1 + i, ciphertext1[7-i]);
  RunSimulator_SetRegister(REG_PTXT_BYTE_MASK, plaintextByteMask);
  RunSimulator_SetRegister(REG_SEARCHINFO, (useCBC?1:0) |
          (extraXor?2:0) | 16);                       /* enable board active */
  for (i = 0; i < 24; i++) {                              /* for each engine */
    RunSimulator_SetRegister(REG_SEARCH_KEY(i)+0, startKey[6]);
    RunSimulator_SetRegister(REG_SEARCH_KEY(i)+1, startKey[5]);
    RunSimulator_SetRegister(REG_SEARCH_KEY(i)+2, startKey[4]);
    RunSimulator_SetRegister(REG_SEARCH_KEY(i)+3, startKey[3]);
    RunSimulator_SetRegister(REG_SEARCH_KEY(i)+4, startKey[2]);
    RunSimulator_SetRegister(REG_SEARCH_KEY(i)+5, startKey[1]);
    RunSimulator_SetRegister(REG_SEARCH_KEY(i)+6, (startKey[0] + i) & 255);
    RunSimulator_SetRegister(REG_SEARCH_STATUS(i), 1);
  }
}



void RunSimulator_SetRegister(int addr, int data) {
  char buffer[256];

  /* RESET,BOARD_EN,ALE,ADRSEL1,WRB,RDB,ADRSEL2,ALLACT_IN,ADDR,CHIP_ID,DATA */
  sprintf(buffer, "1%d0%d110%d %02x %02x %02x\n", BOARD_EN_IN, ADRSEL1_IN,
          ALLACTIVE_IN, addr, HARDWIRED_CHIP_ID, data);
  RunChip(buffer, FILE_FROMCHIP, USE_RAW_IO);
  fputs(buffer, FILE_TOCHIP);

  sprintf(buffer, "1%d0%d010%d %02x %02x %02x\n", BOARD_EN_IN, ADRSEL1_IN,
          ALLACTIVE_IN, addr, HARDWIRED_CHIP_ID, data);
  RunChip(buffer, FILE_FROMCHIP, USE_RAW_IO);
  fputs(buffer, FILE_TOCHIP);

  sprintf(buffer, "1%d0%d110%d %02x %02x %02x\n", BOARD_EN_IN, ADRSEL1_IN,
          ALLACTIVE_IN, addr, HARDWIRED_CHIP_ID, data);
  RunChip(buffer, FILE_FROMCHIP, USE_RAW_IO);
  fputs(buffer, FILE_TOCHIP);

  if ((rand() & 31) == 0)
    ALLACTIVE_IN = 1-ALLACTIVE_IN;
}


void RunSimulator_DummyIO(void) {
  char buffer[256];
  int i,b,addr,chip;

  if ((rand() & 3) > 0) {
    addr = rand() & 255;
    chip = (rand() & 7) ? HARDWIRED_CHIP_ID : (rand() & 255);
    b = (rand() & 7) ? 1 : 0;
    /*RESET,BOARD_EN,ALE,ADRSEL1,WRB,RDB,ADRSEL2,ALLACT_IN,ADDR,CHIP_ID,DATA*/
    sprintf(buffer, "1%d01110%d %02x %02x 00\n", b, ALLACTIVE_IN, addr, chip);
    RunChip(buffer, FILE_FROMCHIP, USE_RAW_IO);
    fputs(buffer, FILE_TOCHIP);
    RunChip(buffer, FILE_FROMCHIP, USE_RAW_IO);
    fputs(buffer, FILE_TOCHIP);
    sprintf(buffer, "1%d01100%d %02x %02x 00\n", b, ALLACTIVE_IN, addr, chip);
    RunChip(buffer, FILE_FROMCHIP, USE_RAW_IO);
    fputs(buffer, FILE_TOCHIP);
    RunChip(buffer, FILE_FROMCHIP, USE_RAW_IO);
    fputs(buffer, FILE_TOCHIP);
    sprintf(buffer, "1%d01111%d %02x %02x 00\n", b, ALLACTIVE_IN, addr, chip);
    RunChip(buffer, FILE_FROMCHIP, USE_RAW_IO);
    fputs(buffer, FILE_TOCHIP);
    RunChip(buffer, FILE_FROMCHIP, USE_RAW_IO);
    fputs(buffer, FILE_TOCHIP);
    RunChip(buffer, FILE_FROMCHIP, USE_RAW_IO);
    fputs(buffer, FILE_TOCHIP);
  } else {
    sprintf(buffer, "1101111%d FF %02x FF\n", ALLACTIVE_IN, HARDWIRED_CHIP_ID);
    for (i = rand() & 7; i > 0; i--) {
      RunChip(buffer, FILE_FROMCHIP, USE_RAW_IO);
      fputs(buffer, FILE_TOCHIP);
    }
  }
}



unsigned char RunSimulator_CheckRegister(int addr) {
  unsigned char rval;
  char buffer[256];

  /* RESET,BOARD_EN,ALE,ADRSEL1,WRB,RDB,ADRSEL2,ALLACT_IN,ADDR,CHIP_ID,DATA */
  sprintf(buffer, "1%d0%d110%d %02x %02x 00\n", BOARD_EN_IN, ADRSEL1_IN,
          ALLACTIVE_IN, addr, HARDWIRED_CHIP_ID /*no data*/);
  RunChip(buffer, FILE_FROMCHIP, USE_RAW_IO);
  fputs(buffer, FILE_TOCHIP);

  sprintf(buffer, "1%d0%d100%d %02x %02x 00\n", BOARD_EN_IN, ADRSEL1_IN,
          ALLACTIVE_IN, addr, HARDWIRED_CHIP_ID /*no data*/);
  rval=(unsigned char)RunChip(buffer, FILE_FROMCHIP, USE_RAW_IO);
  fputs(buffer, FILE_TOCHIP);

  sprintf(buffer, "1%d0%d111%d %02x %02x 00\n", BOARD_EN_IN, ADRSEL1_IN,
          ALLACTIVE_IN, addr, HARDWIRED_CHIP_ID /*no data*/);
  RunChip(buffer, FILE_FROMCHIP, USE_RAW_IO);
  fputs(buffer, FILE_TOCHIP);

  return (rval);
}


int unhex(char c) {
  if (c >= '0' && c <= '9')
    return (c - '0');
  if (c >= 'a' && c <= 'f')
    return (c - 'a' + 10);
  if (c >= 'A' && c <= 'F')
    return (c - 'A' + 10);
  return (-1);
}


int hex2bin(char *hex, unsigned char *bin) {
  int i = 0;
  int j = 0;

  /* Trim string if comments present */
  if (strchr(hex, '#') != NULL)
    *strchr(hex, '#') = 0;
  if (strchr(hex, '*') != NULL)
    *strchr(hex, '*') = 0;
  if (strchr(hex, '\'') != NULL)
    *strchr(hex, '\'') = 0;

  for (i = 0; i < (int)strlen(hex); i++) {
    if (hex[i] >= '0' && unhex(hex[i]) < 0)
      EXIT_ERR("Bad hex digit encountered.\n");
  }

  for (i = 0; i < (int)strlen(hex); i++) {
    if (hex[i] < '0')
      continue;
    if (hex[i] >= '0' && hex[i+1] >= '0') {
      bin[j++] = (unsigned char)(unhex(hex[i])*16+unhex(hex[i+1]));
      i++;                                                       /* skip one */
      continue;
    }
    if (hex[i] >= '0') {
      bin[j++] = (unsigned char)(unhex(hex[i]));
    }
  }
  return (j);
}


void printHexString(char *tag, unsigned char *data, int len) {
  int i;

  printf("%s", tag);
  for (i = 0; i < len; i++)
    printf("%02X", data[i]);
  printf("\n");
}


void OpenFiles(char *toChipFilename, char *fromChipFilename, int useRaw) {
  FILE_TOCHIP = fopen(toChipFilename, useRaw ? "rb" : "r");
  if (FILE_TOCHIP != NULL) {
    CREATING_VECTOR = 0;
  } else {
    FILE_TOCHIP = fopen(toChipFilename, useRaw ? "wb" : "w");
    if (FILE_TOCHIP == NULL) {
      fprintf(stderr, "Can't open \"s\" for toChip file\n", toChipFilename);
      exit(1);
    }
    CREATING_VECTOR = 1;
  }

  FILE_FROMCHIP = fopen(fromChipFilename, useRaw ? "wb" : "w");
  if (FILE_FROMCHIP == NULL) {
    fprintf(stderr, "Can't open \"s\" for fromChip file\n", fromChipFilename);
    exit(1);
  }

  USE_RAW_IO = useRaw;
#if 0               /* Activate this to add column descriptors in the output */
  if (!useRaw){
    fprintf(FILE_TOCHIP, "RESET\n");
    fprintf(FILE_TOCHIP, "|BOARD_EN\n");
    fprintf(FILE_TOCHIP, "||ALE\n");
    fprintf(FILE_TOCHIP, "|||ADRSEL1\n");
    fprintf(FILE_TOCHIP, "||||WRB\n");
    fprintf(FILE_TOCHIP, "|||||RDB\n");
    fprintf(FILE_TOCHIP, "||||||ADRSEL2\n");
    fprintf(FILE_TOCHIP, "|||||||ALLACTIVE_IN\n");
    fprintf(FILE_TOCHIP, "|||||||| ADDR\n");
    fprintf(FILE_TOCHIP, "|||||||| /\\ CHIP_ID\n");
    fprintf(FILE_TOCHIP, "|||||||| || /\\ DATA\n");
    fprintf(FILE_TOCHIP, "|||||||| || || /\\ ALLACTIVE_OUT\n");
    fprintf(FILE_FROMCHIP, "DATA\n");
    fprintf(FILE_FROMCHIP, "/\\ ALLACTIVE_OUT\n");
    fprintf(FILE_FROMCHIP, "|| | /-- IsActive [0..23] --\\\n");
  }
#endif
  fprintf(FILE_FROMCHIP, "KEY            DES_OUT          MATCH & SELECT1:\n");
}