Improve the speed of the cipher mode code
[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   gcry_cipher_encrypt_t enc_fn = c->spec->encrypt;
41   size_t blocksize = c->spec->blocksize;
42   unsigned int burn, nburn;
43
44   if (outbuflen < inbuflen)
45     return GPG_ERR_BUFFER_TOO_SHORT;
46
47   if ( inbuflen <= c->unused )
48     {
49       /* Short enough to be encoded by the remaining XOR mask. */
50       /* XOR the input with the IV */
51       ivp = c->u_iv.iv + blocksize - c->unused;
52       buf_xor(outbuf, ivp, inbuf, inbuflen);
53       c->unused -= inbuflen;
54       return 0;
55     }
56
57   burn = 0;
58
59   if( c->unused )
60     {
61       inbuflen -= c->unused;
62       ivp = c->u_iv.iv + blocksize - c->unused;
63       buf_xor(outbuf, ivp, inbuf, c->unused);
64       outbuf += c->unused;
65       inbuf += c->unused;
66       c->unused = 0;
67     }
68
69   /* Now we can process complete blocks. */
70   while ( inbuflen >= blocksize )
71     {
72       /* Encrypt the IV (and save the current one). */
73       buf_cpy( c->lastiv, c->u_iv.iv, blocksize );
74       nburn = enc_fn ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
75       burn = nburn > burn ? nburn : burn;
76       buf_xor(outbuf, c->u_iv.iv, inbuf, blocksize);
77       outbuf += blocksize;
78       inbuf += blocksize;
79       inbuflen -= blocksize;
80     }
81   if ( inbuflen )
82     { /* process the remaining bytes */
83       buf_cpy( c->lastiv, c->u_iv.iv, blocksize );
84       nburn = enc_fn ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
85       burn = nburn > burn ? nburn : burn;
86       c->unused = blocksize;
87       c->unused -= inbuflen;
88       buf_xor(outbuf, c->u_iv.iv, inbuf, inbuflen);
89       outbuf += inbuflen;
90       inbuf += inbuflen;
91       inbuflen = 0;
92     }
93
94   if (burn > 0)
95     _gcry_burn_stack (burn + 4 * sizeof(void *));
96
97   return 0;
98 }
99
100
101 gcry_err_code_t
102 _gcry_cipher_ofb_decrypt (gcry_cipher_hd_t c,
103                           unsigned char *outbuf, unsigned int outbuflen,
104                           const unsigned char *inbuf, unsigned int inbuflen)
105 {
106   unsigned char *ivp;
107   gcry_cipher_encrypt_t enc_fn = c->spec->encrypt;
108   size_t blocksize = c->spec->blocksize;
109   unsigned int burn, nburn;
110
111   if (outbuflen < inbuflen)
112     return GPG_ERR_BUFFER_TOO_SHORT;
113
114   if( inbuflen <= c->unused )
115     {
116       /* Short enough to be encoded by the remaining XOR mask. */
117       ivp = c->u_iv.iv + blocksize - c->unused;
118       buf_xor(outbuf, ivp, inbuf, inbuflen);
119       c->unused -= inbuflen;
120       return 0;
121     }
122
123   burn = 0;
124
125   if ( c->unused )
126     {
127       inbuflen -= c->unused;
128       ivp = c->u_iv.iv + blocksize - c->unused;
129       buf_xor(outbuf, ivp, inbuf, c->unused);
130       outbuf += c->unused;
131       inbuf += c->unused;
132       c->unused = 0;
133     }
134
135   /* Now we can process complete blocks. */
136   while ( inbuflen >= blocksize )
137     {
138       /* Encrypt the IV (and save the current one). */
139       buf_cpy( c->lastiv, c->u_iv.iv, blocksize );
140       nburn = enc_fn ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
141       burn = nburn > burn ? nburn : burn;
142       buf_xor(outbuf, c->u_iv.iv, inbuf, blocksize);
143       outbuf += blocksize;
144       inbuf += blocksize;
145       inbuflen -= blocksize;
146     }
147   if ( inbuflen )
148     { /* Process the remaining bytes. */
149       /* Encrypt the IV (and save the current one). */
150       buf_cpy( c->lastiv, c->u_iv.iv, blocksize );
151       nburn = enc_fn ( &c->context.c, c->u_iv.iv, c->u_iv.iv );
152       burn = nburn > burn ? nburn : burn;
153       c->unused = blocksize;
154       c->unused -= inbuflen;
155       buf_xor(outbuf, c->u_iv.iv, inbuf, inbuflen);
156       outbuf += inbuflen;
157       inbuf += inbuflen;
158       inbuflen = 0;
159     }
160
161   if (burn > 0)
162     _gcry_burn_stack (burn + 4 * sizeof(void *));
163
164   return 0;
165 }