Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/branches/ssh_chacha20poly1305/ttssh2/ttxssh/crypt.c

Diff of /branches/ssh_chacha20poly1305/ttssh2/ttxssh/crypt.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3043 by maya, Wed Oct 17 15:58:15 2007 UTC revision 3045 by maya, Thu Oct 18 03:49:39 2007 UTC
# Line 48  SOFTWARE, EVEN IF ADVISED OF THE POSSIBI Line 48  SOFTWARE, EVEN IF ADVISED OF THE POSSIBI
48  #define DEATTACK_DETECTED       1  #define DEATTACK_DETECTED       1
49    
50  /*  /*
51   * $Id: crypt.c,v 1.15 2007-10-17 15:58:15 maya Exp $ Cryptographic attack   * $Id: crypt.c,v 1.16 2007-10-18 03:49:39 maya Exp $ Cryptographic attack
52   * detector for ssh - source code (C)1998 CORE-SDI, Buenos Aires Argentina   * detector for ssh - source code (C)1998 CORE-SDI, Buenos Aires Argentina
53   * Ariel Futoransky(futo@core-sdi.com) <http://www.core-sdi.com>   * Ariel Futoransky(futo@core-sdi.com) <http://www.core-sdi.com>
54   */   */
# Line 219  static void no_encrypt(PTInstVar pvar, u Line 219  static void no_encrypt(PTInstVar pvar, u
219  static void cAES128_encrypt(PTInstVar pvar, unsigned char FAR * buf,  static void cAES128_encrypt(PTInstVar pvar, unsigned char FAR * buf,
220                              int bytes)                              int bytes)
221  {  {
 //      unsigned char key[AES128_KEYLEN], iv[AES128_IVLEN];  
222          unsigned char *newbuf = malloc(bytes);          unsigned char *newbuf = malloc(bytes);
223          int block_size = pvar->ssh2_keys[MODE_OUT].enc.block_size;          int block_size = pvar->ssh2_keys[MODE_OUT].enc.block_size;
224    
# Line 247  static void cAES128_encrypt(PTInstVar pv Line 246  static void cAES128_encrypt(PTInstVar pv
246                  goto error;                  goto error;
247    
248          } else {          } else {
                 //memcpy(key, pvar->ssh2_keys[MODE_OUT].enc.key, AES128_KEYLEN);  
                 // IVはDES関数内で更新されるため、ローカルにコピーしてから使う。  
                 //memcpy(iv, pvar->ssh2_keys[MODE_OUT].enc.iv, AES128_IVLEN);  
                   
                 //debug_print(50, key, 24);  
                 //debug_print(51, iv, 8);  
                 //debug_print(52, buf, bytes);  
                 //debug_print(53, newbuf, bytes);  
   
249                  memcpy(buf, newbuf, bytes);                  memcpy(buf, newbuf, bytes);
250    
251          }          }
252    
253  error:  error:
# Line 266  error: Line 257  error:
257  static void cAES128_decrypt(PTInstVar pvar, unsigned char FAR * buf,  static void cAES128_decrypt(PTInstVar pvar, unsigned char FAR * buf,
258                              int bytes)                              int bytes)
259  {  {
 //      unsigned char key[AES128_KEYLEN], iv[AES128_IVLEN];  
260          unsigned char *newbuf = malloc(bytes);          unsigned char *newbuf = malloc(bytes);
261          int block_size = pvar->ssh2_keys[MODE_IN].enc.block_size;          int block_size = pvar->ssh2_keys[MODE_IN].enc.block_size;
262    
# Line 293  static void cAES128_decrypt(PTInstVar pv Line 283  static void cAES128_decrypt(PTInstVar pv
283                  goto error;                  goto error;
284    
285          } else {          } else {
                 //memcpy(key, pvar->ssh2_keys[MODE_IN].enc.key, AES128_KEYLEN);  
                 // IVはDES関数内で更新されるため、ローカルにコピーしてから使う。  
                 //memcpy(iv, pvar->ssh2_keys[MODE_IN].enc.iv, AES128_IVLEN);  
                   
                 //debug_print(70, key, AES128_KEYLEN);  
                 //debug_print(71, iv, AES128_IVLEN);  
                 //debug_print(72, buf, bytes);  
                 //debug_print(73, newbuf, bytes);  
   
286                  memcpy(buf, newbuf, bytes);                  memcpy(buf, newbuf, bytes);
287    
288          }          }
289    
290  error:  error:
# Line 315  error: Line 297  error:
297  static void c3DES_CBC_encrypt(PTInstVar pvar, unsigned char FAR * buf,  static void c3DES_CBC_encrypt(PTInstVar pvar, unsigned char FAR * buf,
298                                int bytes)                                int bytes)
299  {  {
 //      unsigned char key[24], iv[8];  
300          unsigned char *newbuf = malloc(bytes);          unsigned char *newbuf = malloc(bytes);
301    
302          if (newbuf == NULL)          if (newbuf == NULL)
# Line 328  static void c3DES_CBC_encrypt(PTInstVar Line 309  static void c3DES_CBC_encrypt(PTInstVar
309                  goto error;                  goto error;
310    
311          } else {          } else {
312                    //unsigned char key[24], iv[8];
313                  //memcpy(key, pvar->ssh2_keys[MODE_OUT].enc.key, 24);                  //memcpy(key, pvar->ssh2_keys[MODE_OUT].enc.key, 24);
314                  // IVはDES関数内で更新されるため、ローカルにコピーしてから使う。                  // IVはDES関数内で更新されるため、ローカルにコピーしてから使う。
315                  //memcpy(iv, pvar->ssh2_keys[MODE_OUT].enc.iv, 8);                  //memcpy(iv, pvar->ssh2_keys[MODE_OUT].enc.iv, 8);
# Line 347  error: Line 329  error:
329  static void c3DES_CBC_decrypt(PTInstVar pvar, unsigned char FAR * buf,  static void c3DES_CBC_decrypt(PTInstVar pvar, unsigned char FAR * buf,
330                                int bytes)                                int bytes)
331  {  {
 //      unsigned char key[24], iv[8];  
332          unsigned char *newbuf = malloc(bytes);          unsigned char *newbuf = malloc(bytes);
333    
334          if (newbuf == NULL)          if (newbuf == NULL)
# Line 360  static void c3DES_CBC_decrypt(PTInstVar Line 341  static void c3DES_CBC_decrypt(PTInstVar
341                  goto error;                  goto error;
342    
343          } else {          } else {
344                    //unsigned char key[24], iv[8];
345                  //memcpy(key, pvar->ssh2_keys[MODE_IN].enc.key, 24);                  //memcpy(key, pvar->ssh2_keys[MODE_IN].enc.key, 24);
346                  // IVはDES関数内で更新されるため、ローカルにコピーしてから使う。                  // IVはDES関数内で更新されるため、ローカルにコピーしてから使う。
347                  //memcpy(iv, pvar->ssh2_keys[MODE_IN].enc.iv, 8);                  //memcpy(iv, pvar->ssh2_keys[MODE_IN].enc.iv, 8);
# Line 377  error: Line 359  error:
359  }  }
360    
361    
362    static void cBlowfish_encrypt2(PTInstVar pvar, unsigned char FAR * buf,
363                                   int bytes)
364    {
365            unsigned char *newbuf = malloc(bytes);
366            int block_size = pvar->ssh2_keys[MODE_OUT].enc.block_size;
367    
368            // 事前復号化により、全ペイロードが復号化されている場合は、0バイトになる。(2004.11.7 yutaka)
369            if (bytes == 0)
370                    return;
371    
372            if (newbuf == NULL)
373                    return;
374    
375            if (EVP_Cipher(&pvar->evpcip[MODE_OUT], newbuf, buf, bytes) == 0) {
376                    UTIL_get_lang_msg("MSG_BLOWFISH_ENCRYPT_ERROR", pvar,
377                                      "Blowfish encrypt error");
378                    notify_fatal_error(pvar, pvar->ts->UIMsg);
379                    goto error;
380    
381            } else {
382                    memcpy(buf, newbuf, bytes);
383    
384            }
385    
386    error:
387            free(newbuf);
388    }
389    
390    static void cBlowfish_decrypt2(PTInstVar pvar, unsigned char FAR * buf,
391                                   int bytes)
392    {
393            unsigned char *newbuf = malloc(bytes);
394            int block_size = pvar->ssh2_keys[MODE_IN].enc.block_size;
395    
396            // 事前復号化により、全ペイロードが復号化されている場合は、0バイトになる。(2004.11.7 yutaka)
397            if (bytes == 0)
398                    return;
399    
400            if (newbuf == NULL)
401                    return;
402    
403            if (EVP_Cipher(&pvar->evpcip[MODE_IN], newbuf, buf, bytes) == 0) {
404                    UTIL_get_lang_msg("MSG_BLOWFISH_DECRYPT_ERROR", pvar,
405                                      "Blowfish decrypt error");
406                    notify_fatal_error(pvar, pvar->ts->UIMsg);
407                    goto error;
408    
409            } else {
410                    memcpy(buf, newbuf, bytes);
411    
412            }
413    
414    error:
415            free(newbuf);
416    }
417    
418    
419    
420  static void c3DES_encrypt(PTInstVar pvar, unsigned char FAR * buf,  static void c3DES_encrypt(PTInstVar pvar, unsigned char FAR * buf,
421                            int bytes)                            int bytes)
422  {  {
# Line 597  BOOL CRYPT_set_supported_ciphers(PTInstV Line 637  BOOL CRYPT_set_supported_ciphers(PTInstV
637    
638          } else { // for SSH2(yutaka)          } else { // for SSH2(yutaka)
639                  // SSH2がサポートするデータ通信用アルゴリズム（公開鍵交換用とは別）                  // SSH2がサポートするデータ通信用アルゴリズム（公開鍵交換用とは別）
640                  cipher_mask = (1 << SSH_CIPHER_3DES_CBC)                  cipher_mask = (1 << SSH2_CIPHER_3DES_CBC)
641                              | (1 << SSH_CIPHER_AES128)                              | (1 << SSH2_CIPHER_AES128)
642  #ifdef SSH2_BLOWFISH                              | (1 << SSH2_CIPHER_BLOWFISH)
643                              | (1 << SSH_CIPHER_BLOWFISH)                              | (1 << SSH2_CIPHER_AES192)
644  #endif                              | (1 << SSH2_CIPHER_AES256);
                             | (1 << SSH_CIPHER_AES192)  
                             | (1 << SSH_CIPHER_AES256);  
645          }          }
646    
647          sender_ciphers &= cipher_mask;          sender_ciphers &= cipher_mask;
# Line 1050  BOOL CRYPT_start_encryption(PTInstVar pv Line 1088  BOOL CRYPT_start_encryption(PTInstVar pv
1088          if (sender_flag) {          if (sender_flag) {
1089                  switch (pvar->crypt_state.sender_cipher) {                  switch (pvar->crypt_state.sender_cipher) {
1090                          // for SSH2(yutaka)                          // for SSH2(yutaka)
1091                  case SSH_CIPHER_3DES_CBC:                  case SSH2_CIPHER_3DES_CBC:
1092                          {                          {
1093                                  struct Enc *enc;                                  struct Enc *enc;
1094    
# Line 1070  BOOL CRYPT_start_encryption(PTInstVar pv Line 1108  BOOL CRYPT_start_encryption(PTInstVar pv
1108                          }                          }
1109    
1110                          // for SSH2(yutaka)                          // for SSH2(yutaka)
1111                  case SSH_CIPHER_AES128:                  case SSH2_CIPHER_AES128:
1112                  case SSH_CIPHER_AES192:                  case SSH2_CIPHER_AES192:
1113                  case SSH_CIPHER_AES256:                  case SSH2_CIPHER_AES256:
1114                          {                          {
1115                                  struct Enc *enc;                                  struct Enc *enc;
1116    
# Line 1091  BOOL CRYPT_start_encryption(PTInstVar pv Line 1129  BOOL CRYPT_start_encryption(PTInstVar pv
1129                                  break;                                  break;
1130                          }                          }
1131    
1132                    case SSH2_CIPHER_BLOWFISH:
1133                            {
1134                                    struct Enc *enc;
1135    
1136                                    enc = &pvar->ssh2_keys[MODE_OUT].enc;
1137                                    cipher_init_SSH2(&pvar->evpcip[MODE_OUT],
1138                                                     enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher),
1139                                                     enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher),
1140                                                     CIPHER_ENCRYPT,
1141                                                     get_cipher_EVP_CIPHER(pvar->crypt_state.sender_cipher),
1142                                                     pvar);
1143    
1144                                    //debug_print(10, enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher));
1145                                    //debug_print(11, enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher));
1146    
1147                                    pvar->crypt_state.encrypt = cBlowfish_encrypt2;
1148                                    break;
1149                            }
1150    
1151                  case SSH_CIPHER_3DES:{                  case SSH_CIPHER_3DES:{
1152                                  c3DES_init(encryption_key, &pvar->crypt_state.enc.c3DES);                                  c3DES_init(encryption_key, &pvar->crypt_state.enc.c3DES);
1153                                  pvar->crypt_state.encrypt = c3DES_encrypt;                                  pvar->crypt_state.encrypt = c3DES_encrypt;
# Line 1127  BOOL CRYPT_start_encryption(PTInstVar pv Line 1184  BOOL CRYPT_start_encryption(PTInstVar pv
1184          if (receiver_flag) {          if (receiver_flag) {
1185                  switch (pvar->crypt_state.receiver_cipher) {                  switch (pvar->crypt_state.receiver_cipher) {
1186                          // for SSH2(yutaka)                          // for SSH2(yutaka)
1187                  case SSH_CIPHER_3DES_CBC:                  case SSH2_CIPHER_3DES_CBC:
1188                          {                          {
1189                                  struct Enc *enc;                                  struct Enc *enc;
1190    
# Line 1139  BOOL CRYPT_start_encryption(PTInstVar pv Line 1196  BOOL CRYPT_start_encryption(PTInstVar pv
1196                                                   get_cipher_EVP_CIPHER(pvar->crypt_state.sender_cipher),                                                   get_cipher_EVP_CIPHER(pvar->crypt_state.sender_cipher),
1197                                                   pvar);                                                   pvar);
1198    
1199                                  //debug_print(12, enc->key, 24);                                  //debug_print(12, enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher));
1200                                  //debug_print(13, enc->iv, 24);                                  //debug_print(13, enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher));
1201    
1202                                  pvar->crypt_state.decrypt = c3DES_CBC_decrypt;                                  pvar->crypt_state.decrypt = c3DES_CBC_decrypt;
1203                                  break;                                  break;
1204                          }                          }
1205    
1206                          // for SSH2(yutaka)                          // for SSH2(yutaka)
1207                  case SSH_CIPHER_AES128:                  case SSH2_CIPHER_AES128:
1208                  case SSH_CIPHER_AES192:                  case SSH2_CIPHER_AES192:
1209                  case SSH_CIPHER_AES256:                  case SSH2_CIPHER_AES256:
1210                          {                          {
1211                                  struct Enc *enc;                                  struct Enc *enc;
1212    
# Line 1161  BOOL CRYPT_start_encryption(PTInstVar pv Line 1218  BOOL CRYPT_start_encryption(PTInstVar pv
1218                                                   get_cipher_EVP_CIPHER(pvar->crypt_state.sender_cipher),                                                   get_cipher_EVP_CIPHER(pvar->crypt_state.sender_cipher),
1219                                                   pvar);                                                   pvar);
1220    
1221                                  //debug_print(12, enc->key, 24);                                  //debug_print(12, enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher));
1222                                  //debug_print(13, enc->iv, 24);                                  //debug_print(13, enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher));
1223    
1224                                  pvar->crypt_state.decrypt = cAES128_decrypt;                                  pvar->crypt_state.decrypt = cAES128_decrypt;
1225                                  break;                                  break;
1226                          }                          }
1227    
1228                    case SSH2_CIPHER_BLOWFISH:
1229                            {
1230                                    struct Enc *enc;
1231    
1232                                    enc = &pvar->ssh2_keys[MODE_IN].enc;
1233                                    cipher_init_SSH2(&pvar->evpcip[MODE_IN],
1234                                                     enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher),
1235                                                     enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher),
1236                                                     CIPHER_DECRYPT,
1237                                                     get_cipher_EVP_CIPHER(pvar->crypt_state.sender_cipher),
1238                                                     pvar);
1239    
1240                                    //debug_print(12, enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher));
1241                                    //debug_print(13, enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher));
1242    
1243                                    pvar->crypt_state.decrypt = cBlowfish_decrypt2;
1244                                    break;
1245                            }
1246    
1247                  case SSH_CIPHER_3DES:{                  case SSH_CIPHER_3DES:{
1248                                  c3DES_init(decryption_key, &pvar->crypt_state.dec.c3DES);                                  c3DES_init(decryption_key, &pvar->crypt_state.dec.c3DES);
1249                                  pvar->crypt_state.decrypt = c3DES_decrypt;                                  pvar->crypt_state.decrypt = c3DES_decrypt;
# Line 1243  static char FAR *get_cipher_name(int cip Line 1319  static char FAR *get_cipher_name(int cip
1319                  return "Blowfish (256 key bits)";                  return "Blowfish (256 key bits)";
1320    
1321          // SSH2          // SSH2
1322          case SSH_CIPHER_3DES_CBC:          case SSH2_CIPHER_3DES_CBC:
1323                  return "3DES-CBC";                  return "3DES-CBC";
1324          case SSH_CIPHER_AES128:          case SSH2_CIPHER_AES128:
1325                  return "AES128";                  return "AES128";
1326          case SSH_CIPHER_AES192:          case SSH2_CIPHER_AES192:
1327                  return "AES192";                  return "AES192";
1328          case SSH_CIPHER_AES256:          case SSH2_CIPHER_AES256:
1329                  return "AES256";                  return "AES256";
1330            case SSH2_CIPHER_BLOWFISH:
1331                    return "Blowfish";
1332    
1333          default:          default:
1334                  return "Unknown";                  return "Unknown";
Legend:
Removed from v.3043  
changed lines
  Added in v.3045
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help