Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

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

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

Parent Directory Parent Directory | Revision Log Revision Log

Revision 4433 - (hide annotations) (download) (as text)
Mon Apr 11 00:29:12 2011 UTC (13 years ago) by doda
Original Path: trunk/ttssh2/ttxssh/crypt.c
File MIME type: text/x-csrc
File size: 61967 byte(s) 
Camellia γ‚΅γƒγƒΌγƒˆ
1 maya 3227 /*
2     Copyright (c) 1998-2001, Robert O'Callahan
3     All rights reserved.
4    
5     Redistribution and use in source and binary forms, with or without modification,
6     are permitted provided that the following conditions are met:
7    
8     Redistributions of source code must retain the above copyright notice, this list of
9     conditions and the following disclaimer.
10    
11     Redistributions in binary form must reproduce the above copyright notice, this list
12     of conditions and the following disclaimer in the documentation and/or other materials
13     provided with the distribution.
14    
15     The name of Robert O'Callahan may not be used to endorse or promote products derived from
16     this software without specific prior written permission.
17    
18     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
19     ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20     OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
21     THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
22     EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23     SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
25     OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
26     SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27     */
28    
29     #define WINDOWS
30    
31     #include "ttxssh.h"
32     #include "util.h"
33    
34     #include <openssl/rand.h>
35     #include <openssl/bn.h>
36     #include <openssl/md5.h>
37     #include <openssl/err.h>
38     #include <openssl/des.h>
39     #include <openssl/hmac.h> // for SSH2(yutaka)
40     #include <openssl/dsa.h>
41     #include "cipher.h"
42     #include "ssh.h"
43    
44     #define do_crc(buf, len) (~(uint32)crc32(0xFFFFFFFF, (buf), (len)))
45     #define get_uint32(buf) get_uint32_MSBfirst((buf))
46    
47     #define DEATTACK_OK 0
48     #define DEATTACK_DETECTED 1
49    
50     /*
51     * $Id: crypt.c,v 1.28 2008-11-23 07:44:05 doda Exp $ Cryptographic attack
52     * detector for ssh - source code (C)1998 CORE-SDI, Buenos Aires Argentina
53     * Ariel Futoransky(futo@core-sdi.com) <http://www.core-sdi.com>
54     */
55    
56     /* SSH Constants */
57     #define SSH_BLOCKSIZE 8
58    
59     /* Hashing constants */
60     #define HASH_MINSIZE 8*2048
61     #define HASH_ENTRYSIZE 4
62     #define HASH_FACTOR(x) ((x)*3/2)
63     #define HASH_UNUSEDCHAR 0xff
64     #define HASH_UNUSED 0xffffffff
65     #define HASH_IV 0xfffffffe
66    
67     #define HASH_MINBLOCKS (7*SSH_BLOCKSIZE)
68    
69     /* Hash function (Input keys are cipher results) */
70     #define HASH(x) get_uint32(x)
71    
72     #define CMP(a,b) memcmp(a, b, SSH_BLOCKSIZE)
73    
74    
75    
76     static void crc_update(uint32 FAR * a, uint32 b)
77     {
78     b ^= *a;
79     *a = do_crc((unsigned char FAR *) &b, sizeof(b));
80     }
81    
82     /* check_crc
83     detects if a block is used in a particular pattern
84     */
85    
86     static int check_crc(unsigned char FAR * S, unsigned char FAR * buf,
87     uint32 len, unsigned char FAR * IV)
88     {
89     uint32 crc;
90     unsigned char FAR *c;
91    
92     crc = 0;
93     if (IV && !CMP(S, IV)) {
94     crc_update(&crc, 1);
95     crc_update(&crc, 0);
96     }
97     for (c = buf; c < buf + len; c += SSH_BLOCKSIZE) {
98     if (!CMP(S, c)) {
99     crc_update(&crc, 1);
100     crc_update(&crc, 0);
101     } else {
102     crc_update(&crc, 0);
103     crc_update(&crc, 0);
104     }
105     }
106    
107     return crc == 0;
108     }
109    
110    
111     /*
112     detect_attack
113     Detects a crc32 compensation attack on a packet
114     */
115     static int detect_attack(CRYPTDetectAttack FAR * statics,
116     unsigned char FAR * buf, uint32 len,
117     unsigned char *FAR IV)
118     {
119     uint32 FAR *h = statics->h;
120     uint32 n = statics->n;
121     uint32 i, j;
122     uint32 l;
123     unsigned char FAR *c;
124     unsigned char FAR *d;
125    
126     for (l = n; l < HASH_FACTOR(len / SSH_BLOCKSIZE); l = l << 2) {
127     }
128    
129     if (h == NULL) {
130     n = l;
131     h = (uint32 FAR *) malloc(n * HASH_ENTRYSIZE);
132     } else {
133     if (l > n) {
134     n = l;
135     h = (uint32 FAR *) realloc(h, n * HASH_ENTRYSIZE);
136     }
137     }
138    
139     statics->h = h;
140     statics->n = n;
141    
142     if (len <= HASH_MINBLOCKS) {
143     for (c = buf; c < buf + len; c += SSH_BLOCKSIZE) {
144     if (IV && (!CMP(c, IV))) {
145     if ((check_crc(c, buf, len, IV)))
146     return DEATTACK_DETECTED;
147     else
148     break;
149     }
150     for (d = buf; d < c; d += SSH_BLOCKSIZE) {
151     if (!CMP(c, d)) {
152     if ((check_crc(c, buf, len, IV)))
153     return DEATTACK_DETECTED;
154     else
155     break;
156     }
157     }
158     }
159     return (DEATTACK_OK);
160     }
161     memset(h, HASH_UNUSEDCHAR, n * HASH_ENTRYSIZE);
162    
163     if (IV) {
164     h[HASH(IV) & (n - 1)] = HASH_IV;
165     }
166    
167     for (c = buf, j = 0; c < (buf + len); c += SSH_BLOCKSIZE, j++) {
168     for (i = HASH(c) & (n - 1); h[i] != HASH_UNUSED;
169     i = (i + 1) & (n - 1)) {
170     if (h[i] == HASH_IV) {
171     if (!CMP(c, IV)) {
172     if (check_crc(c, buf, len, IV))
173     return DEATTACK_DETECTED;
174     else
175     break;
176     }
177     } else if (!CMP(c, buf + h[i] * SSH_BLOCKSIZE)) {
178     if (check_crc(c, buf, len, IV))
179     return DEATTACK_DETECTED;
180     else
181     break;
182     }
183     }
184     h[i] = j;
185     }
186    
187     return DEATTACK_OK;
188     }
189    
190     BOOL CRYPT_detect_attack(PTInstVar pvar, unsigned char FAR * buf,
191     int bytes)
192     {
193     if (SSHv1(pvar)) {
194     switch (pvar->crypt_state.sender_cipher) {
195     case SSH_CIPHER_NONE:
196     return FALSE;
197     case SSH_CIPHER_IDEA:
198     return detect_attack(&pvar->crypt_state.detect_attack_statics,
199     buf, bytes,
200     pvar->crypt_state.dec.cIDEA.ivec) ==
201     DEATTACK_DETECTED;
202     default:
203     return detect_attack(&pvar->crypt_state.detect_attack_statics,
204     buf, bytes, NULL) == DEATTACK_DETECTED;
205     }
206     } else {
207     return FALSE;
208     }
209     }
210    
211     static void no_encrypt(PTInstVar pvar, unsigned char FAR * buf, int bytes)
212     {
213     }
214    
215    
216     // for SSH2(yutaka)
217     // οΏ½οΏ½οΏ½OοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½AAES192, AES256 οΏ½οΏ½οΏ½οΏ½
218     // cAES128_encrypt/cAES128_decrypt οΏ½οΏ½οΏ½gοΏ½pοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½ (2007.10.16 maya)
219     static void cAES128_encrypt(PTInstVar pvar, unsigned char FAR * buf,
220     int bytes)
221     {
222     unsigned char *newbuf = malloc(bytes);
223     int block_size = pvar->ssh2_keys[MODE_OUT].enc.block_size;
224 doda 4212 char tmp[80];
225 maya 3227
226     // οΏ½οΏ½οΏ½OοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½AοΏ½SοΏ½yοΏ½CοΏ½οΏ½οΏ½[οΏ½hοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½A0οΏ½oοΏ½CοΏ½gοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½B(2004.11.7 yutaka)
227     if (bytes == 0)
228     goto error;
229    
230     if (newbuf == NULL)
231     return;
232    
233     if (bytes % block_size) {
234 doda 4212 UTIL_get_lang_msg("MSG_ENCRYPT_ERROR1", pvar,
235     "%s encrypt error(1): bytes %d (%d)");
236     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
237     "AES128/192/256", bytes, block_size);
238 maya 3227 notify_fatal_error(pvar, tmp);
239     goto error;
240     }
241    
242     if (EVP_Cipher(&pvar->evpcip[MODE_OUT], newbuf, buf, bytes) == 0) {
243 doda 4212 UTIL_get_lang_msg("MSG_ENCRYPT_ERROR2", pvar, "%s encrypt error(2)");
244     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
245     "AES128/192/256");
246     notify_fatal_error(pvar, tmp);
247 maya 3227 goto error;
248    
249     } else {
250     //unsigned char key[AES128_KEYLEN], iv[AES128_IVLEN];
251     //memcpy(key, pvar->ssh2_keys[MODE_OUT].enc.key, AES128_KEYLEN);
252     // IVοΏ½οΏ½DESοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½XοΏ½VοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½AοΏ½οΏ½οΏ½[οΏ½JοΏ½οΏ½οΏ½οΏ½οΏ½RοΏ½sοΏ½[οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½gοΏ½οΏ½οΏ½B
253     //memcpy(iv, pvar->ssh2_keys[MODE_OUT].enc.iv, AES128_IVLEN);
254    
255     //debug_print(50, key, 24);
256     //debug_print(51, iv, 8);
257     //debug_print(52, buf, bytes);
258     //debug_print(53, newbuf, bytes);
259    
260     memcpy(buf, newbuf, bytes);
261     }
262    
263     error:
264     free(newbuf);
265     }
266    
267     static void cAES128_decrypt(PTInstVar pvar, unsigned char FAR * buf,
268     int bytes)
269     {
270     unsigned char *newbuf = malloc(bytes);
271     int block_size = pvar->ssh2_keys[MODE_IN].enc.block_size;
272 doda 4212 char tmp[80];
273 maya 3227
274     // οΏ½οΏ½οΏ½OοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½AοΏ½SοΏ½yοΏ½CοΏ½οΏ½οΏ½[οΏ½hοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½A0οΏ½oοΏ½CοΏ½gοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½B(2004.11.7 yutaka)
275     if (bytes == 0)
276     goto error;
277    
278     if (newbuf == NULL)
279     return;
280    
281     if (bytes % block_size) {
282 doda 4212 UTIL_get_lang_msg("MSG_DECRYPT_ERROR1", pvar,
283     "%s decrypt error(1): bytes %d (%d)");
284     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
285     "AES128/192/256", bytes, block_size);
286 maya 3227 notify_fatal_error(pvar, tmp);
287     goto error;
288     }
289    
290     if (EVP_Cipher(&pvar->evpcip[MODE_IN], newbuf, buf, bytes) == 0) {
291 doda 4212 UTIL_get_lang_msg("MSG_DECRYPT_ERROR2", pvar, "%s decrypt error(2)");
292     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
293     "AES128/192/256");
294     notify_fatal_error(pvar, tmp);
295 maya 3227 goto error;
296    
297     } else {
298     //unsigned char key[AES128_KEYLEN], iv[AES128_IVLEN];
299     //memcpy(key, pvar->ssh2_keys[MODE_IN].enc.key, AES128_KEYLEN);
300     // IVοΏ½οΏ½DESοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½XοΏ½VοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½AοΏ½οΏ½οΏ½[οΏ½JοΏ½οΏ½οΏ½οΏ½οΏ½RοΏ½sοΏ½[οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½gοΏ½οΏ½οΏ½B
301     //memcpy(iv, pvar->ssh2_keys[MODE_IN].enc.iv, AES128_IVLEN);
302    
303     //debug_print(70, key, AES128_KEYLEN);
304     //debug_print(71, iv, AES128_IVLEN);
305     //debug_print(72, buf, bytes);
306     //debug_print(73, newbuf, bytes);
307    
308     memcpy(buf, newbuf, bytes);
309     }
310    
311     error:
312     free(newbuf);
313     }
314    
315    
316     // for SSH2(yutaka)
317 doda 3850 static void c3DES_encrypt2(PTInstVar pvar, unsigned char FAR * buf,
318 doda 4212 int bytes)
319 maya 3227 {
320     unsigned char *newbuf = malloc(bytes);
321     int block_size = pvar->ssh2_keys[MODE_OUT].enc.block_size;
322 doda 4212 char tmp[80];
323 maya 3227
324     // οΏ½οΏ½οΏ½OοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½AοΏ½SοΏ½yοΏ½CοΏ½οΏ½οΏ½[οΏ½hοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½A0οΏ½oοΏ½CοΏ½gοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½B(2004.11.7 yutaka)
325     if (bytes == 0)
326     goto error;
327    
328     if (newbuf == NULL)
329     return;
330    
331     if (bytes % block_size) {
332 doda 4212 UTIL_get_lang_msg("MSG_ENCRYPT_ERROR1", pvar,
333     "%s encrypt error(1): bytes %d (%d)");
334     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
335     "3DES-CBC", bytes, block_size);
336 maya 3227 notify_fatal_error(pvar, tmp);
337     goto error;
338     }
339    
340     if (EVP_Cipher(&pvar->evpcip[MODE_OUT], newbuf, buf, bytes) == 0) {
341 doda 4212 UTIL_get_lang_msg("MSG_ENCRYPT_ERROR2", pvar, "%s encrypt error(2)");
342     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
343     "3DES-CBC");
344     notify_fatal_error(pvar, tmp);
345 maya 3227 goto error;
346    
347     } else {
348     //unsigned char key[24], iv[8];
349     //memcpy(key, pvar->ssh2_keys[MODE_OUT].enc.key, 24);
350     // IVοΏ½οΏ½DESοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½XοΏ½VοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½AοΏ½οΏ½οΏ½[οΏ½JοΏ½οΏ½οΏ½οΏ½οΏ½RοΏ½sοΏ½[οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½gοΏ½οΏ½οΏ½B
351     //memcpy(iv, pvar->ssh2_keys[MODE_OUT].enc.iv, 8);
352    
353     //debug_print(50, key, 24);
354     //debug_print(51, iv, 8);
355     //debug_print(52, buf, bytes);
356     //debug_print(53, newbuf, bytes);
357    
358     memcpy(buf, newbuf, bytes);
359     }
360    
361     error:
362     free(newbuf);
363     }
364    
365 doda 3850 static void c3DES_decrypt2(PTInstVar pvar, unsigned char FAR * buf,
366 doda 4212 int bytes)
367 maya 3227 {
368     unsigned char *newbuf = malloc(bytes);
369     int block_size = pvar->ssh2_keys[MODE_IN].enc.block_size;
370 doda 4212 char tmp[80];
371 maya 3227
372     // οΏ½οΏ½οΏ½OοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½AοΏ½SοΏ½yοΏ½CοΏ½οΏ½οΏ½[οΏ½hοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½A0οΏ½oοΏ½CοΏ½gοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½B(2004.11.7 yutaka)
373     if (bytes == 0)
374     goto error;
375    
376     if (newbuf == NULL)
377     return;
378    
379     if (bytes % block_size) {
380 doda 4212 UTIL_get_lang_msg("MSG_DECRYPT_ERROR1", pvar,
381     "%s decrypt error(1): bytes %d (%d)");
382     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
383     "3DES-CBC", bytes, block_size);
384 maya 3227 notify_fatal_error(pvar, tmp);
385     goto error;
386     }
387    
388     if (EVP_Cipher(&pvar->evpcip[MODE_IN], newbuf, buf, bytes) == 0) {
389 doda 4212 UTIL_get_lang_msg("MSG_DECRYPT_ERROR2", pvar, "%s decrypt error(2)");
390     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
391     "3DES-CBC");
392     notify_fatal_error(pvar, tmp);
393 maya 3227 goto error;
394    
395     } else {
396     //unsigned char key[24], iv[8];
397     //memcpy(key, pvar->ssh2_keys[MODE_IN].enc.key, 24);
398     // IVοΏ½οΏ½DESοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½XοΏ½VοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½AοΏ½οΏ½οΏ½[οΏ½JοΏ½οΏ½οΏ½οΏ½οΏ½RοΏ½sοΏ½[οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½gοΏ½οΏ½οΏ½B
399     //memcpy(iv, pvar->ssh2_keys[MODE_IN].enc.iv, 8);
400    
401     //debug_print(70, key, 24);
402     //debug_print(71, iv, 8);
403     //debug_print(72, buf, bytes);
404     //debug_print(73, newbuf, bytes);
405    
406     memcpy(buf, newbuf, bytes);
407     }
408    
409     error:
410     free(newbuf);
411     }
412    
413    
414     static void cBlowfish_encrypt2(PTInstVar pvar, unsigned char FAR * buf,
415     int bytes)
416     {
417     unsigned char *newbuf = malloc(bytes);
418     int block_size = pvar->ssh2_keys[MODE_OUT].enc.block_size;
419 doda 4212 char tmp[80];
420 maya 3227
421     // οΏ½οΏ½οΏ½OοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½AοΏ½SοΏ½yοΏ½CοΏ½οΏ½οΏ½[οΏ½hοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½A0οΏ½oοΏ½CοΏ½gοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½B(2004.11.7 yutaka)
422     if (bytes == 0)
423     goto error;
424    
425     if (newbuf == NULL)
426     return;
427    
428     if (bytes % block_size) {
429 doda 4212 UTIL_get_lang_msg("MSG_ENCRYPT_ERROR1", pvar,
430     "%s encrypt error(1): bytes %d (%d)");
431     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
432     "Blowfish", bytes, block_size);
433 maya 3227 notify_fatal_error(pvar, tmp);
434     goto error;
435     }
436    
437     if (EVP_Cipher(&pvar->evpcip[MODE_OUT], newbuf, buf, bytes) == 0) {
438 doda 4212 UTIL_get_lang_msg("MSG_ENCRYPT_ERROR2", pvar, "%s encrypt error(2)");
439     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
440     "Blowfish");
441     notify_fatal_error(pvar, tmp);
442 maya 3227 goto error;
443    
444     } else {
445     memcpy(buf, newbuf, bytes);
446    
447     }
448    
449     error:
450     free(newbuf);
451     }
452    
453     static void cBlowfish_decrypt2(PTInstVar pvar, unsigned char FAR * buf,
454     int bytes)
455     {
456     unsigned char *newbuf = malloc(bytes);
457     int block_size = pvar->ssh2_keys[MODE_IN].enc.block_size;
458 doda 4212 char tmp[80];
459 maya 3227
460     // οΏ½οΏ½οΏ½OοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½AοΏ½SοΏ½yοΏ½CοΏ½οΏ½οΏ½[οΏ½hοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½A0οΏ½oοΏ½CοΏ½gοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½B(2004.11.7 yutaka)
461     if (bytes == 0)
462     goto error;
463    
464     if (newbuf == NULL)
465     return;
466    
467     if (bytes % block_size) {
468 doda 4212 UTIL_get_lang_msg("MSG_DECRYPT_ERROR1", pvar,
469     "%s decrypt error(1): bytes %d (%d)");
470     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
471     "Blowfish", bytes, block_size);
472 maya 3227 notify_fatal_error(pvar, tmp);
473     goto error;
474     }
475    
476     if (EVP_Cipher(&pvar->evpcip[MODE_IN], newbuf, buf, bytes) == 0) {
477 doda 4212 UTIL_get_lang_msg("MSG_DECRYPT_ERROR2", pvar, "%s decrypt error(2)");
478     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
479     "Blowfish");
480     notify_fatal_error(pvar, tmp);
481 maya 3227 goto error;
482    
483     } else {
484     memcpy(buf, newbuf, bytes);
485    
486     }
487    
488     error:
489     free(newbuf);
490     }
491    
492 doda 4212
493 maya 3227 static void cArcfour_encrypt(PTInstVar pvar, unsigned char FAR * buf,
494 doda 4212 int bytes)
495 maya 3227 {
496     unsigned char *newbuf = malloc(bytes);
497     int block_size = pvar->ssh2_keys[MODE_OUT].enc.block_size;
498 doda 4212 char tmp[80];
499 maya 3227
500     // οΏ½οΏ½οΏ½OοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½AοΏ½SοΏ½yοΏ½CοΏ½οΏ½οΏ½[οΏ½hοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½A0οΏ½oοΏ½CοΏ½gοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½B(2004.11.7 yutaka)
501     if (bytes == 0)
502     goto error;
503    
504     if (newbuf == NULL)
505     return;
506    
507     if (bytes % block_size) {
508 doda 4212 UTIL_get_lang_msg("MSG_ENCRYPT_ERROR1", pvar,
509     "%s encrypt error(1): bytes %d (%d)");
510     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
511     "Arcfour", bytes, block_size);
512 maya 3227 notify_fatal_error(pvar, tmp);
513     goto error;
514     }
515    
516     if (EVP_Cipher(&pvar->evpcip[MODE_OUT], newbuf, buf, bytes) == 0) {
517 doda 4212 UTIL_get_lang_msg("MSG_ENCRYPT_ERROR2", pvar, "%s encrypt error(2)");
518     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
519     "Arcfour");
520     notify_fatal_error(pvar, tmp);
521 maya 3227 goto error;
522    
523     } else {
524     memcpy(buf, newbuf, bytes);
525    
526     }
527    
528     error:
529     free(newbuf);
530     }
531    
532     static void cArcfour_decrypt(PTInstVar pvar, unsigned char FAR * buf,
533 doda 4212 int bytes)
534 maya 3227 {
535     unsigned char *newbuf = malloc(bytes);
536     int block_size = pvar->ssh2_keys[MODE_IN].enc.block_size;
537 doda 4212 char tmp[80];
538 maya 3227
539     // οΏ½οΏ½οΏ½OοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½AοΏ½SοΏ½yοΏ½CοΏ½οΏ½οΏ½[οΏ½hοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½A0οΏ½oοΏ½CοΏ½gοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½B(2004.11.7 yutaka)
540     if (bytes == 0)
541     goto error;
542    
543     if (newbuf == NULL)
544     return;
545    
546     if (bytes % block_size) {
547 doda 4212 UTIL_get_lang_msg("MSG_DECRYPT_ERROR1", pvar,
548     "%s decrypt error(1): bytes %d (%d)");
549     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
550     "Arcfour", bytes, block_size);
551 maya 3227 notify_fatal_error(pvar, tmp);
552     goto error;
553     }
554    
555     if (EVP_Cipher(&pvar->evpcip[MODE_IN], newbuf, buf, bytes) == 0) {
556 doda 4212 UTIL_get_lang_msg("MSG_DECRYPT_ERROR2", pvar, "%s decrypt error(2)");
557     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
558     "Arcfour");
559     notify_fatal_error(pvar, tmp);
560 maya 3227 goto error;
561    
562     } else {
563     memcpy(buf, newbuf, bytes);
564    
565     }
566    
567     error:
568     free(newbuf);
569     }
570    
571 doda 4212
572 maya 3227 static void cCast128_encrypt(PTInstVar pvar, unsigned char FAR * buf,
573     int bytes)
574     {
575     unsigned char *newbuf = malloc(bytes);
576     int block_size = pvar->ssh2_keys[MODE_OUT].enc.block_size;
577 doda 4212 char tmp[80];
578 maya 3227
579     // οΏ½οΏ½οΏ½OοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½AοΏ½SοΏ½yοΏ½CοΏ½οΏ½οΏ½[οΏ½hοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½A0οΏ½oοΏ½CοΏ½gοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½B(2004.11.7 yutaka)
580     if (bytes == 0)
581     goto error;
582    
583     if (newbuf == NULL)
584     return;
585    
586     if (bytes % block_size) {
587 doda 4212 UTIL_get_lang_msg("MSG_ENCRYPT_ERROR1", pvar,
588     "%s encrypt error(1): bytes %d (%d)");
589     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
590     "CAST128", bytes, block_size);
591 maya 3227 notify_fatal_error(pvar, tmp);
592     goto error;
593     }
594    
595     if (EVP_Cipher(&pvar->evpcip[MODE_OUT], newbuf, buf, bytes) == 0) {
596 doda 4212 UTIL_get_lang_msg("MSG_ENCRYPT_ERROR2", pvar, "%s encrypt error(2)");
597     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
598     "CAST128");
599     notify_fatal_error(pvar, tmp);
600 maya 3227 goto error;
601    
602     } else {
603     memcpy(buf, newbuf, bytes);
604    
605     }
606    
607     error:
608     free(newbuf);
609     }
610    
611     static void cCast128_decrypt(PTInstVar pvar, unsigned char FAR * buf,
612     int bytes)
613     {
614     unsigned char *newbuf = malloc(bytes);
615     int block_size = pvar->ssh2_keys[MODE_IN].enc.block_size;
616 doda 4212 char tmp[80];
617 maya 3227
618     // οΏ½οΏ½οΏ½OοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½AοΏ½SοΏ½yοΏ½CοΏ½οΏ½οΏ½[οΏ½hοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½A0οΏ½oοΏ½CοΏ½gοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½B(2004.11.7 yutaka)
619     if (bytes == 0)
620     goto error;
621    
622     if (newbuf == NULL)
623     return;
624    
625     if (bytes % block_size) {
626 doda 4212 UTIL_get_lang_msg("MSG_DECRYPT_ERROR1", pvar,
627     "%s decrypt error(1): bytes %d (%d)");
628     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
629     "CAST128", bytes, block_size);
630 maya 3227 notify_fatal_error(pvar, tmp);
631     goto error;
632     }
633    
634     if (EVP_Cipher(&pvar->evpcip[MODE_IN], newbuf, buf, bytes) == 0) {
635 doda 4212 UTIL_get_lang_msg("MSG_DECRYPT_ERROR2", pvar, "%s decrypt error(2)");
636     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
637     "CAST128");
638     notify_fatal_error(pvar, tmp);
639 maya 3227 goto error;
640    
641     } else {
642     memcpy(buf, newbuf, bytes);
643    
644     }
645    
646     error:
647     free(newbuf);
648     }
649    
650 doda 4433 #ifdef WITH_CAMELLIA_DRAFT
651     static void cCamellia_encrypt(PTInstVar pvar, unsigned char FAR * buf,
652     int bytes)
653     {
654     unsigned char *newbuf = malloc(bytes);
655     int block_size = pvar->ssh2_keys[MODE_OUT].enc.block_size;
656     char tmp[80];
657 maya 3227
658 doda 4433 // οΏ½οΏ½οΏ½OοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½AοΏ½SοΏ½yοΏ½CοΏ½οΏ½οΏ½[οΏ½hοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½A0οΏ½oοΏ½CοΏ½gοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½B(2004.11.7 yutaka)
659     if (bytes == 0)
660     goto error;
661    
662     if (newbuf == NULL)
663     return;
664    
665     if (bytes % block_size) {
666     UTIL_get_lang_msg("MSG_ENCRYPT_ERROR1", pvar,
667     "%s encrypt error(1): bytes %d (%d)");
668     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
669     "Camellia128/192/256", bytes, block_size);
670     notify_fatal_error(pvar, tmp);
671     goto error;
672     }
673    
674     if (EVP_Cipher(&pvar->evpcip[MODE_OUT], newbuf, buf, bytes) == 0) {
675     UTIL_get_lang_msg("MSG_ENCRYPT_ERROR2", pvar, "%s encrypt error(2)");
676     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
677     "Camellia128/192/256");
678     notify_fatal_error(pvar, tmp);
679     goto error;
680    
681     } else {
682     memcpy(buf, newbuf, bytes);
683    
684     }
685    
686     error:
687     free(newbuf);
688     }
689    
690     static void cCamellia_decrypt(PTInstVar pvar, unsigned char FAR * buf,
691     int bytes)
692     {
693     unsigned char *newbuf = malloc(bytes);
694     int block_size = pvar->ssh2_keys[MODE_IN].enc.block_size;
695     char tmp[80];
696    
697     // οΏ½οΏ½οΏ½OοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½AοΏ½SοΏ½yοΏ½CοΏ½οΏ½οΏ½[οΏ½hοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½A0οΏ½oοΏ½CοΏ½gοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½B(2004.11.7 yutaka)
698     if (bytes == 0)
699     goto error;
700    
701     if (newbuf == NULL)
702     return;
703    
704     if (bytes % block_size) {
705     UTIL_get_lang_msg("MSG_DECRYPT_ERROR1", pvar,
706     "%s decrypt error(1): bytes %d (%d)");
707     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
708     "Camellia128/192/256", bytes, block_size);
709     notify_fatal_error(pvar, tmp);
710     goto error;
711     }
712    
713     if (EVP_Cipher(&pvar->evpcip[MODE_IN], newbuf, buf, bytes) == 0) {
714     UTIL_get_lang_msg("MSG_DECRYPT_ERROR2", pvar, "%s decrypt error(2)");
715     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg,
716     "Camellia128/192/256");
717     notify_fatal_error(pvar, tmp);
718     goto error;
719    
720     } else {
721     memcpy(buf, newbuf, bytes);
722    
723     }
724    
725     error:
726     free(newbuf);
727     }
728     #endif // WITH_CAMELLIA_DRAFT
729    
730 maya 3227 static void c3DES_encrypt(PTInstVar pvar, unsigned char FAR * buf,
731     int bytes)
732     {
733     Cipher3DESState FAR *encryptstate = &pvar->crypt_state.enc.c3DES;
734    
735     DES_ncbc_encrypt(buf, buf, bytes,
736     &encryptstate->k1, &encryptstate->ivec1, DES_ENCRYPT);
737     DES_ncbc_encrypt(buf, buf, bytes,
738     &encryptstate->k2, &encryptstate->ivec2, DES_DECRYPT);
739     DES_ncbc_encrypt(buf, buf, bytes,
740     &encryptstate->k3, &encryptstate->ivec3, DES_ENCRYPT);
741     }
742    
743     static void c3DES_decrypt(PTInstVar pvar, unsigned char FAR * buf,
744     int bytes)
745     {
746     Cipher3DESState FAR *decryptstate = &pvar->crypt_state.dec.c3DES;
747    
748     DES_ncbc_encrypt(buf, buf, bytes,
749     &decryptstate->k3, &decryptstate->ivec3, DES_DECRYPT);
750     DES_ncbc_encrypt(buf, buf, bytes,
751     &decryptstate->k2, &decryptstate->ivec2, DES_ENCRYPT);
752     DES_ncbc_encrypt(buf, buf, bytes,
753     &decryptstate->k1, &decryptstate->ivec1, DES_DECRYPT);
754     }
755    
756     static void cDES_encrypt(PTInstVar pvar, unsigned char FAR * buf,
757     int bytes)
758     {
759     CipherDESState FAR *encryptstate = &pvar->crypt_state.enc.cDES;
760    
761     DES_ncbc_encrypt(buf, buf, bytes,
762     &encryptstate->k, &encryptstate->ivec, DES_ENCRYPT);
763     }
764    
765     static void cDES_decrypt(PTInstVar pvar, unsigned char FAR * buf,
766     int bytes)
767     {
768     CipherDESState FAR *decryptstate = &pvar->crypt_state.dec.cDES;
769    
770     DES_ncbc_encrypt(buf, buf, bytes,
771     &decryptstate->k, &decryptstate->ivec, DES_DECRYPT);
772     }
773    
774     static void cIDEA_encrypt(PTInstVar pvar, unsigned char FAR * buf,
775     int bytes)
776     {
777     CipherIDEAState FAR *encryptstate = &pvar->crypt_state.enc.cIDEA;
778     int num = 0;
779    
780     idea_cfb64_encrypt(buf, buf, bytes, &encryptstate->k,
781     encryptstate->ivec, &num, IDEA_ENCRYPT);
782     }
783    
784     static void cIDEA_decrypt(PTInstVar pvar, unsigned char FAR * buf,
785     int bytes)
786     {
787     CipherIDEAState FAR *decryptstate = &pvar->crypt_state.dec.cIDEA;
788     int num = 0;
789    
790     idea_cfb64_encrypt(buf, buf, bytes, &decryptstate->k,
791     decryptstate->ivec, &num, IDEA_DECRYPT);
792     }
793    
794     static void flip_endianness(unsigned char FAR * cbuf, int bytes)
795     {
796     uint32 FAR *buf = (uint32 FAR *) cbuf;
797     int count = bytes / 4;
798    
799     while (count > 0) {
800     uint32 w = *buf;
801    
802     *buf = ((w << 24) & 0xFF000000) | ((w << 8) & 0x00FF0000)
803     | ((w >> 8) & 0x0000FF00) | ((w >> 24) & 0x000000FF);
804     count--;
805     buf++;
806     }
807     }
808    
809     static void cBlowfish_encrypt(PTInstVar pvar, unsigned char FAR * buf,
810     int bytes)
811     {
812     CipherBlowfishState FAR *encryptstate =
813     &pvar->crypt_state.enc.cBlowfish;
814    
815     flip_endianness(buf, bytes);
816     BF_cbc_encrypt(buf, buf, bytes, &encryptstate->k, encryptstate->ivec,
817     BF_ENCRYPT);
818     flip_endianness(buf, bytes);
819     }
820    
821     static void cBlowfish_decrypt(PTInstVar pvar, unsigned char FAR * buf,
822     int bytes)
823     {
824     CipherBlowfishState FAR *decryptstate =
825     &pvar->crypt_state.dec.cBlowfish;
826    
827     flip_endianness(buf, bytes);
828     BF_cbc_encrypt(buf, buf, bytes, &decryptstate->k, decryptstate->ivec,
829     BF_DECRYPT);
830     flip_endianness(buf, bytes);
831     }
832    
833     static void cRC4_encrypt(PTInstVar pvar, unsigned char FAR * buf,
834     int bytes)
835     {
836     CipherRC4State FAR *encryptstate = &pvar->crypt_state.enc.cRC4;
837     int num = 0;
838    
839     RC4(&encryptstate->k, bytes, buf, buf);
840     }
841    
842     static void cRC4_decrypt(PTInstVar pvar, unsigned char FAR * buf,
843     int bytes)
844     {
845     CipherRC4State FAR *decryptstate = &pvar->crypt_state.dec.cRC4;
846     int num = 0;
847    
848     RC4(&decryptstate->k, bytes, buf, buf);
849     }
850    
851     void CRYPT_set_random_data(PTInstVar pvar, unsigned char FAR * buf,
852     int bytes)
853     {
854     RAND_bytes(buf, bytes);
855     }
856    
857     void CRYPT_initialize_random_numbers(PTInstVar pvar)
858     {
859     RAND_screen();
860     }
861    
862     static BIGNUM FAR *get_bignum(unsigned char FAR * bytes)
863     {
864     int bits = get_ushort16_MSBfirst(bytes);
865    
866     return BN_bin2bn(bytes + 2, (bits + 7) / 8, NULL);
867     }
868    
869     // make_key()οΏ½οΏ½ fingerprint οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½pοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½AstaticοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½B(2006.3.27 yutaka)
870     RSA FAR *make_key(PTInstVar pvar,
871     int bits, unsigned char FAR * exp,
872     unsigned char FAR * mod)
873     {
874     RSA FAR *key = RSA_new();
875    
876     if (key != NULL) {
877     key->e = get_bignum(exp);
878     key->n = get_bignum(mod);
879     }
880    
881     if (key == NULL || key->e == NULL || key->n == NULL) {
882     UTIL_get_lang_msg("MSG_RSAKEY_SETUP_ERROR", pvar,
883     "Error setting up RSA keys");
884     notify_fatal_error(pvar, pvar->ts->UIMsg);
885    
886     if (key != NULL) {
887     if (key->e != NULL) {
888     BN_free(key->e);
889     }
890     if (key->n != NULL) {
891     BN_free(key->n);
892     }
893     RSA_free(key);
894     }
895    
896     return NULL;
897     } else {
898     return key;
899     }
900     }
901    
902     void CRYPT_set_server_cookie(PTInstVar pvar, unsigned char FAR * cookie)
903     {
904     if (SSHv1(pvar)) {
905     memcpy(pvar->crypt_state.server_cookie, cookie, SSH_COOKIE_LENGTH);
906     } else {
907     memcpy(pvar->crypt_state.server_cookie, cookie,
908     SSH2_COOKIE_LENGTH);
909     }
910     }
911    
912     void CRYPT_set_client_cookie(PTInstVar pvar, unsigned char FAR * cookie)
913     {
914     if (SSHv2(pvar)) {
915     memcpy(pvar->crypt_state.client_cookie, cookie,
916     SSH2_COOKIE_LENGTH);
917     }
918     }
919    
920     BOOL CRYPT_set_server_RSA_key(PTInstVar pvar,
921     int bits, unsigned char FAR * exp,
922     unsigned char FAR * mod)
923     {
924     pvar->crypt_state.server_key.RSA_key = make_key(pvar, bits, exp, mod);
925    
926     return pvar->crypt_state.server_key.RSA_key != NULL;
927     }
928    
929     BOOL CRYPT_set_host_RSA_key(PTInstVar pvar,
930     int bits, unsigned char FAR * exp,
931     unsigned char FAR * mod)
932     {
933     pvar->crypt_state.host_key.RSA_key = make_key(pvar, bits, exp, mod);
934    
935     return pvar->crypt_state.host_key.RSA_key != NULL;
936     }
937    
938     BOOL CRYPT_set_supported_ciphers(PTInstVar pvar, int sender_ciphers,
939     int receiver_ciphers)
940     {
941     int cipher_mask;
942    
943     if (SSHv1(pvar)) {
944     cipher_mask = (1 << SSH_CIPHER_DES)
945     | (1 << SSH_CIPHER_3DES)
946     | (1 << SSH_CIPHER_BLOWFISH);
947    
948     } else { // for SSH2(yutaka)
949     // SSH2οΏ½οΏ½οΏ½TοΏ½|οΏ½[οΏ½gοΏ½οΏ½οΏ½οΏ½οΏ½fοΏ½[οΏ½^οΏ½οΏ½οΏ½MοΏ½pοΏ½AοΏ½οΏ½οΏ½SοΏ½οΏ½οΏ½YοΏ½οΏ½οΏ½iοΏ½οΏ½οΏ½JοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½pοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½j
950 doda 4433 cipher_mask =((1 << SSH2_CIPHER_3DES_CBC)
951 maya 3227 | (1 << SSH2_CIPHER_AES128_CBC)
952     | (1 << SSH2_CIPHER_AES192_CBC)
953     | (1 << SSH2_CIPHER_AES256_CBC)
954     | (1 << SSH2_CIPHER_BLOWFISH_CBC)
955     | (1 << SSH2_CIPHER_AES128_CTR)
956     | (1 << SSH2_CIPHER_AES192_CTR)
957     | (1 << SSH2_CIPHER_AES256_CTR)
958     | (1 << SSH2_CIPHER_ARCFOUR)
959     | (1 << SSH2_CIPHER_ARCFOUR128)
960     | (1 << SSH2_CIPHER_ARCFOUR256)
961 doda 3850 | (1 << SSH2_CIPHER_CAST128_CBC)
962     | (1 << SSH2_CIPHER_3DES_CTR)
963     | (1 << SSH2_CIPHER_BLOWFISH_CTR)
964 doda 4433 | (1 << SSH2_CIPHER_CAST128_CTR)
965     #ifdef WITH_CAMELLIA_DRAFT
966     | (1 << SSH2_CIPHER_CAMELLIA128_CBC)
967     | (1 << SSH2_CIPHER_CAMELLIA192_CBC)
968     | (1 << SSH2_CIPHER_CAMELLIA256_CBC)
969     | (1 << SSH2_CIPHER_CAMELLIA128_CTR)
970     | (1 << SSH2_CIPHER_CAMELLIA192_CTR)
971     | (1 << SSH2_CIPHER_CAMELLIA256_CTR)
972     #endif // WITH_CAMELLIA_DRAFT
973     );
974 maya 3227 }
975    
976     sender_ciphers &= cipher_mask;
977     receiver_ciphers &= cipher_mask;
978     pvar->crypt_state.supported_sender_ciphers = sender_ciphers;
979     pvar->crypt_state.supported_receiver_ciphers = receiver_ciphers;
980    
981     if (sender_ciphers == 0) {
982     UTIL_get_lang_msg("MSG_UNAVAILABLE_CIPHERS_ERROR", pvar,
983     "The server does not support any of the TTSSH encryption algorithms.\n"
984     "A secure connection cannot be made in the TTSSH-to-server direction.\n"
985     "The connection will be closed.");
986     notify_fatal_error(pvar, pvar->ts->UIMsg);
987     return FALSE;
988     } else if (receiver_ciphers == 0) {
989     UTIL_get_lang_msg("MSG_UNAVAILABLE_CIPHERS_ERROR", pvar,
990     "The server does not support any of the TTSSH encryption algorithms.\n"
991     "A secure connection cannot be made in the TTSSH-to-server direction.\n"
992     "The connection will be closed.");
993     notify_fatal_error(pvar, pvar->ts->UIMsg);
994     return FALSE;
995     } else {
996     return TRUE;
997     }
998     }
999    
1000     int CRYPT_get_decryption_block_size(PTInstVar pvar)
1001     {
1002     if (SSHv1(pvar)) {
1003     return 8;
1004     } else {
1005     // οΏ½pοΏ½PοΏ½bοΏ½gοΏ½οΏ½οΏ½MοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½AοΏ½οΏ½οΏ½SοΏ½οΏ½οΏ½YοΏ½οΏ½οΏ½οΏ½οΏ½uοΏ½οΏ½οΏ½bοΏ½NοΏ½TοΏ½CοΏ½Y (2004.11.7 yutaka)
1006     // cf. 3DES=8, AES128=16
1007     return (pvar->ssh2_keys[MODE_IN].enc.block_size);
1008     }
1009     }
1010    
1011     int CRYPT_get_encryption_block_size(PTInstVar pvar)
1012     {
1013     if (SSHv1(pvar)) {
1014     return 8;
1015     } else {
1016     // οΏ½pοΏ½PοΏ½bοΏ½gοΏ½οΏ½οΏ½MοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½AοΏ½οΏ½οΏ½SοΏ½οΏ½οΏ½YοΏ½οΏ½οΏ½οΏ½οΏ½uοΏ½οΏ½οΏ½bοΏ½NοΏ½TοΏ½CοΏ½Y (2004.11.7 yutaka)
1017     // cf. 3DES=8, AES128=16
1018     return (pvar->ssh2_keys[MODE_OUT].enc.block_size);
1019     }
1020     }
1021    
1022     int CRYPT_get_receiver_MAC_size(PTInstVar pvar)
1023     {
1024     struct Mac *mac;
1025    
1026     if (SSHv1(pvar)) {
1027     return 0;
1028    
1029     } else { // for SSH2(yutaka)
1030     mac = &pvar->ssh2_keys[MODE_IN].mac;
1031     if (mac == NULL || mac->enabled == 0)
1032     return 0;
1033    
1034     return (pvar->ssh2_keys[MODE_IN].mac.mac_len);
1035     }
1036    
1037     }
1038    
1039     // HMACοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½
1040     // οΏ½οΏ½οΏ½{οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½ SSH2 οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½gοΏ½pοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½B
1041     // (2004.12.17 yutaka)
1042     BOOL CRYPT_verify_receiver_MAC(PTInstVar pvar, uint32 sequence_number,
1043     char FAR * data, int len, char FAR * MAC)
1044     {
1045     HMAC_CTX c;
1046     unsigned char m[EVP_MAX_MD_SIZE];
1047     unsigned char b[4];
1048     struct Mac *mac;
1049    
1050     mac = &pvar->ssh2_keys[MODE_IN].mac;
1051    
1052     // HMACοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½LοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½AοΏ½οΏ½οΏ½οΏ½OKοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½B
1053     if (mac == NULL || mac->enabled == 0)
1054     return TRUE;
1055    
1056     if (mac->key == NULL)
1057     goto error;
1058    
1059     if ((u_int)mac->mac_len > sizeof(m))
1060     goto error;
1061    
1062     HMAC_Init(&c, mac->key, mac->key_len, mac->md);
1063     set_uint32_MSBfirst(b, sequence_number);
1064     HMAC_Update(&c, b, sizeof(b));
1065     HMAC_Update(&c, data, len);
1066     HMAC_Final(&c, m, NULL);
1067     HMAC_cleanup(&c);
1068    
1069     if (memcmp(m, MAC, mac->mac_len)) {
1070     goto error;
1071     }
1072    
1073     return TRUE;
1074    
1075     error:
1076     return FALSE;
1077     }
1078    
1079     int CRYPT_get_sender_MAC_size(PTInstVar pvar)
1080     {
1081     struct Mac *mac;
1082    
1083     if (SSHv2(pvar)) { // for SSH2(yutaka)
1084     mac = &pvar->ssh2_keys[MODE_OUT].mac;
1085     if (mac == NULL || mac->enabled == 0)
1086     return 0;
1087    
1088     return (mac->mac_len);
1089     }
1090    
1091     return 0;
1092     }
1093    
1094     // for SSH2
1095     BOOL CRYPT_build_sender_MAC(PTInstVar pvar, uint32 sequence_number,
1096     char FAR * data, int len, char FAR * MAC)
1097     {
1098     HMAC_CTX c;
1099     static u_char m[EVP_MAX_MD_SIZE];
1100     u_char b[4];
1101     struct Mac *mac;
1102    
1103     if (SSHv2(pvar)) { // for SSH2(yutaka)
1104     mac = &pvar->ssh2_keys[MODE_OUT].mac;
1105     if (mac == NULL || mac->enabled == 0)
1106     return FALSE;
1107    
1108     HMAC_Init(&c, mac->key, mac->key_len, mac->md);
1109     set_uint32_MSBfirst(b, sequence_number);
1110     HMAC_Update(&c, b, sizeof(b));
1111     HMAC_Update(&c, data, len);
1112     HMAC_Final(&c, m, NULL);
1113     HMAC_cleanup(&c);
1114    
1115     // 20οΏ½oοΏ½CοΏ½gοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½RοΏ½sοΏ½[
1116     memcpy(MAC, m, pvar->ssh2_keys[MODE_OUT].mac.mac_len);
1117     // memcpy(MAC, m, sizeof(m));
1118    
1119     return TRUE;
1120     }
1121    
1122     return TRUE;
1123    
1124     }
1125    
1126     static int choose_cipher(PTInstVar pvar, int supported)
1127     {
1128     int i;
1129    
1130     for (i = 0; pvar->session_settings.CipherOrder[i] != 0; i++) {
1131     int cipher = pvar->session_settings.CipherOrder[i] - '0';
1132    
1133     if (cipher == SSH_CIPHER_NONE) {
1134     break;
1135     } else if ((supported & (1 << cipher)) != 0) {
1136     return cipher;
1137     }
1138     }
1139    
1140     return SSH_CIPHER_NONE;
1141     }
1142    
1143     BOOL CRYPT_choose_ciphers(PTInstVar pvar)
1144     {
1145     if (SSHv1(pvar)) {
1146     pvar->crypt_state.sender_cipher = choose_cipher(pvar,
1147     pvar->crypt_state.
1148     supported_sender_ciphers);
1149     pvar->crypt_state.receiver_cipher =
1150     choose_cipher(pvar, pvar->crypt_state.supported_receiver_ciphers);
1151    
1152     } else { // SSH2(yutaka)
1153     pvar->crypt_state.sender_cipher = pvar->ctos_cipher;
1154     pvar->crypt_state.receiver_cipher =pvar->stoc_cipher;
1155    
1156     }
1157    
1158     if (pvar->crypt_state.sender_cipher == SSH_CIPHER_NONE
1159     || pvar->crypt_state.receiver_cipher == SSH_CIPHER_NONE) {
1160     UTIL_get_lang_msg("MSG_CHIPHER_NONE_ERROR", pvar,
1161     "All the encryption algorithms that this program and the server both understand have been disabled.\n"
1162     "To communicate with this server, you will have to enable some more ciphers\n"
1163     "in the TTSSH Setup dialog box when you run Tera Term again.\n"
1164     "This connection will now close.");
1165     notify_fatal_error(pvar, pvar->ts->UIMsg);
1166     return FALSE;
1167     } else {
1168     return TRUE;
1169     }
1170     }
1171    
1172     int CRYPT_get_encrypted_session_key_len(PTInstVar pvar)
1173     {
1174     int server_key_bits =
1175     BN_num_bits(pvar->crypt_state.server_key.RSA_key->n);
1176     int host_key_bits = BN_num_bits(pvar->crypt_state.host_key.RSA_key->n);
1177     int server_key_bytes = (server_key_bits + 7) / 8;
1178     int host_key_bytes = (host_key_bits + 7) / 8;
1179    
1180     if (server_key_bits < host_key_bits) {
1181     return host_key_bytes;
1182     } else {
1183     return server_key_bytes;
1184     }
1185     }
1186    
1187     int CRYPT_choose_session_key(PTInstVar pvar,
1188     unsigned char FAR * encrypted_key_buf)
1189     {
1190     int server_key_bits =
1191     BN_num_bits(pvar->crypt_state.server_key.RSA_key->n);
1192     int host_key_bits = BN_num_bits(pvar->crypt_state.host_key.RSA_key->n);
1193     int server_key_bytes = (server_key_bits + 7) / 8;
1194     int host_key_bytes = (host_key_bits + 7) / 8;
1195     int encrypted_key_bytes;
1196     int bit_delta;
1197    
1198     if (server_key_bits < host_key_bits) {
1199     encrypted_key_bytes = host_key_bytes;
1200     bit_delta = host_key_bits - server_key_bits;
1201     } else {
1202     encrypted_key_bytes = server_key_bytes;
1203     bit_delta = server_key_bits - host_key_bits;
1204     }
1205    
1206     if (bit_delta < 128 || server_key_bits < 512 || host_key_bits < 512) {
1207     UTIL_get_lang_msg("MSG_RASKEY_TOOWEAK_ERROR", pvar,
1208     "Server RSA keys are too weak. A secure connection cannot be established.");
1209     notify_fatal_error(pvar, pvar->ts->UIMsg);
1210     return 0;
1211     } else {
1212     /* following Goldberg's code, I'm using MD5(servkey->n || hostkey->n || cookie)
1213     for the session ID, rather than the one specified in the RFC */
1214     int session_buf_len = server_key_bytes + host_key_bytes + 8;
1215     char FAR *session_buf = (char FAR *) malloc(session_buf_len);
1216     char session_id[16];
1217     int i;
1218    
1219     BN_bn2bin(pvar->crypt_state.host_key.RSA_key->n, session_buf);
1220     BN_bn2bin(pvar->crypt_state.server_key.RSA_key->n,
1221     session_buf + host_key_bytes);
1222     memcpy(session_buf + server_key_bytes + host_key_bytes,
1223     pvar->crypt_state.server_cookie, 8);
1224     MD5(session_buf, session_buf_len, session_id);
1225    
1226     free(session_buf);
1227    
1228     RAND_bytes(pvar->crypt_state.sender_cipher_key,
1229     SSH_SESSION_KEY_LENGTH);
1230     memcpy(pvar->crypt_state.receiver_cipher_key,
1231     pvar->crypt_state.sender_cipher_key,
1232     SSH_SESSION_KEY_LENGTH);
1233    
1234     memcpy(encrypted_key_buf + encrypted_key_bytes -
1235     SSH_SESSION_KEY_LENGTH, pvar->crypt_state.sender_cipher_key,
1236     SSH_SESSION_KEY_LENGTH);
1237     for (i = 0; i < sizeof(session_id); i++) {
1238     encrypted_key_buf[encrypted_key_bytes -
1239     SSH_SESSION_KEY_LENGTH + i]
1240     ^= session_id[i];
1241     }
1242    
1243     if (host_key_bits > server_key_bits) {
1244     if (RSA_public_encrypt(SSH_SESSION_KEY_LENGTH,
1245     encrypted_key_buf +
1246     encrypted_key_bytes -
1247     SSH_SESSION_KEY_LENGTH,
1248     encrypted_key_buf +
1249     encrypted_key_bytes - server_key_bytes,
1250     pvar->crypt_state.server_key.RSA_key,
1251     RSA_PKCS1_PADDING) < 0)
1252     return 0;
1253    
1254     if (RSA_public_encrypt(server_key_bytes,
1255     encrypted_key_buf +
1256     encrypted_key_bytes - server_key_bytes,
1257     encrypted_key_buf,
1258     pvar->crypt_state.host_key.RSA_key,
1259     RSA_PKCS1_PADDING) < 0)
1260     return 0;
1261     } else {
1262     if (RSA_public_encrypt(SSH_SESSION_KEY_LENGTH,
1263     encrypted_key_buf +
1264     encrypted_key_bytes -
1265     SSH_SESSION_KEY_LENGTH,
1266     encrypted_key_buf +
1267     encrypted_key_bytes - host_key_bytes,
1268     pvar->crypt_state.host_key.RSA_key,
1269     RSA_PKCS1_PADDING) < 0)
1270     return 0;
1271    
1272     if (RSA_public_encrypt(host_key_bytes,
1273     encrypted_key_buf +
1274     encrypted_key_bytes - host_key_bytes,
1275     encrypted_key_buf,
1276     pvar->crypt_state.server_key.RSA_key,
1277     RSA_PKCS1_PADDING) < 0)
1278     return 0;
1279     }
1280     }
1281    
1282     return 1;
1283     }
1284    
1285     int CRYPT_generate_RSA_challenge_response(PTInstVar pvar,
1286     unsigned char FAR * challenge,
1287     int challenge_len,
1288     unsigned char FAR * response)
1289     {
1290     int server_key_bits =
1291     BN_num_bits(pvar->crypt_state.server_key.RSA_key->n);
1292     int host_key_bits = BN_num_bits(pvar->crypt_state.host_key.RSA_key->n);
1293     int server_key_bytes = (server_key_bits + 7) / 8;
1294     int host_key_bytes = (host_key_bits + 7) / 8;
1295     int session_buf_len = server_key_bytes + host_key_bytes + 8;
1296     char FAR *session_buf = (char FAR *) malloc(session_buf_len);
1297     char decrypted_challenge[48];
1298     int decrypted_challenge_len;
1299    
1300     decrypted_challenge_len =
1301     RSA_private_decrypt(challenge_len, challenge, challenge,
1302 maya 4307 AUTH_get_cur_cred(pvar)->key_pair->rsa,
1303 maya 3227 RSA_PKCS1_PADDING);
1304     if (decrypted_challenge_len < 0) {
1305     free(session_buf);
1306     return 0;
1307     }
1308     if (decrypted_challenge_len >= SSH_RSA_CHALLENGE_LENGTH) {
1309     memcpy(decrypted_challenge,
1310     challenge + decrypted_challenge_len -
1311     SSH_RSA_CHALLENGE_LENGTH, SSH_RSA_CHALLENGE_LENGTH);
1312     } else {
1313     memset(decrypted_challenge, 0,
1314     SSH_RSA_CHALLENGE_LENGTH - decrypted_challenge_len);
1315     memcpy(decrypted_challenge + SSH_RSA_CHALLENGE_LENGTH -
1316     decrypted_challenge_len, challenge,
1317     decrypted_challenge_len);
1318     }
1319    
1320     BN_bn2bin(pvar->crypt_state.host_key.RSA_key->n, session_buf);
1321     BN_bn2bin(pvar->crypt_state.server_key.RSA_key->n,
1322     session_buf + host_key_bytes);
1323     memcpy(session_buf + server_key_bytes + host_key_bytes,
1324     pvar->crypt_state.server_cookie, 8);
1325     MD5(session_buf, session_buf_len, decrypted_challenge + 32);
1326    
1327     free(session_buf);
1328    
1329     MD5(decrypted_challenge, 48, response);
1330    
1331     return 1;
1332     }
1333    
1334     static void c3DES_init(char FAR * session_key, Cipher3DESState FAR * state)
1335     {
1336     DES_set_key((const_DES_cblock FAR *) session_key, &state->k1);
1337     DES_set_key((const_DES_cblock FAR *) (session_key + 8), &state->k2);
1338     DES_set_key((const_DES_cblock FAR *) (session_key + 16), &state->k3);
1339     memset(state->ivec1, 0, 8);
1340     memset(state->ivec2, 0, 8);
1341     memset(state->ivec3, 0, 8);
1342     }
1343    
1344     static void cDES_init(char FAR * session_key, CipherDESState FAR * state)
1345     {
1346     DES_set_key((const_des_cblock FAR *) session_key, &state->k);
1347     memset(state->ivec, 0, 8);
1348     }
1349    
1350     static void cIDEA_init(char FAR * session_key, CipherIDEAState FAR * state)
1351     {
1352     idea_set_encrypt_key(session_key, &state->k);
1353     memset(state->ivec, 0, 8);
1354     }
1355    
1356     static void cBlowfish_init(char FAR * session_key,
1357     CipherBlowfishState FAR * state)
1358     {
1359     BF_set_key(&state->k, 32, session_key);
1360     memset(state->ivec, 0, 8);
1361     }
1362    
1363    
1364     //
1365     // SSH2οΏ½pοΏ½AοΏ½οΏ½οΏ½SοΏ½οΏ½οΏ½YοΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½οΏ½
1366     //
1367     // for SSH2(yutaka)
1368     //
1369     void cipher_init_SSH2(EVP_CIPHER_CTX *evp,
1370     const u_char *key, u_int keylen,
1371     const u_char *iv, u_int ivlen,
1372     int encrypt,
1373     const EVP_CIPHER *type,
1374     int discard_len,
1375     PTInstVar pvar)
1376     {
1377     int klen;
1378     char tmp[80];
1379     unsigned char *junk = NULL, *discard = NULL;
1380    
1381     EVP_CIPHER_CTX_init(evp);
1382     if (EVP_CipherInit(evp, type, NULL, (u_char *)iv, (encrypt == CIPHER_ENCRYPT)) == 0) {
1383     UTIL_get_lang_msg("MSG_CIPHER_INIT_ERROR", pvar,
1384     "Cipher initialize error(%d)");
1385     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg, 1);
1386     notify_fatal_error(pvar, tmp);
1387     return;
1388     }
1389    
1390     klen = EVP_CIPHER_CTX_key_length(evp);
1391     if (klen > 0 && keylen != klen) {
1392     if (EVP_CIPHER_CTX_set_key_length(evp, keylen) == 0) {
1393     UTIL_get_lang_msg("MSG_CIPHER_INIT_ERROR", pvar,
1394     "Cipher initialize error(%d)");
1395     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg, 2);
1396     notify_fatal_error(pvar, tmp);
1397     return;
1398     }
1399     }
1400     if (EVP_CipherInit(evp, NULL, (u_char *)key, NULL, -1) == 0) {
1401     UTIL_get_lang_msg("MSG_CIPHER_INIT_ERROR", pvar,
1402     "Cipher initialize error(%d)");
1403     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE, pvar->ts->UIMsg, 3);
1404     notify_fatal_error(pvar, tmp);
1405     return;
1406     }
1407    
1408     if (discard_len > 0) {
1409     junk = malloc(discard_len);
1410     discard = malloc(discard_len);
1411     if (junk == NULL || discard == NULL ||
1412     EVP_Cipher(evp, discard, junk, discard_len) == 0) {
1413     UTIL_get_lang_msg("MSG_CIPHER_INIT_ERROR", pvar,
1414     "Cipher initialize error(%d)");
1415     _snprintf_s(tmp, sizeof(tmp), _TRUNCATE,
1416     pvar->ts->UIMsg, 3);
1417     notify_fatal_error(pvar, tmp);
1418     }
1419     else {
1420     memset(discard, 0, discard_len);
1421     }
1422     free(junk);
1423     free(discard);
1424     }
1425     }
1426    
1427    
1428     BOOL CRYPT_start_encryption(PTInstVar pvar, int sender_flag, int receiver_flag)
1429     {
1430     char FAR *encryption_key = pvar->crypt_state.sender_cipher_key;
1431     char FAR *decryption_key = pvar->crypt_state.receiver_cipher_key;
1432     BOOL isOK = TRUE;
1433    
1434     if (sender_flag) {
1435     switch (pvar->crypt_state.sender_cipher) {
1436     // for SSH2(yutaka)
1437     case SSH2_CIPHER_3DES_CBC:
1438 doda 3850 case SSH2_CIPHER_3DES_CTR:
1439 maya 3227 {
1440     struct Enc *enc;
1441    
1442     enc = &pvar->ssh2_keys[MODE_OUT].enc;
1443     cipher_init_SSH2(&pvar->evpcip[MODE_OUT],
1444     enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher),
1445     enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher),
1446     CIPHER_ENCRYPT,
1447     get_cipher_EVP_CIPHER(pvar->crypt_state.sender_cipher),
1448     get_cipher_discard_len(pvar->crypt_state.sender_cipher),
1449     pvar);
1450    
1451     //debug_print(10, enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher));
1452     //debug_print(11, enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher));
1453    
1454 doda 3850 pvar->crypt_state.encrypt = c3DES_encrypt2;
1455 maya 3227 break;
1456     }
1457    
1458     // for SSH2(yutaka)
1459     case SSH2_CIPHER_AES128_CBC:
1460     case SSH2_CIPHER_AES192_CBC:
1461     case SSH2_CIPHER_AES256_CBC:
1462     case SSH2_CIPHER_AES128_CTR:
1463     case SSH2_CIPHER_AES192_CTR:
1464     case SSH2_CIPHER_AES256_CTR:
1465     {
1466     struct Enc *enc;
1467    
1468     enc = &pvar->ssh2_keys[MODE_OUT].enc;
1469     cipher_init_SSH2(&pvar->evpcip[MODE_OUT],
1470     enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher),
1471     enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher),
1472     CIPHER_ENCRYPT,
1473     get_cipher_EVP_CIPHER(pvar->crypt_state.sender_cipher),
1474     get_cipher_discard_len(pvar->crypt_state.sender_cipher),
1475     pvar);
1476    
1477     //debug_print(10, enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher));
1478     //debug_print(11, enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher));
1479    
1480     pvar->crypt_state.encrypt = cAES128_encrypt;
1481     break;
1482     }
1483    
1484     case SSH2_CIPHER_BLOWFISH_CBC:
1485 doda 3850 case SSH2_CIPHER_BLOWFISH_CTR:
1486 maya 3227 {
1487     struct Enc *enc;
1488    
1489     enc = &pvar->ssh2_keys[MODE_OUT].enc;
1490     cipher_init_SSH2(&pvar->evpcip[MODE_OUT],
1491     enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher),
1492     enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher),
1493     CIPHER_ENCRYPT,
1494     get_cipher_EVP_CIPHER(pvar->crypt_state.sender_cipher),
1495     get_cipher_discard_len(pvar->crypt_state.sender_cipher),
1496     pvar);
1497    
1498     //debug_print(10, enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher));
1499     //debug_print(11, enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher));
1500    
1501     pvar->crypt_state.encrypt = cBlowfish_encrypt2;
1502     break;
1503     }
1504    
1505     case SSH2_CIPHER_ARCFOUR:
1506     case SSH2_CIPHER_ARCFOUR128:
1507     case SSH2_CIPHER_ARCFOUR256:
1508     {
1509     struct Enc *enc;
1510    
1511     enc = &pvar->ssh2_keys[MODE_OUT].enc;
1512     cipher_init_SSH2(&pvar->evpcip[MODE_OUT],
1513     enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher),
1514     enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher),
1515     CIPHER_ENCRYPT,
1516     get_cipher_EVP_CIPHER(pvar->crypt_state.sender_cipher),
1517     get_cipher_discard_len(pvar->crypt_state.sender_cipher),
1518     pvar);
1519     //debug_print(10, enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher));
1520     //debug_print(11, enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher));
1521    
1522     pvar->crypt_state.encrypt = cArcfour_encrypt;
1523     break;
1524     }
1525    
1526     case SSH2_CIPHER_CAST128_CBC:
1527 doda 3850 case SSH2_CIPHER_CAST128_CTR:
1528 maya 3227 {
1529     struct Enc *enc;
1530    
1531     enc = &pvar->ssh2_keys[MODE_OUT].enc;
1532     cipher_init_SSH2(&pvar->evpcip[MODE_OUT],
1533     enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher),
1534     enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher),
1535     CIPHER_ENCRYPT,
1536     get_cipher_EVP_CIPHER(pvar->crypt_state.sender_cipher),
1537     get_cipher_discard_len(pvar->crypt_state.sender_cipher),
1538     pvar);
1539     //debug_print(10, enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher));
1540     //debug_print(11, enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher));
1541    
1542     pvar->crypt_state.encrypt = cCast128_encrypt;
1543     break;
1544     }
1545    
1546 doda 4433 #ifdef WITH_CAMELLIA_DRAFT
1547     case SSH2_CIPHER_CAMELLIA128_CBC:
1548     case SSH2_CIPHER_CAMELLIA192_CBC:
1549     case SSH2_CIPHER_CAMELLIA256_CBC:
1550     case SSH2_CIPHER_CAMELLIA128_CTR:
1551     case SSH2_CIPHER_CAMELLIA192_CTR:
1552     case SSH2_CIPHER_CAMELLIA256_CTR:
1553     {
1554     struct Enc *enc;
1555    
1556     enc = &pvar->ssh2_keys[MODE_OUT].enc;
1557     cipher_init_SSH2(&pvar->evpcip[MODE_OUT],
1558     enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher),
1559     enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher),
1560     CIPHER_ENCRYPT,
1561     get_cipher_EVP_CIPHER(pvar->crypt_state.sender_cipher),
1562     get_cipher_discard_len(pvar->crypt_state.sender_cipher),
1563     pvar);
1564    
1565     //debug_print(10, enc->key, get_cipher_key_len(pvar->crypt_state.sender_cipher));
1566     //debug_print(11, enc->iv, get_cipher_block_size(pvar->crypt_state.sender_cipher));
1567    
1568     pvar->crypt_state.encrypt = cCamellia_encrypt;
1569     break;
1570     }
1571     #endif // WITH_CAMELLIA_DRAFT
1572    
1573 maya 3227 case SSH_CIPHER_3DES:{
1574     c3DES_init(encryption_key, &pvar->crypt_state.enc.c3DES);
1575     pvar->crypt_state.encrypt = c3DES_encrypt;
1576     break;
1577     }
1578     case SSH_CIPHER_IDEA:{
1579     cIDEA_init(encryption_key, &pvar->crypt_state.enc.cIDEA);
1580     pvar->crypt_state.encrypt = cIDEA_encrypt;
1581     break;
1582     }
1583     case SSH_CIPHER_DES:{
1584     cDES_init(encryption_key, &pvar->crypt_state.enc.cDES);
1585     pvar->crypt_state.encrypt = cDES_encrypt;
1586     break;
1587     }
1588     case SSH_CIPHER_RC4:{
1589     RC4_set_key(&pvar->crypt_state.enc.cRC4.k, 16,
1590     encryption_key + 16);
1591     pvar->crypt_state.encrypt = cRC4_encrypt;
1592     break;
1593     }
1594     case SSH_CIPHER_BLOWFISH:{
1595     cBlowfish_init(encryption_key,
1596     &pvar->crypt_state.enc.cBlowfish);
1597     pvar->crypt_state.encrypt = cBlowfish_encrypt;
1598     break;
1599     }
1600     default:
1601     isOK = FALSE;
1602     }
1603     }
1604    
1605    
1606     if (receiver_flag) {
1607     switch (pvar->crypt_state.receiver_cipher) {
1608     // for SSH2(yutaka)
1609     case SSH2_CIPHER_3DES_CBC:
1610 doda 3850 case SSH2_CIPHER_3DES_CTR:
1611 maya 3227 {
1612     struct Enc *enc;
1613    
1614     enc = &pvar->ssh2_keys[MODE_IN].enc;
1615     cipher_init_SSH2(&pvar->evpcip[MODE_IN],
1616     enc->key, get_cipher_key_len(pvar->crypt_state.receiver_cipher),
1617     enc->iv, get_cipher_block_size(pvar->crypt_state.receiver_cipher),
1618     CIPHER_DECRYPT,
1619     get_cipher_EVP_CIPHER(pvar->crypt_state.receiver_cipher),
1620     get_cipher_discard_len(pvar->crypt_state.receiver_cipher),
1621     pvar);
1622    
1623     //debug_print(12, enc->key, get_cipher_key_len(pvar->crypt_state.receiver_cipher));
1624     //debug_print(13, enc->iv, get_cipher_block_size(pvar->crypt_state.receiver_cipher));
1625    
1626 doda 3850 pvar->crypt_state.decrypt = c3DES_decrypt2;
1627 maya 3227 break;
1628     }
1629    
1630     // for SSH2(yutaka)
1631     case SSH2_CIPHER_AES128_CBC:
1632     case SSH2_CIPHER_AES192_CBC:
1633     case SSH2_CIPHER_AES256_CBC:
1634     case SSH2_CIPHER_AES128_CTR:
1635     case SSH2_CIPHER_AES192_CTR:
1636     case SSH2_CIPHER_AES256_CTR:
1637     {
1638     struct Enc *enc;
1639    
1640     enc = &pvar->ssh2_keys[MODE_IN].enc;
1641     cipher_init_SSH2(&pvar->evpcip[MODE_IN],
1642     enc->key, get_cipher_key_len(pvar->crypt_state.receiver_cipher),
1643     enc->iv, get_cipher_block_size(pvar->crypt_state.receiver_cipher),
1644     CIPHER_DECRYPT,
1645     get_cipher_EVP_CIPHER(pvar->crypt_state.receiver_cipher),
1646     get_cipher_discard_len(pvar->crypt_state.receiver_cipher),
1647     pvar);
1648    
1649     //debug_print(12, enc->key, get_cipher_key_len(pvar->crypt_state.receiver_cipher));
1650     //debug_print(13, enc->iv, get_cipher_block_size(pvar->crypt_state.receiver_cipher));
1651    
1652     pvar->crypt_state.decrypt = cAES128_decrypt;
1653     break;
1654     }
1655    
1656     case SSH2_CIPHER_BLOWFISH_CBC:
1657 doda 3850 case SSH2_CIPHER_BLOWFISH_CTR:
1658 maya 3227 {
1659     struct Enc *enc;
1660    
1661     enc = &pvar->ssh2_keys[MODE_IN].enc;
1662     cipher_init_SSH2(&pvar->evpcip[MODE_IN],
1663     enc->key, get_cipher_key_len(pvar->crypt_state.receiver_cipher),
1664     enc->iv, get_cipher_block_size(pvar->crypt_state.receiver_cipher),
1665     CIPHER_DECRYPT,
1666     get_cipher_EVP_CIPHER(pvar->crypt_state.receiver_cipher),
1667     get_cipher_discard_len(pvar->crypt_state.receiver_cipher),
1668     pvar);
1669    
1670     //debug_print(12, enc->key, get_cipher_key_len(pvar->crypt_state.receiver_cipher));
1671     //debug_print(13, enc->iv, get_cipher_block_size(pvar->crypt_state.receiver_cipher));
1672    
1673     pvar->crypt_state.decrypt = cBlowfish_decrypt2;
1674     break;
1675     }
1676    
1677     case SSH2_CIPHER_ARCFOUR:
1678     case SSH2_CIPHER_ARCFOUR128:
1679     case SSH2_CIPHER_ARCFOUR256:
1680     {
1681     struct Enc *enc;
1682    
1683     enc = &pvar->ssh2_keys[MODE_IN].enc;
1684     cipher_init_SSH2(&pvar->evpcip[MODE_IN],
1685     enc->key, get_cipher_key_len(pvar->crypt_state.receiver_cipher),
1686     enc->iv, get_cipher_block_size(pvar->crypt_state.receiver_cipher),
1687     CIPHER_DECRYPT,
1688     get_cipher_EVP_CIPHER(pvar->crypt_state.receiver_cipher),
1689     get_cipher_discard_len(pvar->crypt_state.receiver_cipher),
1690     pvar);
1691    
1692     //debug_print(12, enc->key, get_cipher_key_len(pvar->crypt_state.receiver_cipher));
1693     //debug_print(13, enc->iv, get_cipher_block_size(pvar->crypt_state.receiver_cipher));
1694    
1695     pvar->crypt_state.decrypt = cArcfour_decrypt;
1696     break;
1697     }
1698    
1699     case SSH2_CIPHER_CAST128_CBC:
1700 doda 3850 case SSH2_CIPHER_CAST128_CTR:
1701 maya 3227 {
1702     struct Enc *enc;
1703    
1704     enc = &pvar->ssh2_keys[MODE_IN].enc;
1705     cipher_init_SSH2(&pvar->evpcip[MODE_IN],
1706     enc->key, get_cipher_key_len(pvar->crypt_state.receiver_cipher),
1707     enc->iv, get_cipher_block_size(pvar->crypt_state.receiver_cipher),
1708     CIPHER_DECRYPT,
1709     get_cipher_EVP_CIPHER(pvar->crypt_state.receiver_cipher),
1710     get_cipher_discard_len(pvar->crypt_state.receiver_cipher),
1711     pvar);
1712    
1713     //debug_print(12, enc->key, get_cipher_key_len(pvar->crypt_state.receiver_cipher));
1714     //debug_print(13, enc->iv, get_cipher_block_size(pvar->crypt_state.receiver_cipher));
1715    
1716     pvar->crypt_state.decrypt = cCast128_decrypt;
1717     break;
1718     }
1719    
1720 doda 4433 #ifdef WITH_CAMELLIA_DRAFT
1721     case SSH2_CIPHER_CAMELLIA128_CBC:
1722     case SSH2_CIPHER_CAMELLIA192_CBC:
1723     case SSH2_CIPHER_CAMELLIA256_CBC:
1724     case SSH2_CIPHER_CAMELLIA128_CTR:
1725     case SSH2_CIPHER_CAMELLIA192_CTR:
1726     case SSH2_CIPHER_CAMELLIA256_CTR:
1727     {
1728     struct Enc *enc;
1729    
1730     enc = &pvar->ssh2_keys[MODE_IN].enc;
1731     cipher_init_SSH2(&pvar->evpcip[MODE_IN],
1732     enc->key, get_cipher_key_len(pvar->crypt_state.receiver_cipher),
1733     enc->iv, get_cipher_block_size(pvar->crypt_state.receiver_cipher),
1734     CIPHER_DECRYPT,
1735     get_cipher_EVP_CIPHER(pvar->crypt_state.receiver_cipher),
1736     get_cipher_discard_len(pvar->crypt_state.receiver_cipher),
1737     pvar);
1738    
1739     //debug_print(12, enc->key, get_cipher_key_len(pvar->crypt_state.receiver_cipher));
1740     //debug_print(13, enc->iv, get_cipher_block_size(pvar->crypt_state.receiver_cipher));
1741    
1742     pvar->crypt_state.decrypt = cCamellia_decrypt;
1743     break;
1744     }
1745     #endif // WITH_CAMELLIA_DRAFT
1746    
1747 maya 3227 case SSH_CIPHER_3DES:{
1748     c3DES_init(decryption_key, &pvar->crypt_state.dec.c3DES);
1749     pvar->crypt_state.decrypt = c3DES_decrypt;
1750     break;
1751     }
1752     case SSH_CIPHER_IDEA:{
1753     cIDEA_init(decryption_key, &pvar->crypt_state.dec.cIDEA);
1754     pvar->crypt_state.decrypt = cIDEA_decrypt;
1755     break;
1756     }
1757     case SSH_CIPHER_DES:{
1758     cDES_init(decryption_key, &pvar->crypt_state.dec.cDES);
1759     pvar->crypt_state.decrypt = cDES_decrypt;
1760     break;
1761     }
1762     case SSH_CIPHER_RC4:{
1763     RC4_set_key(&pvar->crypt_state.dec.cRC4.k, 16, decryption_key);
1764     pvar->crypt_state.decrypt = cRC4_decrypt;
1765     break;
1766     }
1767     case SSH_CIPHER_BLOWFISH:{
1768     cBlowfish_init(decryption_key,
1769     &pvar->crypt_state.dec.cBlowfish);
1770     pvar->crypt_state.decrypt = cBlowfish_decrypt;
1771     break;
1772     }
1773     default:
1774     isOK = FALSE;
1775     }
1776     }
1777    
1778    
1779     if (!isOK) {
1780     UTIL_get_lang_msg("MSG_CHPHER_NOTSELECTED_ERROR", pvar,
1781     "No cipher selected!");
1782     notify_fatal_error(pvar, pvar->ts->UIMsg);
1783     return FALSE;
1784     } else {
1785     memset(encryption_key, 0, CRYPT_KEY_LENGTH);
1786     memset(decryption_key, 0, CRYPT_KEY_LENGTH);
1787     return TRUE;
1788     }
1789     }
1790    
1791     void CRYPT_init(PTInstVar pvar)
1792     {
1793     pvar->crypt_state.encrypt = no_encrypt;
1794     pvar->crypt_state.decrypt = no_encrypt;
1795     pvar->crypt_state.sender_cipher = SSH_CIPHER_NONE;
1796     pvar->crypt_state.receiver_cipher = SSH_CIPHER_NONE;
1797     pvar->crypt_state.server_key.RSA_key = NULL;
1798     pvar->crypt_state.host_key.RSA_key = NULL;
1799    
1800     pvar->crypt_state.detect_attack_statics.h = NULL;
1801     pvar->crypt_state.detect_attack_statics.n =
1802     HASH_MINSIZE / HASH_ENTRYSIZE;
1803     }
1804    
1805     static char FAR *get_cipher_name(int cipher)
1806     {
1807     switch (cipher) {
1808     case SSH_CIPHER_NONE:
1809     return "None";
1810     case SSH_CIPHER_3DES:
1811     return "3DES (168 key bits)";
1812     case SSH_CIPHER_DES:
1813     return "DES (56 key bits)";
1814     case SSH_CIPHER_IDEA:
1815     return "IDEA (128 key bits)";
1816     case SSH_CIPHER_RC4:
1817     return "RC4 (128 key bits)";
1818     case SSH_CIPHER_BLOWFISH:
1819     return "Blowfish (256 key bits)";
1820    
1821     // SSH2
1822     case SSH2_CIPHER_3DES_CBC:
1823     return "3DES-CBC";
1824     case SSH2_CIPHER_AES128_CBC:
1825     return "AES128-CBC";
1826     case SSH2_CIPHER_AES192_CBC:
1827     return "AES192-CBC";
1828     case SSH2_CIPHER_AES256_CBC:
1829     return "AES256-CBC";
1830     case SSH2_CIPHER_BLOWFISH_CBC:
1831     return "Blowfish-CBC";
1832     case SSH2_CIPHER_AES128_CTR:
1833     return "AES128-CTR";
1834     case SSH2_CIPHER_AES192_CTR:
1835     return "AES192-CTR";
1836     case SSH2_CIPHER_AES256_CTR:
1837     return "AES256-CTR";
1838     case SSH2_CIPHER_ARCFOUR:
1839     return "Arcfour";
1840     case SSH2_CIPHER_ARCFOUR128:
1841     return "Arcfour128";
1842     case SSH2_CIPHER_ARCFOUR256:
1843     return "Arcfour256";
1844     case SSH2_CIPHER_CAST128_CBC:
1845     return "CAST-128-CBC";
1846 doda 3850 case SSH2_CIPHER_3DES_CTR:
1847     return "3DES-CTR";
1848     case SSH2_CIPHER_BLOWFISH_CTR:
1849     return "Blowfish-CTR";
1850     case SSH2_CIPHER_CAST128_CTR:
1851     return "CAST-128-CTR";
1852 doda 4433 #ifdef WITH_CAMELLIA_DRAFT
1853     case SSH2_CIPHER_CAMELLIA128_CBC:
1854     return "Camellia128-CBC";
1855     case SSH2_CIPHER_CAMELLIA192_CBC:
1856     return "Camellia192-CBC";
1857     case SSH2_CIPHER_CAMELLIA256_CBC:
1858     return "Camellia256-CBC";
1859     case SSH2_CIPHER_CAMELLIA128_CTR:
1860     return "Camellia128-CTR";
1861     case SSH2_CIPHER_CAMELLIA192_CTR:
1862     return "Camellia192-CTR";
1863     case SSH2_CIPHER_CAMELLIA256_CTR:
1864     return "Camellia256-CTR";
1865     #endif // WITH_CAMELLIA_DRAFT
1866 maya 3227
1867     default:
1868     return "Unknown";
1869     }
1870     }
1871    
1872     void CRYPT_get_cipher_info(PTInstVar pvar, char FAR * dest, int len)
1873     {
1874     UTIL_get_lang_msg("DLG_ABOUT_CIPHER_INFO", pvar,
1875     "%s to server, %s from server");
1876     _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg,
1877     get_cipher_name(pvar->crypt_state.sender_cipher),
1878     get_cipher_name(pvar->crypt_state.receiver_cipher));
1879     }
1880    
1881     void CRYPT_get_server_key_info(PTInstVar pvar, char FAR * dest, int len)
1882     {
1883     if (SSHv1(pvar)) {
1884     if (pvar->crypt_state.server_key.RSA_key == NULL
1885     || pvar->crypt_state.host_key.RSA_key == NULL) {
1886     UTIL_get_lang_msg("DLG_ABOUT_KEY_NONE", pvar, "None");
1887     strncpy_s(dest, len, pvar->ts->UIMsg, _TRUNCATE);
1888     } else {
1889     UTIL_get_lang_msg("DLG_ABOUT_KEY_INFO", pvar,
1890     "%d-bit server key, %d-bit host key");
1891     _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg,
1892     BN_num_bits(pvar->crypt_state.server_key.RSA_key->n),
1893     BN_num_bits(pvar->crypt_state.host_key.RSA_key->n));
1894     }
1895     } else { // SSH2
1896 maya 4313 UTIL_get_lang_msg("DLG_ABOUT_KEY_INFO2", pvar,
1897     "%d-bit client key, %d-bit server key");
1898 maya 3227 _snprintf_s(dest, len, _TRUNCATE, pvar->ts->UIMsg,
1899 maya 4313 pvar->client_key_bits,
1900     pvar->server_key_bits);
1901 maya 3227 }
1902     }
1903    
1904 maya 4307 static void destroy_public_key(CRYPTPublicKey * key)
1905 maya 3227 {
1906     if (key->RSA_key != NULL) {
1907     RSA_free(key->RSA_key);
1908     key->RSA_key = NULL;
1909     }
1910     }
1911    
1912 maya 4307 void CRYPT_free_public_key(CRYPTPublicKey * key)
1913 maya 3227 {
1914     destroy_public_key(key);
1915     free(key);
1916     }
1917    
1918     void CRYPT_end(PTInstVar pvar)
1919     {
1920     destroy_public_key(&pvar->crypt_state.host_key);
1921     destroy_public_key(&pvar->crypt_state.server_key);
1922    
1923     if (pvar->crypt_state.detect_attack_statics.h != NULL) {
1924     memset(pvar->crypt_state.detect_attack_statics.h, 0,
1925     pvar->crypt_state.detect_attack_statics.n * HASH_ENTRYSIZE);
1926     free(pvar->crypt_state.detect_attack_statics.h);
1927     }
1928    
1929     memset(pvar->crypt_state.sender_cipher_key, 0,
1930     sizeof(pvar->crypt_state.sender_cipher_key));
1931     memset(pvar->crypt_state.receiver_cipher_key, 0,
1932     sizeof(pvar->crypt_state.receiver_cipher_key));
1933     memset(pvar->crypt_state.server_cookie, 0,
1934     sizeof(pvar->crypt_state.server_cookie));
1935     memset(pvar->crypt_state.client_cookie, 0,
1936     sizeof(pvar->crypt_state.client_cookie));
1937     memset(&pvar->crypt_state.enc, 0, sizeof(pvar->crypt_state.enc));
1938     memset(&pvar->crypt_state.dec, 0, sizeof(pvar->crypt_state.dec));
1939     }
1940    
1941     int CRYPT_passphrase_decrypt(int cipher, char FAR * passphrase,
1942     char FAR * buf, int bytes)
1943     {
1944     unsigned char passphrase_key[16];
1945    
1946     MD5(passphrase, strlen(passphrase), passphrase_key);
1947    
1948     switch (cipher) {
1949     case SSH_CIPHER_3DES:{
1950     Cipher3DESState state;
1951    
1952     DES_set_key((const_DES_cblock FAR *) passphrase_key,
1953     &state.k1);
1954     DES_set_key((const_DES_cblock FAR *) (passphrase_key + 8),
1955     &state.k2);
1956     DES_set_key((const_DES_cblock FAR *) passphrase_key,
1957     &state.k3);
1958     memset(state.ivec1, 0, 8);
1959     memset(state.ivec2, 0, 8);
1960     memset(state.ivec3, 0, 8);
1961     DES_ncbc_encrypt(buf, buf, bytes,
1962     &state.k3, &state.ivec3, DES_DECRYPT);
1963     DES_ncbc_encrypt(buf, buf, bytes,
1964     &state.k2, &state.ivec2, DES_ENCRYPT);
1965     DES_ncbc_encrypt(buf, buf, bytes,
1966     &state.k1, &state.ivec1, DES_DECRYPT);
1967     break;
1968     }
1969    
1970     case SSH_CIPHER_IDEA:{
1971     CipherIDEAState state;
1972     int num = 0;
1973    
1974     cIDEA_init(passphrase_key, &state);
1975     idea_cfb64_encrypt(buf, buf, bytes, &state.k, state.ivec,
1976     &num, IDEA_DECRYPT);
1977     break;
1978     }
1979    
1980     case SSH_CIPHER_DES:{
1981     CipherDESState state;
1982    
1983     cDES_init(passphrase_key, &state);
1984     DES_ncbc_encrypt(buf, buf, bytes,
1985     &state.k, &state.ivec, DES_DECRYPT);
1986     break;
1987     }
1988    
1989     case SSH_CIPHER_RC4:{
1990     CipherRC4State state;
1991     int num = 0;
1992    
1993     RC4_set_key(&state.k, 16, passphrase_key);
1994     RC4(&state.k, bytes, buf, buf);
1995     break;
1996     }
1997    
1998     case SSH_CIPHER_BLOWFISH:{
1999     CipherBlowfishState state;
2000    
2001     BF_set_key(&state.k, 16, passphrase_key);
2002     memset(state.ivec, 0, 8);
2003     flip_endianness(buf, bytes);
2004     BF_cbc_encrypt(buf, buf, bytes, &state.k, state.ivec,
2005     BF_DECRYPT);
2006     flip_endianness(buf, bytes);
2007     break;
2008     }
2009    
2010     case SSH_CIPHER_NONE:
2011     break;
2012    
2013     default:
2014     memset(passphrase_key, 0, sizeof(passphrase_key));
2015     return 0;
2016     }
2017    
2018     memset(passphrase_key, 0, sizeof(passphrase_key));
2019     return 1;
2020     }
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help