c6b296b360bad67b16a8c289023f0bc93fa5f5b0
[gnupg.git] / cipher / cipher.c
1 /* cipher.c  -  cipher dispatcher
2  *      Copyright (C) 1998 Free Software Foundation, Inc.
3  *
4  * This file is part of GNUPG.
5  *
6  * GNUPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GNUPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #define DEFINES_CIPHER_HANDLE 1
22
23 #include <config.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <errno.h>
28 #include <assert.h>
29 #include "util.h"
30 #include "errors.h"
31 #include "cipher.h"
32 #include "blowfish.h"
33 #include "cast5.h"
34 #include "des.h"
35
36 #define STD_BLOCKSIZE 8
37
38 #if BLOWFISH_BLOCKSIZE != STD_BLOCKSIZE
39   #error Invalid BLOWFISH blocksize
40 #elif CAST5_BLOCKSIZE != STD_BLOCKSIZE
41   #error Invalid CAST blocksize
42 #elif DES_BLOCKSIZE != STD_BLOCKSIZE
43   #error Invalid DES blocksize
44 #endif
45
46
47 static struct { const char *name; int algo; int keylen; } cipher_names[] = {
48     { "IDEA",        CIPHER_ALGO_IDEA        ,0   },
49     { "3DES",        CIPHER_ALGO_3DES        ,168 },
50     { "CAST",        CIPHER_ALGO_CAST        ,128 },
51     { "BLOWFISH160", CIPHER_ALGO_BLOWFISH160 ,160 },
52     { "SAFER_SK128", CIPHER_ALGO_SAFER_SK128 ,0   },
53     { "DES_SK",      CIPHER_ALGO_DES_SK      ,0   },
54     { "BLOWFISH",    CIPHER_ALGO_BLOWFISH    ,128 },
55     { "DUMMY"   ,    CIPHER_ALGO_DUMMY       ,128 },
56     {NULL} };
57
58
59 /* Hmmm, no way for a void arg in function pointer? */
60 #define FNCCAST_SETKEY(f)  (void(*)(void*, byte*, unsigned))(f)
61 #define FNCCAST_CRYPT(f)   (void(*)(void*, byte*, byte*))(f)
62
63
64 struct cipher_handle_s {
65     int  algo;
66     int  mode;
67     byte iv[STD_BLOCKSIZE];     /* (this should be ulong aligned) */
68     byte lastiv[STD_BLOCKSIZE];
69     int  unused;  /* in IV */
70     void (*setkey)( void *c, byte *key, unsigned keylen );
71     void (*encrypt)( void *c, byte *outbuf, byte *inbuf );
72     void (*decrypt)( void *c, byte *outbuf, byte *inbuf );
73     void (*sync_cfb)( void *c );
74     union {
75         int              context;
76         BLOWFISH_context blowfish;
77         CAST5_context cast5;
78     } c;
79 };
80
81
82 static void
83 dummy_setkey( void *c, byte *key, unsigned keylen ) { }
84 static void
85 dummy_encrypt_block( void *c, byte *outbuf, byte *inbuf ) { BUG(); }
86 static void
87 dummy_decrypt_block( void *c, byte *outbuf, byte *inbuf ) { BUG(); }
88
89
90 /****************
91  * Map a string to the cipher algo
92  */
93 int
94 string_to_cipher_algo( const char *string )
95 {
96     int i;
97     const char *s;
98
99     for(i=0; (s=cipher_names[i].name); i++ )
100         if( !stricmp( s, string ) )
101             return cipher_names[i].algo;
102     return 0;
103 }
104
105 /****************
106  * Map a cipher algo to a string
107  */
108 const char *
109 cipher_algo_to_string( int algo )
110 {
111     int i;
112
113     for(i=0; cipher_names[i].name; i++ )
114         if( cipher_names[i].algo == algo )
115             return cipher_names[i].name;
116     return NULL;
117 }
118
119 /****************
120  * Return 0 if the cipher algo is available
121  */
122 int
123 check_cipher_algo( int algo )
124 {
125     switch( algo ) {
126       case CIPHER_ALGO_BLOWFISH160:
127       case CIPHER_ALGO_BLOWFISH:
128       case CIPHER_ALGO_CAST:
129       case CIPHER_ALGO_3DES:
130       case CIPHER_ALGO_DUMMY:
131         return 0;
132       default:
133         return G10ERR_CIPHER_ALGO;
134     }
135 }
136
137
138 unsigned
139 cipher_get_keylen( int algo )
140 {
141     int i;
142     unsigned len = 0;
143
144     for(i=0; cipher_names[i].name; i++ )
145         if( cipher_names[i].algo == algo ) {
146             len = cipher_names[i].keylen;
147             break;
148         }
149     if( !len )
150         log_bug("cipher %d w/o key length\n", algo );
151     return len;
152 }
153
154
155 /****************
156  * Open a cipher handle for use with algorithm ALGO, in mode MODE
157  * and put it into secure memory if SECURE is true.
158  */
159 CIPHER_HANDLE
160 cipher_open( int algo, int mode, int secure )
161 {
162     CIPHER_HANDLE hd;
163
164     fast_random_poll();
165     /* performance hint:
166      * It is possible to allocate less memory depending on the cipher */
167     hd = secure ? m_alloc_secure_clear( sizeof *hd )
168                 : m_alloc_clear( sizeof *hd );
169     hd->algo = algo;
170     if( algo == CIPHER_ALGO_DUMMY )
171         hd->mode = CIPHER_MODE_DUMMY;
172     else if( mode == CIPHER_MODE_AUTO_CFB ) {
173         if( algo != CIPHER_ALGO_BLOWFISH160 )
174             hd->mode = CIPHER_MODE_PHILS_CFB;
175         else
176             hd->mode = CIPHER_MODE_CFB;
177     }
178     else
179         hd->mode = mode;
180     switch( algo )  {
181       case CIPHER_ALGO_BLOWFISH:
182       case CIPHER_ALGO_BLOWFISH160:
183         hd->setkey  = FNCCAST_SETKEY(blowfish_setkey);
184         hd->encrypt = FNCCAST_CRYPT(blowfish_encrypt_block);
185         hd->decrypt = FNCCAST_CRYPT(blowfish_decrypt_block);
186         break;
187
188       case CIPHER_ALGO_CAST:
189         hd->setkey  = FNCCAST_SETKEY(cast5_setkey);
190         hd->encrypt = FNCCAST_CRYPT(cast5_encrypt_block);
191         hd->decrypt = FNCCAST_CRYPT(cast5_decrypt_block);
192         break;
193 #if 0
194       case CIPHER_ALGO_3DES:
195         hd->setkey  = FNCCAST_SETKEY(des_3des_setkey);
196         hd->encrypt = FNCCAST_CRYPT(des_encrypt_block);
197         hd->decrypt = FNCCAST_CRYPT(des_decrypt_block);
198         break;
199 #endif
200       case CIPHER_ALGO_DUMMY:
201         hd->setkey  = FNCCAST_SETKEY(dummy_setkey);
202         hd->encrypt = FNCCAST_CRYPT(dummy_encrypt_block);
203         hd->decrypt = FNCCAST_CRYPT(dummy_decrypt_block);
204         break;
205
206       default: log_fatal("cipher_open: invalid algo %d\n", algo );
207     }
208
209     return hd;
210 }
211
212
213 void
214 cipher_close( CIPHER_HANDLE c )
215 {
216     m_free(c);
217 }
218
219
220 void
221 cipher_setkey( CIPHER_HANDLE c, byte *key, unsigned keylen )
222 {
223     (*c->setkey)( &c->c.context, key, keylen );
224 }
225
226
227
228 void
229 cipher_setiv( CIPHER_HANDLE c, const byte *iv )
230 {
231     if( iv )
232         memcpy( c->iv, iv, STD_BLOCKSIZE );
233     else
234         memset( c->iv, 0, STD_BLOCKSIZE );
235     c->unused = 0;
236 }
237
238
239
240 static void
241 do_ecb_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nblocks )
242 {
243     unsigned n;
244
245     for(n=0; n < nblocks; n++ ) {
246         (*c->encrypt)( &c->c.context, outbuf, inbuf );
247         inbuf  += STD_BLOCKSIZE;;
248         outbuf += STD_BLOCKSIZE;
249     }
250 }
251
252 static void
253 do_ecb_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nblocks )
254 {
255     unsigned n;
256
257     for(n=0; n < nblocks; n++ ) {
258         (*c->decrypt)( &c->c.context, outbuf, inbuf );
259         inbuf  += STD_BLOCKSIZE;;
260         outbuf += STD_BLOCKSIZE;
261     }
262 }
263
264
265 static void
266 do_cfb_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
267 {
268     byte *ivp;
269
270     if( nbytes <= c->unused ) {
271         /* short enough to be encoded by the remaining XOR mask */
272         /* XOR the input with the IV and store input into IV */
273         for(ivp=c->iv+STD_BLOCKSIZE - c->unused; nbytes; nbytes--, c->unused-- )
274             *outbuf++ = (*ivp++ ^= *inbuf++);
275         return;
276     }
277
278     if( c->unused ) {
279         /* XOR the input with the IV and store input into IV */
280         nbytes -= c->unused;
281         for(ivp=c->iv+STD_BLOCKSIZE - c->unused; c->unused; c->unused-- )
282             *outbuf++ = (*ivp++ ^= *inbuf++);
283     }
284
285     /* now we can process complete blocks */
286     while( nbytes >= STD_BLOCKSIZE ) {
287         int i;
288         /* encrypt the IV (and save the current one) */
289         memcpy( c->lastiv, c->iv, STD_BLOCKSIZE );
290         (*c->encrypt)( &c->c.context, c->iv, c->iv );
291         /* XOR the input with the IV and store input into IV */
292         for(ivp=c->iv,i=0; i < STD_BLOCKSIZE; i++ )
293             *outbuf++ = (*ivp++ ^= *inbuf++);
294         nbytes -= STD_BLOCKSIZE;
295     }
296     if( nbytes ) { /* process the remaining bytes */
297         /* encrypt the IV (and save the current one) */
298         memcpy( c->lastiv, c->iv, STD_BLOCKSIZE );
299         (*c->encrypt)( &c->c.context, c->iv, c->iv );
300         c->unused = STD_BLOCKSIZE;
301         /* and apply the xor */
302         c->unused -= nbytes;
303         for(ivp=c->iv; nbytes; nbytes-- )
304             *outbuf++ = (*ivp++ ^= *inbuf++);
305     }
306 }
307
308
309 static void
310 do_cfb_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
311 {
312     byte *ivp;
313     ulong temp;
314
315     if( nbytes <= c->unused ) {
316         /* short enough to be encoded by the remaining XOR mask */
317         /* XOR the input with the IV and store input into IV */
318         for(ivp=c->iv+STD_BLOCKSIZE - c->unused; nbytes; nbytes--,c->unused--){
319             temp = *inbuf++;
320             *outbuf++ = *ivp ^ temp;
321             *ivp++ = temp;
322         }
323         return;
324     }
325
326     if( c->unused ) {
327         /* XOR the input with the IV and store input into IV */
328         nbytes -= c->unused;
329         for(ivp=c->iv+STD_BLOCKSIZE - c->unused; c->unused; c->unused-- ) {
330             temp = *inbuf++;
331             *outbuf++ = *ivp ^ temp;
332             *ivp++ = temp;
333         }
334     }
335
336     /* now we can process complete blocks */
337   #ifdef BIG_ENDIAN_HOST
338     /* This does only make sense for big endian hosts, due to ... ivp = temp*/
339     if( !((ulong)inbuf % SIZEOF_UNSIGNED_LONG) ) {
340         while( nbytes >= STD_BLOCKSIZE ) {
341             /* encrypt the IV (and save the current one) */
342             memcpy( c->lastiv, c->iv, STD_BLOCKSIZE );
343             (*c->encrypt)( &c->c.context, c->iv, c->iv );
344             ivp = c->iv;
345             /* XOR the input with the IV and store input into IV */
346           #if SIZEOF_UNSIGNED_LONG == STD_BLOCKSIZE
347             temp = *(ulong*)inbuf;
348             *(ulong*)outbuf = *(ulong*)c->iv ^ temp;
349             *(ulong*)ivp    = temp;
350           #elif (2*SIZEOF_UNSIGNED_LONG) == STD_BLOCKSIZE
351             temp = ((ulong*)inbuf)[0];
352             ((ulong*)outbuf)[0] = ((ulong*)c->iv)[0] ^ temp;
353             ((ulong*)ivp)[0] = temp;
354             temp = ((ulong*)inbuf)[1];
355             ((ulong*)outbuf)[1] = ((ulong*)c->iv)[1] ^ temp;
356             ((ulong*)ivp)[1] = temp;
357           #elif (4*SIZEOF_UNSIGNED_LONG) == STD_BLOCKSIZE
358             temp = ((ulong*)inbuf)[0];
359             ((ulong*)outbuf)[0] = ((ulong*)c->iv)[0] ^ temp;
360             ((ulong*)ivp)[0] = temp;
361             temp = ((ulong*)inbuf)[1];
362             ((ulong*)outbuf)[1] = ((ulong*)c->iv)[1] ^ temp;
363             ((ulong*)ivp)[1] = temp;
364             temp = ((ulong*)inbuf)[2];
365             ((ulong*)outbuf)[2] = ((ulong*)c->iv)[2] ^ temp;
366             ((ulong*)ivp)[2] = temp;
367             temp = ((ulong*)inbuf)[3];
368             ((ulong*)outbuf)[3] = ((ulong*)c->iv)[3] ^ temp;
369             ((ulong*)ivp)[3] = temp;
370           #else
371             #error Please disable the align test.
372           #endif
373             nbytes -= STD_BLOCKSIZE;
374         }
375     }
376     else { /* non aligned version */
377   #endif /* BIG_ENDIAN_HOST */
378         while( nbytes >= STD_BLOCKSIZE ) {
379             int i;
380             /* encrypt the IV (and save the current one) */
381             memcpy( c->lastiv, c->iv, STD_BLOCKSIZE );
382             (*c->encrypt)( &c->c.context, c->iv, c->iv );
383             /* XOR the input with the IV and store input into IV */
384             for(ivp=c->iv,i=0; i < STD_BLOCKSIZE; i++ ) {
385                 temp = *inbuf++;
386                 *outbuf++ = *ivp ^ temp;
387                 *ivp++ = temp;
388             }
389             nbytes -= STD_BLOCKSIZE;
390         }
391    #ifdef BIG_ENDIAN_HOST
392     }
393    #endif
394     if( nbytes ) { /* process the remaining bytes */
395         /* encrypt the IV (and save the current one) */
396         memcpy( c->lastiv, c->iv, STD_BLOCKSIZE );
397         (*c->encrypt)( &c->c.context, c->iv, c->iv );
398         c->unused = STD_BLOCKSIZE;
399         /* and apply the xor */
400         c->unused -= nbytes;
401         for(ivp=c->iv; nbytes; nbytes-- ) {
402             temp = *inbuf++;
403             *outbuf++ = *ivp ^ temp;
404             *ivp++ = temp;
405         }
406     }
407 }
408
409
410 /****************
411  * Encrypt INBUF to OUTBUF with the mode selected at open.
412  * inbuf and outbuf may overlap or be the same.
413  * Depending on the mode some some contraints apply to NBYTES.
414  */
415 void
416 cipher_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
417 {
418     switch( c->mode ) {
419       case CIPHER_MODE_ECB:
420         assert(!(nbytes%8));
421         do_ecb_encrypt(c, outbuf, inbuf, nbytes/8 );
422         break;
423       case CIPHER_MODE_CFB:
424       case CIPHER_MODE_PHILS_CFB:
425         do_cfb_encrypt(c, outbuf, inbuf, nbytes );
426         break;
427       case CIPHER_MODE_DUMMY:
428         if( inbuf != outbuf )
429             memmove( outbuf, inbuf, nbytes );
430         break;
431       default: log_fatal("cipher_encrypt: invalid mode %d\n", c->mode );
432     }
433 }
434
435
436 /****************
437  * Decrypt INBUF to OUTBUF with the mode selected at open.
438  * inbuf and outbuf may overlap or be the same.
439  * Depending on the mode some some contraints apply to NBYTES.
440  */
441 void
442 cipher_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
443 {
444     switch( c->mode ) {
445       case CIPHER_MODE_ECB:
446         assert(!(nbytes%8));
447         do_ecb_decrypt(c, outbuf, inbuf, nbytes/8 );
448         break;
449       case CIPHER_MODE_CFB:
450       case CIPHER_MODE_PHILS_CFB:
451         do_cfb_decrypt(c, outbuf, inbuf, nbytes );
452         break;
453       case CIPHER_MODE_DUMMY:
454         if( inbuf != outbuf )
455             memmove( outbuf, inbuf, nbytes );
456         break;
457       default: log_fatal("cipher_decrypt: invalid mode %d\n", c->mode );
458     }
459 }
460
461
462
463 /****************
464  * Used for PGP's somewhat strange CFB mode. Only works if
465  * the handle is in PHILS_CFB mode
466  */
467 void
468 cipher_sync( CIPHER_HANDLE c )
469 {
470     if( c->mode == CIPHER_MODE_PHILS_CFB && c->unused ) {
471         memmove(c->iv + c->unused, c->iv, STD_BLOCKSIZE - c->unused );
472         memcpy(c->iv, c->lastiv + STD_BLOCKSIZE - c->unused, c->unused);
473         c->unused = 0;
474     }
475 }
476