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