idea_cmd.c

IDEA加密算法(PGP中使用的加密算法）

    CopyHeadOfRasFile();
    if (optEncrypt) /* encrypt rasterfile */
      while ((len = GetData(data)) == Idea_dataSize) {
        EncryptData(data); 
        PutData(data, Idea_dataSize); 
      } 
    else /* decrypt rasterfile */
      while ((len = GetData(data)) == Idea_dataSize) {
        DecryptData(data); 
        PutData(data, Idea_dataSize); 
      } 
    if (len) PutData(data, len);
    CloseOutput();
  }
  else if (optEncrypt) { /* encrypt data */
    while ((len = GetData(data)) == Idea_dataSize) {
      EncryptData(data); 
      PutData(data, Idea_dataSize); 
    }
    if (len) { EncryptData(data); PutData(data, Idea_dataSize); }
    PlainLenToData(inputLen, data);
    EncryptData(data);
    PutData(data, Idea_dataSize);
    CloseOutput();
  }
  else if (optDecrypt) { /* decrypt data */
    if ((len = GetData(dat[0])) != Idea_dataSize) {
      if (len) Error(2, "input is not a valid cryptogram");
      else Error(3, "there are no data to decrypt");
    }
    DecryptData(dat[0]);
    if ((len = GetData(dat[1])) != Idea_dataSize) {
      if (len) Error(4, "input is not a valid cryptogram");
      DataToPlainLen(dat[0], &len);
      if (len) Error(5, "input is not a valid cryptogram");
    }
    else {
      DecryptData(dat[1]);
      t = 2;
      while ((len = GetData(dat[t])) == Idea_dataSize) {
        DecryptData(dat[t]);
        PutData(dat[(t + 2) & 3], Idea_dataSize);
        t = (t + 1) & 3;
      }
      if (len) Error(6, "input is not a valid cryptogram");
      DataToPlainLen(dat[(t + 3) & 3], &len);
      len += 2 * Idea_dataSize;
      if (inputLen < len && len <= inputLen + Idea_dataSize) {
        len -= inputLen;
        PutData(dat[(t + 2) & 3], len);
      }
      else Error(7, "input is not a valid cryptogram");
    }
    CloseOutput();
  }
  else { /* compute hash value */
    for (i = Idea_dataLen - 1; i >= 0; i--) {
      hashHigh[i] = userKey[i];
      hashLow[i] = userKey[i + Idea_dataLen];
    }
    if (optCopyHash) { 
      while ((len = GetData(data)) == Idea_dataSize) {
        HashData(data); 
        PutData(data, Idea_dataSize); 
      }
      if (len) { HashData(data); PutData(data, len); }
      PlainLenToData(inputLen, data);
      HashData(data);
      CloseOutput();
    }
    else { /* optHash */
      while ((len = GetData(data)) == Idea_dataSize) HashData(data); 
      if (len) HashData(data);
      PlainLenToData(inputLen, data);
      HashData(data);
    }
    WriteHashValue();
  }
} /* CryptData */

/******************************************************************************/
/* measure the time to encrypt 'nofTestData' data-blocks                      */

#ifdef ANSI_C
  void TimeTest(void)
#else
  TimeTest()
#endif

{
#ifdef TIME
  clock_t startTime, endTime;
  float size, duration;
  Idea_Data data;
  Idea_Key key;
  int i;

  for (i = 0; i < Idea_dataLen; i++) data[i] = 7 * Idea_dataLen - i;
  for (i = 0; i < Idea_keyLen; i++) key[i] = 2 * Idea_keyLen - i;
  for (i = Idea_keyLen - Idea_dataLen; i >= 0; i -= Idea_dataLen)
    Idea_Crypt(&key[i], &key[i], key);
  if ((startTime = clock()) == -1) PError("start timer");
  for (i = nofTestData; i != 0; i--) Idea_Crypt(data, data, key);
  if ((endTime = clock()) == -1) PError("stop timer");
  size = (float)nofTestData * (float)Idea_dataSize / 131072.0;
  duration = (float)(endTime - startTime) / (float)CLK_TCK;
  fprintf(stderr, 
    "time needed to encrypt %4.1f MBit of data was %4.1f seconds (%6.3f Mb/s)\n"
    , size, duration, size / duration);
#endif
} /* TimeTest */

/******************************************************************************/
/*                          I N I T I A L I Z A T I O N                       */
/******************************************************************************/
/* set option to TRUE                                                         */

#ifdef ANSI_C
  void SetOption(int *option)
#else
  SetOption(option)
  int *option;
#endif

{ if (*option) UsageError(10);
  *option = TRUE;
} /* SetOption */

/******************************************************************************/
/* set encryption / decryption mode                                           */

#ifdef ANSI_C
  void SetMode(int newMode, char **str)
#else
  SetMode(newMode, str)
  int newMode;
  char **str;
#endif

{ if (mode != nomode) UsageError(11);
  mode = newMode;
  (*str)++; (*str)++;
  if (newMode == cbc || newMode == cfb || newMode == ofb) {
    if ('0' <= **str && **str <= '9') {
      interleave = 0;
      do {
        interleave = 10 * interleave + (**str - '0');
        if (interleave >= maxInterleave)
          Error(12, "interleave factor is too large");
        (*str)++;
      } while ('0' <= **str && **str <= '9');
      if (interleave == 0) Error(13, "interleave factor is zero");
    }
    else interleave = 1;
  }
} /* SetMode */

/******************************************************************************/
/* read options from string 'str'                                             */

#ifdef ANSI_C
  void ReadOptions(char *str, int *readKeyString, int *readKeyHexString)
#else
  ReadOptions(str, readKeyString, readKeyHexString)
  char *str;
  int *readKeyString;
  int *readKeyHexString;
#endif

{ char ch;

  str++;
  *readKeyString = *readKeyHexString = FALSE;
  while((ch = *str++) != '\0') {
    switch (ch) {
      case 'a':
        if (str[0] == 'b' && str[1] == 'r') SetMode(abr, &str);
        else UsageError(14);
        break;
      case 'c':
        if (str[0] == 'b' && str[1] == 'c') SetMode(cbc, &str);
        else if (str[0] == 'f' && str[1] == 'b') SetMode(cfb, &str);
        else UsageError(15);
        break;
      case 'd': SetOption(&optDecrypt); break;
      case 'e': 
        if (str[0] == 'c' && str[1] == 'b') SetMode(ecb, &str);
        else SetOption(&optEncrypt);
        break;
      case 'h': SetOption(&optHash); break;
      case 'H': SetOption(&optCopyHash); break;
      case 'o':
        if (str[0] == 'f' && str[1] == 'b') SetMode(ofb, &str);
        else UsageError(16);
        break;
      case 'k': SetOption(&optKeyString); *readKeyString = TRUE; break;
      case 'K': SetOption(&optKeyHexString); *readKeyHexString = TRUE; break;
      case 't':
        if (str[0] == 'a' && str[1] == 'n') SetMode(tan, &str);
        else UsageError(17);
        break;
#ifdef TIME
      case 'T': SetOption(&optTime); break;
#endif
#ifdef RASTERFILE
      case 'r': SetOption(&optRas); break;
#endif
      default: UsageError(18); break;
    }
  }
} /* ReadOptions */

/******************************************************************************/
/* check if options are unique and set default options                        */

#ifdef ANSI_C
  void AdjustOptions(void)
#else
  AdjustOptions()
#endif

{ if (optTime) {
    if (optDecrypt || optEncrypt || optHash || optCopyHash || optKeyString ||
        optKeyHexString || optRas || mode != nomode) UsageError(20);
  }
  else {
    if (optDecrypt && optEncrypt) UsageError(21);
    if (optHash && optCopyHash) UsageError(22);
    if (optKeyString && optKeyHexString) UsageError(23);
    if (!optDecrypt && !optEncrypt && !optHash && !optCopyHash)
      if (mode == tan || mode == abr) SetOption(&optHash);
      else SetOption(&optEncrypt);
    if (optHash || optCopyHash) {
      if (optDecrypt || optEncrypt) UsageError(24);
      if (optRas) UsageError(25);
      if (mode == nomode) mode = tan;
      else if (mode != tan && mode != abr) UsageError(26);
    }
    else {
      if (mode == nomode) { mode = cbc; interleave = 1; }
      else if (mode != ecb && mode != cbc && mode != cfb && mode != ofb)
        UsageError(27);
      if (!optKeyString && !optKeyHexString) UsageError(28);
    }
    time_0 = interleave;
    time_N = 0;
  }
} /* AdjustOptions */

/******************************************************************************/
/* convert a hex-digit into an integer                                        */

#ifdef ANSI_C
  u_int32 HexToInt(char ch)
#else
  u_int32 HexToInt(ch)
  char ch;
#endif

{ if ('0' <= ch && ch <= '9') return ch - '0';
  else if ('a' <= ch  && ch <= 'f') return 10 + (ch - 'a');
  else if ('A' <= ch && ch <= 'F') return 10 + (ch - 'A');
  else if (ch == ':') return colon;
  else if (ch == '\0') return eol;
  else return error;
} /* HexToInt */

/******************************************************************************/
/* convert a character into an integer                                        */

#ifdef ANSI_C
  u_int32 CharToInt(char ch)
#else
  u_int32 CharToInt(ch)
  char ch;
#endif

{ if ('!' <= ch && ch <= '~') return ch - '!';
  else if (ch == '\0') return eol;
  else return error;
} /* CharToInt */

/******************************************************************************/
/* initializes key and initial values                                         */

#ifdef ANSI_C
  void ReadKeyHexString(char *str)
#else
  ReadKeyHexString(str)
  char *str;
#endif

{ int pos, i;
  u_int32 val;

  while ((val = HexToInt(*str++)) < eol) {
    for (i = Idea_userKeyLen - 1; i >= 0; i--) {
      val |= (u_int32)userKey[i] << 4;
      userKey[i] = (u_int16)(val & 0xFFFF);
      val >>= 16;
    }
    if (val) Error(29, "key value is too large");
  }
  for (pos = 0; val == colon && pos < maxInterleave; pos++) {
    while ((val = HexToInt(*str++)) < eol) {
      for (i = Idea_dataLen - 1; i >= 0; i--) {
        val |= (u_int32)state[pos][i] << 4;
        state[pos][i] = (u_int16)(val & 0xFFFF);
        val >>= 16;
      }
      if (val) Error(30, "initial value is too large");
    }
  }
  if (val == colon) Error(31, "too many initial values specified");
  if (val != eol) Error(32, "wrong character in initialization string");
} /* ReadKeyHexString */

/******************************************************************************/
/* initialize key and initial values                                          */

#ifdef ANSI_C
  void ReadKeyString(char *str)
#else
  ReadKeyString(str)
  char *str;
#endif

{ int i;
  u_int32 val;

  while ((val = CharToInt(*str++)) < eol) {
    for (i = Idea_userKeyLen - 1; i >= 0; i--) {
      val += (u_int32)userKey[i] * nofChar;
      userKey[i] = (u_int16)(val & 0xFFFF);
      val >>= 16;
    }
  }
  if (val != eol) Error(32, "wrong character in key string");
} /* ReadKeyString */

/******************************************************************************/
/* show current state informations                                            */

#ifdef ANSI_C
  void ShowState(void)
#else
  ShowState()
#endif

{ int i, j;

  fprintf(stderr, "Mode = {");
  switch (mode) {
    case ecb: fprintf(stderr, "ecb"); break;
    case cbc: fprintf(stderr, "cbc"); break;
    case cfb: fprintf(stderr, "cfb"); break;
    case ofb: fprintf(stderr, "ofb"); break;
    case tan: fprintf(stderr, "tan"); break;
    case abr: fprintf(stderr, "abr"); break;
    case nomode: fprintf(stderr, "nomode"); break;
    default: fprintf(stderr, "!!!wrong mode!!!"); break;
  }
  if (interleave > 0) fprintf(stderr, "%d", interleave);
  if (optEncrypt) fprintf(stderr, ", encrypt");
  if (optDecrypt) fprintf(stderr, ", decrypt");
  if (optHash) fprintf(stderr, ", hash");
  if (optCopyHash) fprintf(stderr, ", copy and hash");
  if (optKeyString) fprintf(stderr, ", key string");
  if (optKeyHexString) fprintf(stderr, ", key hex string");
  if (optRas) fprintf(stderr, ", raster file");
  if (optTime) fprintf(stderr, ", time test");
  fprintf(stderr, "}\n\nKey:\n");
  for (i = 0; i < Idea_keyLen; i++) {
    fprintf(stderr, "%7u<%4x>", key[i], key[i]);
    if ((i % 6) == 5) fprintf(stderr, "\n");
  }
  fprintf(stderr, "\n\nInitial values:");
  for (i = 0; i < interleave; i++) {
    fprintf(stderr, "\n  x[N -%2d] =", i + 1);
    for (j = 0; j < Idea_dataLen; j++)
      fprintf(stderr, "%7u<%4x>", state[i][j], state[i][j]);
  }
  fprintf(stderr, "\n");
} /* ShowState */

/******************************************************************************/
/*                          M A I N - P R O C E D U R E                       */
/******************************************************************************/
#ifdef ANSI_C
  int main(int argc, char *argv[])
#else
  int main(argc, argv)
  int argc;
  char *argv[];
#endif

{ int readKeyString, readKeyHexString;

  Init();
  argv++; argc--;
  while (argc > 0 && argv[0][0] == '-' && argv[0][1] != '\0') {
    ReadOptions(*argv++, &readKeyString, &readKeyHexString); argc--;
    if (readKeyString || readKeyHexString) {
      if (argc <= 0)  Error(36, "missing key on command line");
      else if (readKeyString) { ReadKeyString(*argv++); argc--; }
      else { ReadKeyHexString(*argv++); argc--; }
    }
  }
  AdjustOptions();
  if (optTime && argc > 0 || optCopyHash && argc > 3 || 
      !optCopyHash && argc > 2) Error(37, "too many parameters");
  if (optTime)
    TimeTest();
  else {
    if (argc > 1 && strcmp(argv[0], argv[1]) == 0)
      Error(38, "source and destination are identical");
    if (argc > 2 && strcmp(argv[0], argv[2]) == 0)
      Error(39, "source and destination are identical");
    if (argc > 2 && strcmp(argv[1], argv[2]) == 0)
      Error(40, "destinations are identical");
    inFile = stdin;
    outFile = hashFile = stdout;
    if (argc > 0) {
      if (strcmp(*argv, "-") == 0) { argv++; argc--; }
      else {
        inFile = fopen(*argv++, "rb"); argc--;
        if (inFile == NULL) PError(*--argv);
      }
    }
    if (optCopyHash) {
      if (argc > 1) {
        outFile = fopen(*argv++, "wb"); argc--;
        if (outFile == NULL) PError(*--argv);
      }
      if (argc > 0) {
        hashFile = fopen(*argv++, "wb"); argc--;
        if (hashFile == NULL) PError(*--argv);
      }
      else hashFile = stderr;
    }
    else if (optHash) {
      if (argc > 0) {
        hashFile = fopen(*argv++, "wb"); argc--;
        if (hashFile == NULL) PError(*--argv);
      }
    }
    else {
      if (argc > 0) {
        outFile = fopen(*argv++, "wb"); argc--;
        if (outFile == NULL) PError(*--argv);
      }
    }
    if (argc > 0) Error(41, "too many parameters");
    Idea_ExpandUserKey(userKey, key);
    if (optDecrypt && (mode == ecb || mode == cbc)) Idea_InvertKey(key, key);
#ifdef DEBUG
    ShowState();
#else
    CryptData();
#endif
  }
  return 0;
}