cipher: Simplify the cipher dispatcher cipher.c.
[libgcrypt.git] / cipher / cipher-ofb.c
1 /* cipher-ofb.c  - Generic OFB mode implementation
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
3  *               2005, 2007, 2008, 2009, 2011 Free Software Foundation, Inc.
4  *
5  * This file is part of Libgcrypt.
6  *
7  * Libgcrypt is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU Lesser general Public License as
9  * published by the Free Software Foundation; either version 2.1 of
10  * the License, or (at your option) any later version.
11  *
12  * Libgcrypt is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26
27 #include "g10lib.h"
28 #include "cipher.h"
29 #include "ath.h"
30 #include "bufhelp.h"
31 #include "./cipher-internal.h"
32
33
34 gcry_err_code_t
35 _gcry_cipher_ofb_encrypt (gcry_cipher_hd_t c,
36                           unsigned char *outbuf, unsigned int outbuflen,
37                           const unsigned char *inbuf, unsigned int inbuflen)
38 {
39   unsigned char *ivp;
40   size_t blocksize = c->spec->blocksize;
41   unsigned int burn, nburn;
42
43   if (outbuflen < inbuflen)
44     return GPG_ERR_BUFFER_TOO_SHORT;
45
46   if ( inbuflen <= c->unused )
47     {
48       /* Short enough to be encoded by the remaining XOR mask. */
49       /* XOR the input with the IV */
50       ivp = c->u_iv.iv + c->spec->blocksize - c->unused;
51       buf_xor(outbuf, ivp, inbuf, inbuflen);
52       c->unused -= inbuflen;
53       return 0;
54     }
55
56   burn = 0;
57
58   if( c->unused )
59     {
60       inbuflen -= c->unused;
61       ivp = c->u_iv.iv + blocksize - c->unused;
62       buf_xor(outbuf, ivp, inbuf, c->unused);
63       outbuf += c->unused;
64       inbuf += c->unused;
65       c->unused = 0;
66     }
67
68   /* Now we can process complete blocks. */
69   while ( inbuflen >= blocksize )
70     {
71       /* Encrypt the IV (and save the current one). */
72       memcpy( c->lastiv, c->u_iv.iv, blocksize );
73       nburn = c->spec->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
74       burn = nburn > burn ? nburn : burn;
75       buf_xor(outbuf, c->u_iv.iv, inbuf, blocksize);
76       outbuf += blocksize;
77       inbuf += blocksize;
78       inbuflen -= blocksize;
79     }
80   if ( inbuflen )
81     { /* process the remaining bytes */
82       memcpy( c->lastiv, c->u_iv.iv, blocksize );
83       nburn = c->spec->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
84       burn = nburn > burn ? nburn : burn;
85       c->unused = blocksize;
86       c->unused -= inbuflen;
87       buf_xor(outbuf, c->u_iv.iv, inbuf, inbuflen);
88       outbuf += inbuflen;
89       inbuf += inbuflen;
90       inbuflen = 0;
91     }
92
93   if (burn > 0)
94     _gcry_burn_stack (burn + 4 * sizeof(void *));
95
96   return 0;
97 }
98
99
100 gcry_err_code_t
101 _gcry_cipher_ofb_decrypt (gcry_cipher_hd_t c,
102                           unsigned char *outbuf, unsigned int outbuflen,
103                           const unsigned char *inbuf, unsigned int inbuflen)
104 {
105   unsigned char *ivp;
106   size_t blocksize = c->spec->blocksize;
107   unsigned int burn, nburn;
108
109   if (outbuflen < inbuflen)
110     return GPG_ERR_BUFFER_TOO_SHORT;
111
112   if( inbuflen <= c->unused )
113     {
114       /* Short enough to be encoded by the remaining XOR mask. */
115       ivp = c->u_iv.iv + blocksize - c->unused;
116       buf_xor(outbuf, ivp, inbuf, inbuflen);
117       c->unused -= inbuflen;
118       return 0;
119     }
120
121   burn = 0;
122
123   if ( c->unused )
124     {
125       inbuflen -= c->unused;
126       ivp = c->u_iv.iv + blocksize - c->unused;
127       buf_xor(outbuf, ivp, inbuf, c->unused);
128       outbuf += c->unused;
129       inbuf += c->unused;
130       c->unused = 0;
131     }
132
133   /* Now we can process complete blocks. */
134   while ( inbuflen >= blocksize )
135     {
136       /* Encrypt the IV (and save the current one). */
137       memcpy( c->lastiv, c->u_iv.iv, blocksize );
138       nburn = c->spec->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
139       burn = nburn > burn ? nburn : burn;
140       buf_xor(outbuf, c->u_iv.iv, inbuf, blocksize);
141       outbuf += blocksize;
142       inbuf += blocksize;
143       inbuflen -= blocksize;
144     }
145   if ( inbuflen )
146     { /* Process the remaining bytes. */
147       /* Encrypt the IV (and save the current one). */
148       memcpy( c->lastiv, c->u_iv.iv, blocksize );
149       nburn = c->spec->encrypt ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
150       burn = nburn > burn ? nburn : burn;
151       c->unused = blocksize;
152       c->unused -= inbuflen;
153       buf_xor(outbuf, c->u_iv.iv, inbuf, inbuflen);
154       outbuf += inbuflen;
155       inbuf += inbuflen;
156       inbuflen = 0;
157     }
158
159   if (burn > 0)
160     _gcry_burn_stack (burn + 4 * sizeof(void *));
161
162   return 0;
163 }