b40f4e53a6428005c3508a51ac42dd329241c3d5
[openssl.git] / crypto / aes / aes_ige.c
1 /*
2  * Copyright 2006-2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 /*
11  * AES_encrypt/AES_decrypt are deprecated - but we need to use them to implement
12  * these functions
13  */
14 #include "internal/deprecated.h"
15
16 #include "internal/cryptlib.h"
17
18 #ifdef OPENSSL_NO_DEPRECATED_3_0
19 NON_EMPTY_TRANSLATION_UNIT
20 #else
21
22 #include <openssl/aes.h>
23 #include "aes_local.h"
24
25 #define N_WORDS (AES_BLOCK_SIZE / sizeof(unsigned long))
26 typedef struct {
27     unsigned long data[N_WORDS];
28 } aes_block_t;
29
30 /* XXX: probably some better way to do this */
31 #if defined(__i386__) || defined(__x86_64__)
32 # define UNALIGNED_MEMOPS_ARE_FAST 1
33 #else
34 # define UNALIGNED_MEMOPS_ARE_FAST 0
35 #endif
36
37 #if UNALIGNED_MEMOPS_ARE_FAST
38 # define load_block(d, s)        (d) = *(const aes_block_t *)(s)
39 # define store_block(d, s)       *(aes_block_t *)(d) = (s)
40 #else
41 # define load_block(d, s)        memcpy((d).data, (s), AES_BLOCK_SIZE)
42 # define store_block(d, s)       memcpy((d), (s).data, AES_BLOCK_SIZE)
43 #endif
44
45 /* N.B. The IV for this mode is _twice_ the block size */
46
47 /*  Use of this function is deprecated. */
48 void AES_ige_encrypt(const unsigned char *in, unsigned char *out,
49                      size_t length, const AES_KEY *key,
50                      unsigned char *ivec, const int enc)
51 {
52     size_t n;
53     size_t len = length;
54
55     if (length == 0)
56         return;
57
58     OPENSSL_assert(in && out && key && ivec);
59     OPENSSL_assert((AES_ENCRYPT == enc) || (AES_DECRYPT == enc));
60     OPENSSL_assert((length % AES_BLOCK_SIZE) == 0);
61
62     len = length / AES_BLOCK_SIZE;
63
64     if (AES_ENCRYPT == enc) {
65         if (in != out &&
66             (UNALIGNED_MEMOPS_ARE_FAST
67              || ((size_t)in | (size_t)out | (size_t)ivec) % sizeof(long) ==
68              0)) {
69             aes_block_t *ivp = (aes_block_t *) ivec;
70             aes_block_t *iv2p = (aes_block_t *) (ivec + AES_BLOCK_SIZE);
71
72             while (len) {
73                 aes_block_t *inp = (aes_block_t *) in;
74                 aes_block_t *outp = (aes_block_t *) out;
75
76                 for (n = 0; n < N_WORDS; ++n)
77                     outp->data[n] = inp->data[n] ^ ivp->data[n];
78                 AES_encrypt((unsigned char *)outp->data,
79                             (unsigned char *)outp->data, key);
80                 for (n = 0; n < N_WORDS; ++n)
81                     outp->data[n] ^= iv2p->data[n];
82                 ivp = outp;
83                 iv2p = inp;
84                 --len;
85                 in += AES_BLOCK_SIZE;
86                 out += AES_BLOCK_SIZE;
87             }
88             memcpy(ivec, ivp->data, AES_BLOCK_SIZE);
89             memcpy(ivec + AES_BLOCK_SIZE, iv2p->data, AES_BLOCK_SIZE);
90         } else {
91             aes_block_t tmp, tmp2;
92             aes_block_t iv;
93             aes_block_t iv2;
94
95             load_block(iv, ivec);
96             load_block(iv2, ivec + AES_BLOCK_SIZE);
97
98             while (len) {
99                 load_block(tmp, in);
100                 for (n = 0; n < N_WORDS; ++n)
101                     tmp2.data[n] = tmp.data[n] ^ iv.data[n];
102                 AES_encrypt((unsigned char *)tmp2.data,
103                             (unsigned char *)tmp2.data, key);
104                 for (n = 0; n < N_WORDS; ++n)
105                     tmp2.data[n] ^= iv2.data[n];
106                 store_block(out, tmp2);
107                 iv = tmp2;
108                 iv2 = tmp;
109                 --len;
110                 in += AES_BLOCK_SIZE;
111                 out += AES_BLOCK_SIZE;
112             }
113             memcpy(ivec, iv.data, AES_BLOCK_SIZE);
114             memcpy(ivec + AES_BLOCK_SIZE, iv2.data, AES_BLOCK_SIZE);
115         }
116     } else {
117         if (in != out &&
118             (UNALIGNED_MEMOPS_ARE_FAST
119              || ((size_t)in | (size_t)out | (size_t)ivec) % sizeof(long) ==
120              0)) {
121             aes_block_t *ivp = (aes_block_t *) ivec;
122             aes_block_t *iv2p = (aes_block_t *) (ivec + AES_BLOCK_SIZE);
123
124             while (len) {
125                 aes_block_t tmp;
126                 aes_block_t *inp = (aes_block_t *) in;
127                 aes_block_t *outp = (aes_block_t *) out;
128
129                 for (n = 0; n < N_WORDS; ++n)
130                     tmp.data[n] = inp->data[n] ^ iv2p->data[n];
131                 AES_decrypt((unsigned char *)tmp.data,
132                             (unsigned char *)outp->data, key);
133                 for (n = 0; n < N_WORDS; ++n)
134                     outp->data[n] ^= ivp->data[n];
135                 ivp = inp;
136                 iv2p = outp;
137                 --len;
138                 in += AES_BLOCK_SIZE;
139                 out += AES_BLOCK_SIZE;
140             }
141             memcpy(ivec, ivp->data, AES_BLOCK_SIZE);
142             memcpy(ivec + AES_BLOCK_SIZE, iv2p->data, AES_BLOCK_SIZE);
143         } else {
144             aes_block_t tmp, tmp2;
145             aes_block_t iv;
146             aes_block_t iv2;
147
148             load_block(iv, ivec);
149             load_block(iv2, ivec + AES_BLOCK_SIZE);
150
151             while (len) {
152                 load_block(tmp, in);
153                 tmp2 = tmp;
154                 for (n = 0; n < N_WORDS; ++n)
155                     tmp.data[n] ^= iv2.data[n];
156                 AES_decrypt((unsigned char *)tmp.data,
157                             (unsigned char *)tmp.data, key);
158                 for (n = 0; n < N_WORDS; ++n)
159                     tmp.data[n] ^= iv.data[n];
160                 store_block(out, tmp);
161                 iv = tmp2;
162                 iv2 = tmp;
163                 --len;
164                 in += AES_BLOCK_SIZE;
165                 out += AES_BLOCK_SIZE;
166             }
167             memcpy(ivec, iv.data, AES_BLOCK_SIZE);
168             memcpy(ivec + AES_BLOCK_SIZE, iv2.data, AES_BLOCK_SIZE);
169         }
170     }
171 }
172
173 /*
174  * Note that its effectively impossible to do biIGE in anything other
175  * than a single pass, so no provision is made for chaining.
176  *
177  * NB: The implementation of AES_bi_ige_encrypt has a bug. It is supposed to use
178  * 2 AES keys, but in fact only one is ever used. This bug has been present
179  * since this code was first implemented. It is believed to have minimal
180  * security impact in practice and has therefore not been fixed for backwards
181  * compatibility reasons.
182  *
183  * Use of this function is deprecated.
184  */
185
186 /* N.B. The IV for this mode is _four times_ the block size */
187
188 void AES_bi_ige_encrypt(const unsigned char *in, unsigned char *out,
189                         size_t length, const AES_KEY *key,
190                         const AES_KEY *key2, const unsigned char *ivec,
191                         const int enc)
192 {
193     size_t n;
194     size_t len = length;
195     unsigned char tmp[AES_BLOCK_SIZE];
196     unsigned char tmp2[AES_BLOCK_SIZE];
197     unsigned char tmp3[AES_BLOCK_SIZE];
198     unsigned char prev[AES_BLOCK_SIZE];
199     const unsigned char *iv;
200     const unsigned char *iv2;
201
202     OPENSSL_assert(in && out && key && ivec);
203     OPENSSL_assert((AES_ENCRYPT == enc) || (AES_DECRYPT == enc));
204     OPENSSL_assert((length % AES_BLOCK_SIZE) == 0);
205
206     if (AES_ENCRYPT == enc) {
207         /*
208          * XXX: Do a separate case for when in != out (strictly should check
209          * for overlap, too)
210          */
211
212         /* First the forward pass */
213         iv = ivec;
214         iv2 = ivec + AES_BLOCK_SIZE;
215         while (len >= AES_BLOCK_SIZE) {
216             for (n = 0; n < AES_BLOCK_SIZE; ++n)
217                 out[n] = in[n] ^ iv[n];
218             AES_encrypt(out, out, key);
219             for (n = 0; n < AES_BLOCK_SIZE; ++n)
220                 out[n] ^= iv2[n];
221             iv = out;
222             memcpy(prev, in, AES_BLOCK_SIZE);
223             iv2 = prev;
224             len -= AES_BLOCK_SIZE;
225             in += AES_BLOCK_SIZE;
226             out += AES_BLOCK_SIZE;
227         }
228
229         /* And now backwards */
230         iv = ivec + AES_BLOCK_SIZE * 2;
231         iv2 = ivec + AES_BLOCK_SIZE * 3;
232         len = length;
233         while (len >= AES_BLOCK_SIZE) {
234             out -= AES_BLOCK_SIZE;
235             /*
236              * XXX: reduce copies by alternating between buffers
237              */
238             memcpy(tmp, out, AES_BLOCK_SIZE);
239             for (n = 0; n < AES_BLOCK_SIZE; ++n)
240                 out[n] ^= iv[n];
241             /*
242              * hexdump(stdout, "out ^ iv", out, AES_BLOCK_SIZE);
243              */
244             AES_encrypt(out, out, key);
245             /*
246              * hexdump(stdout,"enc", out, AES_BLOCK_SIZE);
247              */
248             /*
249              * hexdump(stdout,"iv2", iv2, AES_BLOCK_SIZE);
250              */
251             for (n = 0; n < AES_BLOCK_SIZE; ++n)
252                 out[n] ^= iv2[n];
253             /*
254              * hexdump(stdout,"out", out, AES_BLOCK_SIZE);
255              */
256             iv = out;
257             memcpy(prev, tmp, AES_BLOCK_SIZE);
258             iv2 = prev;
259             len -= AES_BLOCK_SIZE;
260         }
261     } else {
262         /* First backwards */
263         iv = ivec + AES_BLOCK_SIZE * 2;
264         iv2 = ivec + AES_BLOCK_SIZE * 3;
265         in += length;
266         out += length;
267         while (len >= AES_BLOCK_SIZE) {
268             in -= AES_BLOCK_SIZE;
269             out -= AES_BLOCK_SIZE;
270             memcpy(tmp, in, AES_BLOCK_SIZE);
271             memcpy(tmp2, in, AES_BLOCK_SIZE);
272             for (n = 0; n < AES_BLOCK_SIZE; ++n)
273                 tmp[n] ^= iv2[n];
274             AES_decrypt(tmp, out, key);
275             for (n = 0; n < AES_BLOCK_SIZE; ++n)
276                 out[n] ^= iv[n];
277             memcpy(tmp3, tmp2, AES_BLOCK_SIZE);
278             iv = tmp3;
279             iv2 = out;
280             len -= AES_BLOCK_SIZE;
281         }
282
283         /* And now forwards */
284         iv = ivec;
285         iv2 = ivec + AES_BLOCK_SIZE;
286         len = length;
287         while (len >= AES_BLOCK_SIZE) {
288             memcpy(tmp, out, AES_BLOCK_SIZE);
289             memcpy(tmp2, out, AES_BLOCK_SIZE);
290             for (n = 0; n < AES_BLOCK_SIZE; ++n)
291                 tmp[n] ^= iv2[n];
292             AES_decrypt(tmp, out, key);
293             for (n = 0; n < AES_BLOCK_SIZE; ++n)
294                 out[n] ^= iv[n];
295             memcpy(tmp3, tmp2, AES_BLOCK_SIZE);
296             iv = tmp3;
297             iv2 = out;
298             len -= AES_BLOCK_SIZE;
299             in += AES_BLOCK_SIZE;
300             out += AES_BLOCK_SIZE;
301         }
302     }
303 }
304 #endif