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