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