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 6714 by doda, Fri May 12 12:41:49 2017 UTC revision 6716 by doda, Fri May 12 12:42:01 2017 UTC
# Line 72  SOFTWARE, EVEN IF ADVISED OF THE POSSIBI Line 72  SOFTWARE, EVEN IF ADVISED OF THE POSSIBI
72  #define CMP(a,b) memcmp(a, b, SSH_BLOCKSIZE)  #define CMP(a,b) memcmp(a, b, SSH_BLOCKSIZE)
73    
74    
75    static char FAR *get_cipher_name(int cipher);
76    
77  static void crc_update(uint32 FAR * a, uint32 b)  static void crc_update(uint32 FAR * a, uint32 b)
78  {  {
# Line 207  static void no_encrypt(PTInstVar pvar, u Line 208  static void no_encrypt(PTInstVar pvar, u
208  {  {
209  }  }
210    
211    static void crypt_SSH2_encrypt(PTInstVar pvar, unsigned char FAR * buf, int bytes)
 // for SSH2(yutaka)  
 // 事前に設定する鍵長が違うだけなので、AES192, AES256 でも  
 // cAES128_encrypt/cAES128_decrypt を使用できる (2007.10.16 maya)  
 static void cAES128_encrypt(PTInstVar pvar, unsigned char FAR * buf,  
                             int bytes)  
 {  
         unsigned char *newbuf = malloc(bytes);  
         int block_size = pvar->ssh2_keys[MODE_OUT].enc.block_size;  
         char tmp[80];  
   
         // 事前復号化により、全ペイロードが復号化されている場合は、0バイトになる。(2004.11.7 yutaka)  
         if (bytes == 0)  
                 goto error;  
   
         if (newbuf == NULL)  
                 return;  
   
         if (bytes % block_size) {  
                 UTIL_get_lang_msg("MSG_ENCRYPT_ERROR1", pvar,  
                                   "%s encrypt error(1): bytes %d (%d)");  
                 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,  
                             "AES128/192/256", bytes, block_size);  
                 notify_fatal_error(pvar, tmp, TRUE);  
                 goto error;  
         }  
   
         if (EVP_Cipher(&pvar->evpcip[MODE_OUT], newbuf, buf, bytes) == 0) {  
                 UTIL_get_lang_msg("MSG_ENCRYPT_ERROR2", pvar, "%s encrypt error(2)");  
                 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,  
                             "AES128/192/256");  
                 notify_fatal_error(pvar, tmp, TRUE);  
                 goto error;  
   
         } else {  
                 //unsigned char key[AES128_KEYLEN], iv[AES128_IVLEN];  
                 //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);  
   
                 memcpy(buf, newbuf, bytes);  
         }  
   
 error:  
         free(newbuf);  
 }  
   
 static void cAES128_decrypt(PTInstVar pvar, unsigned char FAR * buf,  
                             int bytes)  
 {  
         unsigned char *newbuf = malloc(bytes);  
         int block_size = pvar->ssh2_keys[MODE_IN].enc.block_size;  
         char tmp[80];  
   
         // 事前復号化により、全ペイロードが復号化されている場合は、0バイトになる。(2004.11.7 yutaka)  
         if (bytes == 0)  
                 goto error;  
   
         if (newbuf == NULL)  
                 return;  
   
         if (bytes % block_size) {  
                 UTIL_get_lang_msg("MSG_DECRYPT_ERROR1", pvar,  
                                   "%s decrypt error(1): bytes %d (%d)");  
                 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,  
                             "AES128/192/256", bytes, block_size);  
                 notify_fatal_error(pvar, tmp, TRUE);  
                 goto error;  
         }  
   
         if (EVP_Cipher(&pvar->evpcip[MODE_IN], newbuf, buf, bytes) == 0) {  
                 UTIL_get_lang_msg("MSG_DECRYPT_ERROR2", pvar, "%s decrypt error(2)");  
                 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,  
                             "AES128/192/256");  
                 notify_fatal_error(pvar, tmp, TRUE);  
                 goto error;  
   
         } else {  
                 //unsigned char key[AES128_KEYLEN], iv[AES128_IVLEN];  
                 //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);  
   
                 memcpy(buf, newbuf, bytes);  
         }  
   
 error:  
         free(newbuf);  
 }  
   
   
 // for SSH2(yutaka)  
 static void c3DES_encrypt2(PTInstVar pvar, unsigned char FAR * buf,  
                            int bytes)  
 {  
         unsigned char *newbuf = malloc(bytes);  
         int block_size = pvar->ssh2_keys[MODE_OUT].enc.block_size;  
         char tmp[80];  
   
         // 事前復号化により、全ペイロードが復号化されている場合は、0バイトになる。(2004.11.7 yutaka)  
         if (bytes == 0)  
                 goto error;  
   
         if (newbuf == NULL)  
                 return;  
   
         if (bytes % block_size) {  
                 UTIL_get_lang_msg("MSG_ENCRYPT_ERROR1", pvar,  
                                   "%s encrypt error(1): bytes %d (%d)");  
                 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,  
                             "3DES-CBC", bytes, block_size);  
                 notify_fatal_error(pvar, tmp, TRUE);  
                 goto error;  
         }  
   
         if (EVP_Cipher(&pvar->evpcip[MODE_OUT], newbuf, buf, bytes) == 0) {  
                 UTIL_get_lang_msg("MSG_ENCRYPT_ERROR2", pvar, "%s encrypt error(2)");  
                 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,  
                             "3DES-CBC");  
                 notify_fatal_error(pvar, tmp, TRUE);  
                 goto error;  
   
         } else {  
                 //unsigned char key[24], iv[8];  
                 //memcpy(key, pvar->ssh2_keys[MODE_OUT].enc.key, 24);  
                 // IVはDES関数内で更新されるため、ローカルにコピーしてから使う。  
                 //memcpy(iv, pvar->ssh2_keys[MODE_OUT].enc.iv, 8);  
                   
                 //debug_print(50, key, 24);  
                 //debug_print(51, iv, 8);  
                 //debug_print(52, buf, bytes);  
                 //debug_print(53, newbuf, bytes);  
   
                 memcpy(buf, newbuf, bytes);  
         }  
   
 error:  
         free(newbuf);  
 }  
   
 static void c3DES_decrypt2(PTInstVar pvar, unsigned char FAR * buf,  
                            int bytes)  
 {  
         unsigned char *newbuf = malloc(bytes);  
         int block_size = pvar->ssh2_keys[MODE_IN].enc.block_size;  
         char tmp[80];  
   
         // 事前復号化により、全ペイロードが復号化されている場合は、0バイトになる。(2004.11.7 yutaka)  
         if (bytes == 0)  
                 goto error;  
   
         if (newbuf == NULL)  
                 return;  
   
         if (bytes % block_size) {  
                 UTIL_get_lang_msg("MSG_DECRYPT_ERROR1", pvar,  
                                   "%s decrypt error(1): bytes %d (%d)");  
                 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,  
                             "3DES-CBC", bytes, block_size);  
                 notify_fatal_error(pvar, tmp, TRUE);  
                 goto error;  
         }  
   
         if (EVP_Cipher(&pvar->evpcip[MODE_IN], newbuf, buf, bytes) == 0) {  
                 UTIL_get_lang_msg("MSG_DECRYPT_ERROR2", pvar, "%s decrypt error(2)");  
                 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,  
                             "3DES-CBC");  
                 notify_fatal_error(pvar, tmp, TRUE);  
                 goto error;  
   
         } else {  
                 //unsigned char key[24], iv[8];  
                 //memcpy(key, pvar->ssh2_keys[MODE_IN].enc.key, 24);  
                 // IVはDES関数内で更新されるため、ローカルにコピーしてから使う。  
                 //memcpy(iv, pvar->ssh2_keys[MODE_IN].enc.iv, 8);  
                   
                 //debug_print(70, key, 24);  
                 //debug_print(71, iv, 8);  
                 //debug_print(72, buf, bytes);  
                 //debug_print(73, newbuf, bytes);  
   
                 memcpy(buf, newbuf, bytes);  
         }  
   
 error:  
         free(newbuf);  
 }  
   
   
 static void cBlowfish_encrypt2(PTInstVar pvar, unsigned char FAR * buf,  
                                int bytes)  
 {  
         unsigned char *newbuf = malloc(bytes);  
         int block_size = pvar->ssh2_keys[MODE_OUT].enc.block_size;  
         char tmp[80];  
   
         // 事前復号化により、全ペイロードが復号化されている場合は、0バイトになる。(2004.11.7 yutaka)  
         if (bytes == 0)  
                 goto error;  
   
         if (newbuf == NULL)  
                 return;  
   
         if (bytes % block_size) {  
                 UTIL_get_lang_msg("MSG_ENCRYPT_ERROR1", pvar,  
                                   "%s encrypt error(1): bytes %d (%d)");  
                 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,  
                             "Blowfish", bytes, block_size);  
                 notify_fatal_error(pvar, tmp, TRUE);  
                 goto error;  
         }  
   
         if (EVP_Cipher(&pvar->evpcip[MODE_OUT], newbuf, buf, bytes) == 0) {  
                 UTIL_get_lang_msg("MSG_ENCRYPT_ERROR2", pvar, "%s encrypt error(2)");  
                 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,  
                             "Blowfish");  
                 notify_fatal_error(pvar, tmp, TRUE);  
                 goto error;  
   
         } else {  
                 memcpy(buf, newbuf, bytes);  
   
         }  
   
 error:  
         free(newbuf);  
 }  
   
 static void cBlowfish_decrypt2(PTInstVar pvar, unsigned char FAR * buf,  
                                int bytes)  
 {  
         unsigned char *newbuf = malloc(bytes);  
         int block_size = pvar->ssh2_keys[MODE_IN].enc.block_size;  
         char tmp[80];  
   
         // 事前復号化により、全ペイロードが復号化されている場合は、0バイトになる。(2004.11.7 yutaka)  
         if (bytes == 0)  
                 goto error;  
   
         if (newbuf == NULL)  
                 return;  
   
         if (bytes % block_size) {  
                 UTIL_get_lang_msg("MSG_DECRYPT_ERROR1", pvar,  
                                   "%s decrypt error(1): bytes %d (%d)");  
                 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,  
                             "Blowfish", bytes, block_size);  
                 notify_fatal_error(pvar, tmp, TRUE);  
                 goto error;  
         }  
   
         if (EVP_Cipher(&pvar->evpcip[MODE_IN], newbuf, buf, bytes) == 0) {  
                 UTIL_get_lang_msg("MSG_DECRYPT_ERROR2", pvar, "%s decrypt error(2)");  
                 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,  
                             "Blowfish");  
                 notify_fatal_error(pvar, tmp, TRUE);  
                 goto error;  
   
         } else {  
                 memcpy(buf, newbuf, bytes);  
   
         }  
   
 error:  
         free(newbuf);  
 }  
   
   
 static void cArcfour_encrypt(PTInstVar pvar, unsigned char FAR * buf,  
                              int bytes)  
212  {  {
213          unsigned char *newbuf = malloc(bytes);          unsigned char *newbuf;
214          int block_size = pvar->ssh2_keys[MODE_OUT].enc.block_size;          int block_size = pvar->ssh2_keys[MODE_OUT].enc.block_size;
215          char tmp[80];          char tmp[80];
216    
         // 事前復号化により、全ペイロードが復号化されている場合は、0バイトになる。(2004.11.7 yutaka)  
217          if (bytes == 0)          if (bytes == 0)
                 goto error;  
   
         if (newbuf == NULL)  
218                  return;                  return;
219    
220          if (bytes % block_size) {          if (bytes % block_size) {
221                  UTIL_get_lang_msg("MSG_ENCRYPT_ERROR1", pvar,                  UTIL_get_lang_msg("MSG_ENCRYPT_ERROR1", pvar,
222                                    "%s encrypt error(1): bytes %d (%d)");                                    "%s encrypt error(1): bytes %d (%d)");
223                  _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,                  _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
224                              "Arcfour", bytes, block_size);                              get_cipher_name(pvar->crypt_state.sender_cipher),
225                  notify_fatal_error(pvar, tmp, TRUE);                              bytes, block_size);
                 goto error;  
         }  
   
         if (EVP_Cipher(&pvar->evpcip[MODE_OUT], newbuf, buf, bytes) == 0) {  
                 UTIL_get_lang_msg("MSG_ENCRYPT_ERROR2", pvar, "%s encrypt error(2)");  
                 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,  
                             "Arcfour");  
226                  notify_fatal_error(pvar, tmp, TRUE);                  notify_fatal_error(pvar, tmp, TRUE);
                 goto error;  
   
         } else {  
                 memcpy(buf, newbuf, bytes);  
   
         }  
   
 error:  
         free(newbuf);  
 }  
   
 static void cArcfour_decrypt(PTInstVar pvar, unsigned char FAR * buf,  
                              int bytes)  
 {  
         unsigned char *newbuf = malloc(bytes);  
         int block_size = pvar->ssh2_keys[MODE_IN].enc.block_size;  
         char tmp[80];  
   
         // 事前復号化により、全ペイロードが復号化されている場合は、0バイトになる。(2004.11.7 yutaka)  
         if (bytes == 0)  
                 goto error;  
   
         if (newbuf == NULL)  
227                  return;                  return;
   
         if (bytes % block_size) {  
                 UTIL_get_lang_msg("MSG_DECRYPT_ERROR1", pvar,  
                                   "%s decrypt error(1): bytes %d (%d)");  
                 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,  
                             "Arcfour", bytes, block_size);  
                 notify_fatal_error(pvar, tmp, TRUE);  
                 goto error;  
         }  
   
         if (EVP_Cipher(&pvar->evpcip[MODE_IN], newbuf, buf, bytes) == 0) {  
                 UTIL_get_lang_msg("MSG_DECRYPT_ERROR2", pvar, "%s decrypt error(2)");  
                 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,  
                             "Arcfour");  
                 notify_fatal_error(pvar, tmp, TRUE);  
                 goto error;  
   
         } else {  
                 memcpy(buf, newbuf, bytes);  
   
228          }          }
229    
230  error:          if ((newbuf = malloc(bytes)) == NULL)
         free(newbuf);  
 }  
   
   
 static void cCast128_encrypt(PTInstVar pvar, unsigned char FAR * buf,  
                              int bytes)  
 {  
         unsigned char *newbuf = malloc(bytes);  
         int block_size = pvar->ssh2_keys[MODE_OUT].enc.block_size;  
         char tmp[80];  
   
         // 事前復号化により、全ペイロードが復号化されている場合は、0バイトになる。(2004.11.7 yutaka)  
         if (bytes == 0)  
                 goto error;  
   
         if (newbuf == NULL)  
231                  return;                  return;
232    
         if (bytes % block_size) {  
                 UTIL_get_lang_msg("MSG_ENCRYPT_ERROR1", pvar,  
                                   "%s encrypt error(1): bytes %d (%d)");  
                 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,  
                             "CAST128", bytes, block_size);  
                 notify_fatal_error(pvar, tmp, TRUE);  
                 goto error;  
         }  
   
233          if (EVP_Cipher(&pvar->evpcip[MODE_OUT], newbuf, buf, bytes) == 0) {          if (EVP_Cipher(&pvar->evpcip[MODE_OUT], newbuf, buf, bytes) == 0) {
234                  UTIL_get_lang_msg("MSG_ENCRYPT_ERROR2", pvar, "%s encrypt error(2)");                  UTIL_get_lang_msg("MSG_ENCRYPT_ERROR2", pvar, "%s encrypt error(2)");
235                  _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,                  _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
236                              "CAST128");                              get_cipher_name(pvar->crypt_state.sender_cipher));
237                  notify_fatal_error(pvar, tmp, TRUE);                  notify_fatal_error(pvar, tmp, TRUE);
                 goto error;  
   
238          } else {          } else {
239                  memcpy(buf, newbuf, bytes);                  memcpy(buf, newbuf, bytes);
   
240          }          }
241    
 error:  
242          free(newbuf);          free(newbuf);
243  }  }
244    
245  static void cCast128_decrypt(PTInstVar pvar, unsigned char FAR * buf,  static void crypt_SSH2_decrypt(PTInstVar pvar, unsigned char FAR * buf, int bytes)
                              int bytes)  
246  {  {
247          unsigned char *newbuf = malloc(bytes);          unsigned char *newbuf;
248          int block_size = pvar->ssh2_keys[MODE_IN].enc.block_size;          int block_size = pvar->ssh2_keys[MODE_IN].enc.block_size;
249          char tmp[80];          char tmp[80];
250    
         // 事前復号化により、全ペイロードが復号化されている場合は、0バイトになる。(2004.11.7 yutaka)  
251          if (bytes == 0)          if (bytes == 0)
                 goto error;  
   
         if (newbuf == NULL)  
252                  return;                  return;
253    
254          if (bytes % block_size) {          if (bytes % block_size) {
255                  UTIL_get_lang_msg("MSG_DECRYPT_ERROR1", pvar,                  UTIL_get_lang_msg("MSG_DECRYPT_ERROR1", pvar,
256                                    "%s decrypt error(1): bytes %d (%d)");                                    "%s decrypt error(1): bytes %d (%d)");
257                  _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,                  _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
258                              "CAST128", bytes, block_size);                              get_cipher_name(pvar->crypt_state.receiver_cipher),
259                                bytes, block_size);
260                  notify_fatal_error(pvar, tmp, TRUE);                  notify_fatal_error(pvar, tmp, TRUE);
                 goto error;  
         }  
   
         if (EVP_Cipher(&pvar->evpcip[MODE_IN], newbuf, buf, bytes) == 0) {  
                 UTIL_get_lang_msg("MSG_DECRYPT_ERROR2", pvar, "%s decrypt error(2)");  
                 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,  
                             "CAST128");  
                 notify_fatal_error(pvar, tmp, TRUE);  
                 goto error;  
   
         } else {  
                 memcpy(buf, newbuf, bytes);  
   
         }  
   
 error:  
         free(newbuf);  
 }  
   
 static void cCamellia_encrypt(PTInstVar pvar, unsigned char FAR * buf,  
                              int bytes)  
 {  
         unsigned char *newbuf = malloc(bytes);  
         int block_size = pvar->ssh2_keys[MODE_OUT].enc.block_size;  
         char tmp[80];  
   
         // 事前復号化により、全ペイロードが復号化されている場合は、0バイトになる。(2004.11.7 yutaka)  
         if (bytes == 0)  
                 goto error;  
   
         if (newbuf == NULL)  
261                  return;                  return;
   
         if (bytes % block_size) {  
                 UTIL_get_lang_msg("MSG_ENCRYPT_ERROR1", pvar,  
                                   "%s encrypt error(1): bytes %d (%d)");  
                 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,  
                             "Camellia128/192/256", bytes, block_size);  
                 notify_fatal_error(pvar, tmp, TRUE);  
                 goto error;  
262          }          }
263    
264          if (EVP_Cipher(&pvar->evpcip[MODE_OUT], newbuf, buf, bytes) == 0) {          if ((newbuf = malloc(bytes)) == NULL)
                 UTIL_get_lang_msg("MSG_ENCRYPT_ERROR2", pvar, "%s encrypt error(2)");  
                 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,  
                             "Camellia128/192/256");  
                 notify_fatal_error(pvar, tmp, TRUE);  
                 goto error;  
   
         } else {  
                 memcpy(buf, newbuf, bytes);  
   
         }  
   
 error:  
         free(newbuf);  
 }  
   
 static void cCamellia_decrypt(PTInstVar pvar, unsigned char FAR * buf,  
                              int bytes)  
 {  
         unsigned char *newbuf = malloc(bytes);  
         int block_size = pvar->ssh2_keys[MODE_IN].enc.block_size;  
         char tmp[80];  
   
         // 事前復号化により、全ペイロードが復号化されている場合は、0バイトになる。(2004.11.7 yutaka)  
         if (bytes == 0)  
                 goto error;  
   
         if (newbuf == NULL)  
265                  return;                  return;
266    
         if (bytes % block_size) {  
                 UTIL_get_lang_msg("MSG_DECRYPT_ERROR1", pvar,  
                                   "%s decrypt error(1): bytes %d (%d)");  
                 _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,  
                             "Camellia128/192/256", bytes, block_size);  
                 notify_fatal_error(pvar, tmp, TRUE);  
                 goto error;  
         }  
   
267          if (EVP_Cipher(&pvar->evpcip[MODE_IN], newbuf, buf, bytes) == 0) {          if (EVP_Cipher(&pvar->evpcip[MODE_IN], newbuf, buf, bytes) == 0) {
268                  UTIL_get_lang_msg("MSG_DECRYPT_ERROR2", pvar, "%s decrypt error(2)");                  UTIL_get_lang_msg("MSG_DECRYPT_ERROR2", pvar, "%s decrypt error(2)");
269                  _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,                  _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
270                              "Camellia128/192/256");                              get_cipher_name(pvar->crypt_state.receiver_cipher));
271                  notify_fatal_error(pvar, tmp, TRUE);                  notify_fatal_error(pvar, tmp, TRUE);
                 goto error;  
   
272          } else {          } else {
273                  memcpy(buf, newbuf, bytes);                  memcpy(buf, newbuf, bytes);
   
274          }          }
275    
 error:  
276          free(newbuf);          free(newbuf);
277  }  }
278    
279  static void c3DES_encrypt(PTInstVar pvar, unsigned char FAR * buf,  static void c3DES_encrypt(PTInstVar pvar, unsigned char FAR * buf, int bytes)
                           int bytes)  
280  {  {
281          Cipher3DESState FAR *encryptstate = &pvar->crypt_state.enc.c3DES;          Cipher3DESState FAR *encryptstate = &pvar->crypt_state.enc.c3DES;
282    
# Line 733  static void c3DES_encrypt(PTInstVar pvar Line 288  static void c3DES_encrypt(PTInstVar pvar
288                           &encryptstate->k3, &encryptstate->ivec3, DES_ENCRYPT);                           &encryptstate->k3, &encryptstate->ivec3, DES_ENCRYPT);
289  }  }
290    
291  static void c3DES_decrypt(PTInstVar pvar, unsigned char FAR * buf,  static void c3DES_decrypt(PTInstVar pvar, unsigned char FAR * buf, int bytes)
                           int bytes)  
292  {  {
293          Cipher3DESState FAR *decryptstate = &pvar->crypt_state.dec.c3DES;          Cipher3DESState FAR *decryptstate = &pvar->crypt_state.dec.c3DES;
294    
# Line 746  static void c3DES_decrypt(PTInstVar pvar Line 300  static void c3DES_decrypt(PTInstVar pvar
300                           &decryptstate->k1, &decryptstate->ivec1, DES_DECRYPT);                           &decryptstate->k1, &decryptstate->ivec1, DES_DECRYPT);
301  }  }
302    
303  static void cDES_encrypt(PTInstVar pvar, unsigned char FAR * buf,  static void cDES_encrypt(PTInstVar pvar, unsigned char FAR * buf, int bytes)
                                                  int bytes)  
304  {  {
305          CipherDESState FAR *encryptstate = &pvar->crypt_state.enc.cDES;          CipherDESState FAR *encryptstate = &pvar->crypt_state.enc.cDES;
306    
# Line 755  static void cDES_encrypt(PTInstVar pvar, Line 308  static void cDES_encrypt(PTInstVar pvar,
308                           &encryptstate->k, &encryptstate->ivec, DES_ENCRYPT);                           &encryptstate->k, &encryptstate->ivec, DES_ENCRYPT);
309  }  }
310    
311  static void cDES_decrypt(PTInstVar pvar, unsigned char FAR * buf,  static void cDES_decrypt(PTInstVar pvar, unsigned char FAR * buf, int bytes)
                                                  int bytes)  
312  {  {
313          CipherDESState FAR *decryptstate = &pvar->crypt_state.dec.cDES;          CipherDESState FAR *decryptstate = &pvar->crypt_state.dec.cDES;
314    
# Line 779  static void flip_endianness(unsigned cha Line 331  static void flip_endianness(unsigned cha
331          }          }
332  }  }
333    
334  static void cBlowfish_encrypt(PTInstVar pvar, unsigned char FAR * buf,  static void cBlowfish_encrypt(PTInstVar pvar, unsigned char FAR * buf, int bytes)
                               int bytes)  
335  {  {
336          CipherBlowfishState FAR *encryptstate =          CipherBlowfishState FAR *encryptstate =
337                  &pvar->crypt_state.enc.cBlowfish;                  &pvar->crypt_state.enc.cBlowfish;
# Line 791  static void cBlowfish_encrypt(PTInstVar Line 342  static void cBlowfish_encrypt(PTInstVar
342          flip_endianness(buf, bytes);          flip_endianness(buf, bytes);
343  }  }
344    
345  static void cBlowfish_decrypt(PTInstVar pvar, unsigned char FAR * buf,  static void cBlowfish_decrypt(PTInstVar pvar, unsigned char FAR * buf, int bytes)
                               int bytes)  
346  {  {
347          CipherBlowfishState FAR *decryptstate =          CipherBlowfishState FAR *decryptstate =
348                  &pvar->crypt_state.dec.cBlowfish;                  &pvar->crypt_state.dec.cBlowfish;
# Line 803  static void cBlowfish_decrypt(PTInstVar Line 353  static void cBlowfish_decrypt(PTInstVar
353          flip_endianness(buf, bytes);          flip_endianness(buf, bytes);
354  }  }
355    
356  void CRYPT_set_random_data(PTInstVar pvar, unsigned char FAR * buf,  void CRYPT_set_random_data(PTInstVar pvar, unsigned char FAR * buf, int bytes)
                            int bytes)  
357  {  {
358          RAND_bytes(buf, bytes);          RAND_bytes(buf, bytes);
359  }  }
# Line 1321  static void cBlowfish_init(char FAR * se Line 870  static void cBlowfish_init(char FAR * se
870  //  //
871  // SSH2用アルゴリズムの初期化  // SSH2用アルゴリズムの初期化
872  //  //
 // for SSH2(yutaka)  
 //  
873  void cipher_init_SSH2(EVP_CIPHER_CTX *evp,  void cipher_init_SSH2(EVP_CIPHER_CTX *evp,
874                        const u_char *key, u_int keylen,                        const u_char *key, u_int keylen,
875                        const u_char *iv, u_int ivlen,                        const u_char *iv, u_int ivlen,
# Line 1392  void cipher_cleanup_SSH2(EVP_CIPHER_CTX Line 939  void cipher_cleanup_SSH2(EVP_CIPHER_CTX
939    
940  BOOL CRYPT_start_encryption(PTInstVar pvar, int sender_flag, int receiver_flag)  BOOL CRYPT_start_encryption(PTInstVar pvar, int sender_flag, int receiver_flag)
941  {  {
942            struct Enc *enc;
943          char FAR *encryption_key = pvar->crypt_state.sender_cipher_key;          char FAR *encryption_key = pvar->crypt_state.sender_cipher_key;
944          char FAR *decryption_key = pvar->crypt_state.receiver_cipher_key;          char FAR *decryption_key = pvar->crypt_state.receiver_cipher_key;
945            int cipher;
946          BOOL isOK = TRUE;          BOOL isOK = TRUE;
947    
948          if (sender_flag) {          if (sender_flag) {
949                  switch (pvar->crypt_state.sender_cipher) {                  cipher = pvar->crypt_state.sender_cipher;
950                          // for SSH2(yutaka)                  switch (cipher) {
951                  case SSH2_CIPHER_3DES_CBC:                  case SSH_CIPHER_3DES:
952                  case SSH2_CIPHER_3DES_CTR:                          c3DES_init(encryption_key, &pvar->crypt_state.enc.c3DES);
953                          {                          pvar->crypt_state.encrypt = c3DES_encrypt;
954                                  struct Enc *enc;                          break;
   
                                 enc = &pvar->ssh2_keys[MODE_OUT].enc;  
                                 cipher_init_SSH2(&pvar->evpcip[MODE_OUT],  
                                                  enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher),  
                                                  enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher),  
                                                  CIPHER_ENCRYPT,  
                                                  get_cipher_EVP_CIPHER(pvar->crypt_state.sender_cipher),  
                                                  get_cipher_discard_len(pvar->crypt_state.sender_cipher),  
                                                  pvar);  
   
                                 //debug_print(10, enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher));  
                                 //debug_print(11, enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher));  
   
                                 pvar->crypt_state.encrypt = c3DES_encrypt2;  
                                 break;  
                         }  
   
                         // for SSH2(yutaka)  
                 case SSH2_CIPHER_AES128_CBC:  
                 case SSH2_CIPHER_AES192_CBC:  
                 case SSH2_CIPHER_AES256_CBC:  
                 case SSH2_CIPHER_AES128_CTR:  
                 case SSH2_CIPHER_AES192_CTR:  
                 case SSH2_CIPHER_AES256_CTR:  
                         {  
                                 struct Enc *enc;  
   
                                 enc = &pvar->ssh2_keys[MODE_OUT].enc;  
                                 cipher_init_SSH2(&pvar->evpcip[MODE_OUT],  
                                                  enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher),  
                                                  enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher),  
                                                  CIPHER_ENCRYPT,  
                                                  get_cipher_EVP_CIPHER(pvar->crypt_state.sender_cipher),  
                                                  get_cipher_discard_len(pvar->crypt_state.sender_cipher),  
                                                  pvar);  
   
                                 //debug_print(10, enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher));  
                                 //debug_print(11, enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher));  
   
                                 pvar->crypt_state.encrypt = cAES128_encrypt;  
                                 break;  
                         }  
   
                 case SSH2_CIPHER_BLOWFISH_CBC:  
                 case SSH2_CIPHER_BLOWFISH_CTR:  
                         {  
                                 struct Enc *enc;  
   
                                 enc = &pvar->ssh2_keys[MODE_OUT].enc;  
                                 cipher_init_SSH2(&pvar->evpcip[MODE_OUT],  
                                                  enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher),  
                                                  enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher),  
                                                  CIPHER_ENCRYPT,  
                                                  get_cipher_EVP_CIPHER(pvar->crypt_state.sender_cipher),  
                                                  get_cipher_discard_len(pvar->crypt_state.sender_cipher),  
                                                  pvar);  
   
                                 //debug_print(10, enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher));  
                                 //debug_print(11, enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher));  
   
                                 pvar->crypt_state.encrypt = cBlowfish_encrypt2;  
                                 break;  
                         }  
   
                 case SSH2_CIPHER_ARCFOUR:  
                 case SSH2_CIPHER_ARCFOUR128:  
                 case SSH2_CIPHER_ARCFOUR256:  
                         {  
                                 struct Enc *enc;  
   
                                 enc = &pvar->ssh2_keys[MODE_OUT].enc;  
                                 cipher_init_SSH2(&pvar->evpcip[MODE_OUT],  
                                                  enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher),  
                                                  enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher),  
                                                  CIPHER_ENCRYPT,  
                                                  get_cipher_EVP_CIPHER(pvar->crypt_state.sender_cipher),  
                                                  get_cipher_discard_len(pvar->crypt_state.sender_cipher),  
                                                  pvar);  
                                 //debug_print(10, enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher));  
                                 //debug_print(11, enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher));  
   
                                 pvar->crypt_state.encrypt = cArcfour_encrypt;  
                                 break;  
                         }  
   
                 case SSH2_CIPHER_CAST128_CBC:  
                 case SSH2_CIPHER_CAST128_CTR:  
                         {  
                                 struct Enc *enc;  
955    
956                                  enc = &pvar->ssh2_keys[MODE_OUT].enc;                  case SSH_CIPHER_DES:
957                                  cipher_init_SSH2(&pvar->evpcip[MODE_OUT],                          cDES_init(encryption_key, &pvar->crypt_state.enc.cDES);
958                                                   enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher),                          pvar->crypt_state.encrypt = cDES_encrypt;
959                                                   enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher),                          break;
                                                  CIPHER_ENCRYPT,  
                                                  get_cipher_EVP_CIPHER(pvar->crypt_state.sender_cipher),  
                                                  get_cipher_discard_len(pvar->crypt_state.sender_cipher),  
                                                  pvar);  
                                 //debug_print(10, enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher));  
                                 //debug_print(11, enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher));  
960    
961                                  pvar->crypt_state.encrypt = cCast128_encrypt;                  case SSH_CIPHER_BLOWFISH:
962                                  break;                          cBlowfish_init(encryption_key, &pvar->crypt_state.enc.cBlowfish);
963                          }                          pvar->crypt_state.encrypt = cBlowfish_encrypt;
964                            break;
965    
966                  case SSH2_CIPHER_CAMELLIA128_CBC:                  case SSH_CIPHER_NONE:
967                  case SSH2_CIPHER_CAMELLIA192_CBC:                  case SSH_CIPHER_IDEA:
968                  case SSH2_CIPHER_CAMELLIA256_CBC:                  case SSH_CIPHER_TSS:
969                  case SSH2_CIPHER_CAMELLIA128_CTR:                  case SSH_CIPHER_RC4:
970                  case SSH2_CIPHER_CAMELLIA192_CTR:                          isOK = FALSE;
971                  case SSH2_CIPHER_CAMELLIA256_CTR:                          break;
                         {  
                                 struct Enc *enc;  
972    
973                    default: // SSH2
974                            if (cipher <= SSH_CIPHER_MAX) {
975                                  enc = &pvar->ssh2_keys[MODE_OUT].enc;                                  enc = &pvar->ssh2_keys[MODE_OUT].enc;
976                                  cipher_init_SSH2(&pvar->evpcip[MODE_OUT],                                  cipher_init_SSH2(&pvar->evpcip[MODE_OUT],
977                                                   enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher),                                                   enc->key, get_cipher_key_len(cipher),
978                                                   enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher),                                                   enc->iv, get_cipher_block_size(cipher),
979                                                   CIPHER_ENCRYPT,                                                   CIPHER_ENCRYPT,
980                                                   get_cipher_EVP_CIPHER(pvar->crypt_state.sender_cipher),                                                   get_cipher_EVP_CIPHER(cipher),
981                                                   get_cipher_discard_len(pvar->crypt_state.sender_cipher),                                                   get_cipher_discard_len(cipher),
982                                                   pvar);                                                   pvar);
983    
984                                  //debug_print(10, enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher));                                  pvar->crypt_state.encrypt = crypt_SSH2_encrypt;
                                 //debug_print(11, enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher));  
   
                                 pvar->crypt_state.encrypt = cCamellia_encrypt;  
                                 break;  
                         }  
   
                 case SSH_CIPHER_3DES:{  
                                 c3DES_init(encryption_key, &pvar->crypt_state.enc.c3DES);  
                                 pvar->crypt_state.encrypt = c3DES_encrypt;  
                                 break;  
985                          }                          }
986                  case SSH_CIPHER_DES:{                          else {
987                                  cDES_init(encryption_key, &pvar->crypt_state.enc.cDES);                                  isOK = FALSE;
                                 pvar->crypt_state.encrypt = cDES_encrypt;  
                                 break;  
988                          }                          }
989                  case SSH_CIPHER_BLOWFISH:{                          break;
                                 cBlowfish_init(encryption_key,  
                                                &pvar->crypt_state.enc.cBlowfish);  
                                 pvar->crypt_state.encrypt = cBlowfish_encrypt;  
                                 break;  
                         }  
                 default:  
                         isOK = FALSE;  
990                  }                  }
991          }          }
992    
   
993          if (receiver_flag) {          if (receiver_flag) {
994                  switch (pvar->crypt_state.receiver_cipher) {                  cipher = pvar->crypt_state.receiver_cipher;
995                          // for SSH2(yutaka)                  switch (cipher) {
996                  case SSH2_CIPHER_3DES_CBC:                  case SSH_CIPHER_3DES:
997                  case SSH2_CIPHER_3DES_CTR:                          c3DES_init(decryption_key, &pvar->crypt_state.dec.c3DES);
998                          {                          pvar->crypt_state.decrypt = c3DES_decrypt;
999                                  struct Enc *enc;                          break;
   
                                 enc = &pvar->ssh2_keys[MODE_IN].enc;  
                                 cipher_init_SSH2(&pvar->evpcip[MODE_IN],  
                                                  enc->key, get_cipher_key_len(pvar->crypt_state.receiver_cipher),  
                                                  enc->iv, get_cipher_block_size(pvar->crypt_state.receiver_cipher),  
                                                  CIPHER_DECRYPT,  
                                                  get_cipher_EVP_CIPHER(pvar->crypt_state.receiver_cipher),  
                                                  get_cipher_discard_len(pvar->crypt_state.receiver_cipher),  
                                                  pvar);  
   
                                 //debug_print(12, enc->key, get_cipher_key_len(pvar->crypt_state.receiver_cipher));  
                                 //debug_print(13, enc->iv, get_cipher_block_size(pvar->crypt_state.receiver_cipher));  
   
                                 pvar->crypt_state.decrypt = c3DES_decrypt2;  
                                 break;  
                         }  
   
                         // for SSH2(yutaka)  
                 case SSH2_CIPHER_AES128_CBC:  
                 case SSH2_CIPHER_AES192_CBC:  
                 case SSH2_CIPHER_AES256_CBC:  
                 case SSH2_CIPHER_AES128_CTR:  
                 case SSH2_CIPHER_AES192_CTR:  
                 case SSH2_CIPHER_AES256_CTR:  
                         {  
                                 struct Enc *enc;  
   
                                 enc = &pvar->ssh2_keys[MODE_IN].enc;  
                                 cipher_init_SSH2(&pvar->evpcip[MODE_IN],  
                                                  enc->key, get_cipher_key_len(pvar->crypt_state.receiver_cipher),  
                                                  enc->iv, get_cipher_block_size(pvar->crypt_state.receiver_cipher),  
                                                  CIPHER_DECRYPT,  
                                                  get_cipher_EVP_CIPHER(pvar->crypt_state.receiver_cipher),  
                                                  get_cipher_discard_len(pvar->crypt_state.receiver_cipher),  
                                                  pvar);  
   
                                 //debug_print(12, enc->key, get_cipher_key_len(pvar->crypt_state.receiver_cipher));  
                                 //debug_print(13, enc->iv, get_cipher_block_size(pvar->crypt_state.receiver_cipher));  
   
                                 pvar->crypt_state.decrypt = cAES128_decrypt;  
                                 break;  
                         }  
   
                 case SSH2_CIPHER_BLOWFISH_CBC:  
                 case SSH2_CIPHER_BLOWFISH_CTR:  
                         {  
                                 struct Enc *enc;  
   
                                 enc = &pvar->ssh2_keys[MODE_IN].enc;  
                                 cipher_init_SSH2(&pvar->evpcip[MODE_IN],  
                                                  enc->key, get_cipher_key_len(pvar->crypt_state.receiver_cipher),  
                                                  enc->iv, get_cipher_block_size(pvar->crypt_state.receiver_cipher),  
                                                  CIPHER_DECRYPT,  
                                                  get_cipher_EVP_CIPHER(pvar->crypt_state.receiver_cipher),  
                                                  get_cipher_discard_len(pvar->crypt_state.receiver_cipher),  
                                                  pvar);  
   
                                 //debug_print(12, enc->key, get_cipher_key_len(pvar->crypt_state.receiver_cipher));  
                                 //debug_print(13, enc->iv, get_cipher_block_size(pvar->crypt_state.receiver_cipher));  
   
                                 pvar->crypt_state.decrypt = cBlowfish_decrypt2;  
                                 break;  
                         }  
   
                 case SSH2_CIPHER_ARCFOUR:  
                 case SSH2_CIPHER_ARCFOUR128:  
                 case SSH2_CIPHER_ARCFOUR256:  
                         {  
                                 struct Enc *enc;  
   
                                 enc = &pvar->ssh2_keys[MODE_IN].enc;  
                                 cipher_init_SSH2(&pvar->evpcip[MODE_IN],  
                                                  enc->key, get_cipher_key_len(pvar->crypt_state.receiver_cipher),  
                                                  enc->iv, get_cipher_block_size(pvar->crypt_state.receiver_cipher),  
                                                  CIPHER_DECRYPT,  
                                                  get_cipher_EVP_CIPHER(pvar->crypt_state.receiver_cipher),  
                                                  get_cipher_discard_len(pvar->crypt_state.receiver_cipher),  
                                                  pvar);  
   
                                 //debug_print(12, enc->key, get_cipher_key_len(pvar->crypt_state.receiver_cipher));  
                                 //debug_print(13, enc->iv, get_cipher_block_size(pvar->crypt_state.receiver_cipher));  
   
                                 pvar->crypt_state.decrypt = cArcfour_decrypt;  
                                 break;  
                         }  
   
                 case SSH2_CIPHER_CAST128_CBC:  
                 case SSH2_CIPHER_CAST128_CTR:  
                         {  
                                 struct Enc *enc;  
   
                                 enc = &pvar->ssh2_keys[MODE_IN].enc;  
                                 cipher_init_SSH2(&pvar->evpcip[MODE_IN],  
                                                  enc->key, get_cipher_key_len(pvar->crypt_state.receiver_cipher),  
                                                  enc->iv, get_cipher_block_size(pvar->crypt_state.receiver_cipher),  
                                                  CIPHER_DECRYPT,  
                                                  get_cipher_EVP_CIPHER(pvar->crypt_state.receiver_cipher),  
                                                  get_cipher_discard_len(pvar->crypt_state.receiver_cipher),  
                                                  pvar);  
1000    
1001                                  //debug_print(12, enc->key, get_cipher_key_len(pvar->crypt_state.receiver_cipher));                  case SSH_CIPHER_DES:
1002                                  //debug_print(13, enc->iv, get_cipher_block_size(pvar->crypt_state.receiver_cipher));                          cDES_init(decryption_key, &pvar->crypt_state.dec.cDES);
1003                            pvar->crypt_state.decrypt = cDES_decrypt;
1004                            break;
1005    
1006                                  pvar->crypt_state.decrypt = cCast128_decrypt;                  case SSH_CIPHER_BLOWFISH:
1007                                  break;                          cBlowfish_init(decryption_key, &pvar->crypt_state.dec.cBlowfish);
1008                          }                          pvar->crypt_state.decrypt = cBlowfish_decrypt;
1009                            break;
1010    
1011                  case SSH2_CIPHER_CAMELLIA128_CBC:                  case SSH_CIPHER_NONE:
1012                  case SSH2_CIPHER_CAMELLIA192_CBC:                  case SSH_CIPHER_IDEA:
1013                  case SSH2_CIPHER_CAMELLIA256_CBC:                  case SSH_CIPHER_TSS:
1014                  case SSH2_CIPHER_CAMELLIA128_CTR:                  case SSH_CIPHER_RC4:
1015                  case SSH2_CIPHER_CAMELLIA192_CTR:                          isOK = FALSE;
1016                  case SSH2_CIPHER_CAMELLIA256_CTR:                          break;
                         {  
                                 struct Enc *enc;  
1017    
1018                    default: // SSH2
1019                            if (cipher <= SSH_CIPHER_MAX) {
1020                                  enc = &pvar->ssh2_keys[MODE_IN].enc;                                  enc = &pvar->ssh2_keys[MODE_IN].enc;
1021                                  cipher_init_SSH2(&pvar->evpcip[MODE_IN],                                  cipher_init_SSH2(&pvar->evpcip[MODE_IN],
1022                                                   enc->key, get_cipher_key_len(pvar->crypt_state.receiver_cipher),                                                   enc->key, get_cipher_key_len(cipher),
1023                                                   enc->iv, get_cipher_block_size(pvar->crypt_state.receiver_cipher),                                                   enc->iv, get_cipher_block_size(cipher),
1024                                                   CIPHER_DECRYPT,                                                   CIPHER_DECRYPT,
1025                                                   get_cipher_EVP_CIPHER(pvar->crypt_state.receiver_cipher),                                                   get_cipher_EVP_CIPHER(cipher),
1026                                                   get_cipher_discard_len(pvar->crypt_state.receiver_cipher),                                                   get_cipher_discard_len(cipher),
1027                                                   pvar);                                                   pvar);
1028    
1029                                  //debug_print(12, enc->key, get_cipher_key_len(pvar->crypt_state.receiver_cipher));                                  pvar->crypt_state.decrypt = crypt_SSH2_decrypt;
                                 //debug_print(13, enc->iv, get_cipher_block_size(pvar->crypt_state.receiver_cipher));  
   
                                 pvar->crypt_state.decrypt = cCamellia_decrypt;  
                                 break;  
1030                          }                          }
1031                            else {
1032                  case SSH_CIPHER_3DES:{                                  isOK = FALSE;
                                 c3DES_init(decryption_key, &pvar->crypt_state.dec.c3DES);  
                                 pvar->crypt_state.decrypt = c3DES_decrypt;  
                                 break;  
                         }  
                 case SSH_CIPHER_DES:{  
                                 cDES_init(decryption_key, &pvar->crypt_state.dec.cDES);  
                                 pvar->crypt_state.decrypt = cDES_decrypt;  
                                 break;  
                         }  
                 case SSH_CIPHER_BLOWFISH:{  
                                 cBlowfish_init(decryption_key,  
                                                &pvar->crypt_state.dec.cBlowfish);  
                                 pvar->crypt_state.decrypt = cBlowfish_decrypt;  
                                 break;  
1033                          }                          }
1034                  default:                          break;
                         isOK = FALSE;  
1035                  }                  }
1036          }          }
1037    
   
1038          if (!isOK) {          if (!isOK) {
1039                  UTIL_get_lang_msg("MSG_CIPHER_NOTSELECTED_ERROR", pvar,                  UTIL_get_lang_msg("MSG_CIPHER_NOTSELECTED_ERROR", pvar,
1040                                    "No cipher selected!");                                    "No cipher selected!");
Legend:
Removed from v.6714  
changed lines
  Added in v.6716
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help