cipher reorganisiert
[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;} 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         c->unused -= nbytes;
229         for(ivp=c->iv+STD_BLOCKSIZE - c->unused; nbytes; nbytes-- )
230             *outbuf++ = (*ivp++ ^= *inbuf++);
231         return;
232     }
233
234     if( c->unused ) {
235         /* XOR the input with the IV and store input into IV */
236         nbytes -= c->unused;
237         for(ivp=c->iv+STD_BLOCKSIZE - c->unused; c->unused; c->unused-- )
238             *outbuf++ = (*ivp++ ^= *inbuf++);
239     }
240
241     /* now we can process complete blocks */
242     while( nbytes >= STD_BLOCKSIZE ) {
243         int i;
244         /* encrypt the IV (and save the current one) */
245         memcpy( c->lastiv, c->iv, STD_BLOCKSIZE );
246         (*c->encrypt)( &c->c.context, c->iv, c->iv );
247         /* XOR the input with the IV and store input into IV */
248         for(ivp=c->iv,i=0; i < STD_BLOCKSIZE; i++ )
249             *outbuf++ = (*ivp++ ^= *inbuf++);
250         nbytes -= STD_BLOCKSIZE;
251     }
252     if( nbytes ) { /* process the remaining bytes */
253         /* encrypt the IV (and save the current one) */
254         memcpy( c->lastiv, c->iv, STD_BLOCKSIZE );
255         (*c->encrypt)( &c->c.context, c->iv, c->iv );
256         c->unused = STD_BLOCKSIZE;
257         /* and apply the xor */
258         c->unused -= nbytes;
259         for(ivp=c->iv; nbytes; nbytes-- )
260             *outbuf++ = (*ivp++ ^= *inbuf++);
261     }
262 }
263
264
265 static void
266 do_cfb_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
267 {
268     byte *ivp;
269     ulong temp;
270
271     if( nbytes <= c->unused ) {
272         /* short enough to be encoded by the remaining XOR mask */
273         /* XOR the input with the IV and store input into IV */
274         c->unused -= nbytes;
275         for(ivp=c->iv+STD_BLOCKSIZE - c->unused; nbytes; nbytes-- ) {
276             temp = *inbuf++;
277             *outbuf++ = *ivp ^ temp;
278             *ivp++ = temp;
279         }
280         return;
281     }
282
283     if( c->unused ) {
284         /* XOR the input with the IV and store input into IV */
285         nbytes -= c->unused;
286         for(ivp=c->iv+STD_BLOCKSIZE - c->unused; c->unused; c->unused-- ) {
287             temp = *inbuf++;
288             *outbuf++ = *ivp ^ temp;
289             *ivp++ = temp;
290         }
291     }
292
293     /* now we can process complete blocks */
294   #ifdef BIG_ENDIAN_HOST
295     /* This does only make sense for big endian hosts, due to ... ivp = temp*/
296     if( !((ulong)inbuf % SIZEOF_UNSIGNED_LONG) ) {
297         while( nbytes >= STD_BLOCKSIZE ) {
298             /* encrypt the IV (and save the current one) */
299             memcpy( c->lastiv, c->iv, STD_BLOCKSIZE );
300             (*c->encrypt)( &c->c.context, c->iv, c->iv );
301             ivp = c->iv;
302             /* XOR the input with the IV and store input into IV */
303           #if SIZEOF_UNSIGNED_LONG == STD_BLOCKSIZE
304             temp = *(ulong*)inbuf;
305             *(ulong*)outbuf = *(ulong*)c->iv ^ temp;
306             *(ulong*)ivp    = temp;
307           #elif (2*SIZEOF_UNSIGNED_LONG) == STD_BLOCKSIZE
308             temp = ((ulong*)inbuf)[0];
309             ((ulong*)outbuf)[0] = ((ulong*)c->iv)[0] ^ temp;
310             ((ulong*)ivp)[0] = temp;
311             temp = ((ulong*)inbuf)[1];
312             ((ulong*)outbuf)[1] = ((ulong*)c->iv)[1] ^ temp;
313             ((ulong*)ivp)[1] = temp;
314           #elif (4*SIZEOF_UNSIGNED_LONG) == STD_BLOCKSIZE
315             temp = ((ulong*)inbuf)[0];
316             ((ulong*)outbuf)[0] = ((ulong*)c->iv)[0] ^ temp;
317             ((ulong*)ivp)[0] = temp;
318             temp = ((ulong*)inbuf)[1];
319             ((ulong*)outbuf)[1] = ((ulong*)c->iv)[1] ^ temp;
320             ((ulong*)ivp)[1] = temp;
321             temp = ((ulong*)inbuf)[2];
322             ((ulong*)outbuf)[2] = ((ulong*)c->iv)[2] ^ temp;
323             ((ulong*)ivp)[2] = temp;
324             temp = ((ulong*)inbuf)[3];
325             ((ulong*)outbuf)[3] = ((ulong*)c->iv)[3] ^ temp;
326             ((ulong*)ivp)[3] = temp;
327           #else
328             #error Please disable the align test.
329           #endif
330             nbytes -= STD_BLOCKSIZE;
331         }
332     }
333     else { /* non aligned version */
334   #endif /* BIG_ENDIAN_HOST */
335         while( nbytes >= STD_BLOCKSIZE ) {
336             int i;
337             /* encrypt the IV (and save the current one) */
338             memcpy( c->lastiv, c->iv, STD_BLOCKSIZE );
339             (*c->encrypt)( &c->c.context, c->iv, c->iv );
340             /* XOR the input with the IV and store input into IV */
341             for(ivp=c->iv,i=0; i < STD_BLOCKSIZE; i++ ) {
342                 temp = *inbuf++;
343                 *outbuf++ = *ivp ^ temp;
344                 *ivp++ = temp;
345             }
346             nbytes -= STD_BLOCKSIZE;
347         }
348    #ifdef BIG_ENDIAN_HOST
349     }
350    #endif
351     if( nbytes ) { /* process the remaining bytes */
352         /* encrypt the IV (and save the current one) */
353         memcpy( c->lastiv, c->iv, STD_BLOCKSIZE );
354         (*c->encrypt)( &c->c.context, c->iv, c->iv );
355         c->unused = STD_BLOCKSIZE;
356         /* and apply the xor */
357         c->unused -= nbytes;
358         for(ivp=c->iv; nbytes; nbytes-- ) {
359             temp = *inbuf++;
360             *outbuf++ = *ivp ^ temp;
361             *ivp++ = temp;
362         }
363     }
364 }
365
366
367 /****************
368  * Encrypt INBUF to OUTBUF with the mode selected at open.
369  * inbuf and outbuf may overlap or be the same.
370  * Depending on the mode some some contraints apply to NBYTES.
371  */
372 void
373 cipher_encrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
374 {
375     switch( c->mode ) {
376       case CIPHER_MODE_ECB:
377         assert(!(nbytes%8));
378         do_ecb_encrypt(c, outbuf, inbuf, nbytes/8 );
379         break;
380       case CIPHER_MODE_CFB:
381       case CIPHER_MODE_PHILS_CFB:
382         do_cfb_encrypt(c, outbuf, inbuf, nbytes );
383         break;
384       default: log_fatal("cipher_encrypt: invalid mode %d\n", c->mode );
385     }
386 }
387
388
389 /****************
390  * Decrypt INBUF to OUTBUF with the mode selected at open.
391  * inbuf and outbuf may overlap or be the same.
392  * Depending on the mode some some contraints apply to NBYTES.
393  */
394 void
395 cipher_decrypt( CIPHER_HANDLE c, byte *outbuf, byte *inbuf, unsigned nbytes )
396 {
397     switch( c->mode ) {
398       case CIPHER_MODE_ECB:
399         assert(!(nbytes%8));
400         do_ecb_decrypt(c, outbuf, inbuf, nbytes/8 );
401         break;
402       case CIPHER_MODE_CFB:
403       case CIPHER_MODE_PHILS_CFB:
404         do_cfb_decrypt(c, outbuf, inbuf, nbytes );
405         break;
406       default: log_fatal("cipher_decrypt: invalid mode %d\n", c->mode );
407     }
408 }
409
410
411
412 /****************
413  * Used for PGP's somewhat strange CFB mode. Does only work if
414  * the handle is in PHILS_CFB mode
415  */
416 void
417 cipher_sync( CIPHER_HANDLE c )
418 {
419     if( c->mode == CIPHER_MODE_PHILS_CFB && c->unused ) {
420         memmove(c->iv + c->unused, c->iv, CAST5_BLOCKSIZE - c->unused );
421         memcpy(c->iv, c->lastiv + CAST5_BLOCKSIZE - c->unused, c->unused);
422         c->unused = 0;
423     }
424 }
425