Avoid undefined behavior with unaligned accesses
[openssl.git] / crypto / modes / ctr128.c
1 /*
2  * Copyright 2008-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 #include <string.h>
11 #include <openssl/crypto.h>
12 #include "crypto/modes.h"
13
14 #if defined(__GNUC__) && !defined(STRICT_ALIGNMENT)
15 typedef size_t size_t_aX __attribute((__aligned__(1)));
16 #else
17 typedef size_t size_t_aX;
18 #endif
19
20 /*
21  * NOTE: the IV/counter CTR mode is big-endian.  The code itself is
22  * endian-neutral.
23  */
24
25 /* increment counter (128-bit int) by 1 */
26 static void ctr128_inc(unsigned char *counter)
27 {
28     u32 n = 16, c = 1;
29
30     do {
31         --n;
32         c += counter[n];
33         counter[n] = (u8)c;
34         c >>= 8;
35     } while (n);
36 }
37
38 #if !defined(OPENSSL_SMALL_FOOTPRINT)
39 static void ctr128_inc_aligned(unsigned char *counter)
40 {
41     size_t *data, c, d, n;
42     const union {
43         long one;
44         char little;
45     } is_endian = {
46         1
47     };
48
49     if (is_endian.little || ((size_t)counter % sizeof(size_t)) != 0) {
50         ctr128_inc(counter);
51         return;
52     }
53
54     data = (size_t *)counter;
55     c = 1;
56     n = 16 / sizeof(size_t);
57     do {
58         --n;
59         d = data[n] += c;
60         /* did addition carry? */
61         c = ((d - c) & ~d) >> (sizeof(size_t) * 8 - 1);
62     } while (n);
63 }
64 #endif
65
66 /*
67  * The input encrypted as though 128bit counter mode is being used.  The
68  * extra state information to record how much of the 128bit block we have
69  * used is contained in *num, and the encrypted counter is kept in
70  * ecount_buf.  Both *num and ecount_buf must be initialised with zeros
71  * before the first call to CRYPTO_ctr128_encrypt(). This algorithm assumes
72  * that the counter is in the x lower bits of the IV (ivec), and that the
73  * application has full control over overflow and the rest of the IV.  This
74  * implementation takes NO responsibility for checking that the counter
75  * doesn't overflow into the rest of the IV when incremented.
76  */
77 void CRYPTO_ctr128_encrypt(const unsigned char *in, unsigned char *out,
78                            size_t len, const void *key,
79                            unsigned char ivec[16],
80                            unsigned char ecount_buf[16], unsigned int *num,
81                            block128_f block)
82 {
83     unsigned int n;
84     size_t l = 0;
85
86     n = *num;
87
88 #if !defined(OPENSSL_SMALL_FOOTPRINT)
89     if (16 % sizeof(size_t) == 0) { /* always true actually */
90         do {
91             while (n && len) {
92                 *(out++) = *(in++) ^ ecount_buf[n];
93                 --len;
94                 n = (n + 1) % 16;
95             }
96
97 # if defined(STRICT_ALIGNMENT)
98             if (((size_t)in | (size_t)out | (size_t)ecount_buf)
99                 % sizeof(size_t) != 0)
100                 break;
101 # endif
102             while (len >= 16) {
103                 (*block) (ivec, ecount_buf, key);
104                 ctr128_inc_aligned(ivec);
105                 for (n = 0; n < 16; n += sizeof(size_t))
106                     *(size_t_aX *)(out + n) =
107                         *(size_t_aX *)(in + n)
108                         ^ *(size_t_aX *)(ecount_buf + n);
109                 len -= 16;
110                 out += 16;
111                 in += 16;
112                 n = 0;
113             }
114             if (len) {
115                 (*block) (ivec, ecount_buf, key);
116                 ctr128_inc_aligned(ivec);
117                 while (len--) {
118                     out[n] = in[n] ^ ecount_buf[n];
119                     ++n;
120                 }
121             }
122             *num = n;
123             return;
124         } while (0);
125     }
126     /* the rest would be commonly eliminated by x86* compiler */
127 #endif
128     while (l < len) {
129         if (n == 0) {
130             (*block) (ivec, ecount_buf, key);
131             ctr128_inc(ivec);
132         }
133         out[l] = in[l] ^ ecount_buf[n];
134         ++l;
135         n = (n + 1) % 16;
136     }
137
138     *num = n;
139 }
140
141 /* increment upper 96 bits of 128-bit counter by 1 */
142 static void ctr96_inc(unsigned char *counter)
143 {
144     u32 n = 12, c = 1;
145
146     do {
147         --n;
148         c += counter[n];
149         counter[n] = (u8)c;
150         c >>= 8;
151     } while (n);
152 }
153
154 void CRYPTO_ctr128_encrypt_ctr32(const unsigned char *in, unsigned char *out,
155                                  size_t len, const void *key,
156                                  unsigned char ivec[16],
157                                  unsigned char ecount_buf[16],
158                                  unsigned int *num, ctr128_f func)
159 {
160     unsigned int n, ctr32;
161
162     n = *num;
163
164     while (n && len) {
165         *(out++) = *(in++) ^ ecount_buf[n];
166         --len;
167         n = (n + 1) % 16;
168     }
169
170     ctr32 = GETU32(ivec + 12);
171     while (len >= 16) {
172         size_t blocks = len / 16;
173         /*
174          * 1<<28 is just a not-so-small yet not-so-large number...
175          * Below condition is practically never met, but it has to
176          * be checked for code correctness.
177          */
178         if (sizeof(size_t) > sizeof(unsigned int) && blocks > (1U << 28))
179             blocks = (1U << 28);
180         /*
181          * As (*func) operates on 32-bit counter, caller
182          * has to handle overflow. 'if' below detects the
183          * overflow, which is then handled by limiting the
184          * amount of blocks to the exact overflow point...
185          */
186         ctr32 += (u32)blocks;
187         if (ctr32 < blocks) {
188             blocks -= ctr32;
189             ctr32 = 0;
190         }
191         (*func) (in, out, blocks, key, ivec);
192         /* (*ctr) does not update ivec, caller does: */
193         PUTU32(ivec + 12, ctr32);
194         /* ... overflow was detected, propagate carry. */
195         if (ctr32 == 0)
196             ctr96_inc(ivec);
197         blocks *= 16;
198         len -= blocks;
199         out += blocks;
200         in += blocks;
201     }
202     if (len) {
203         memset(ecount_buf, 0, 16);
204         (*func) (ecount_buf, ecount_buf, 1, key, ivec);
205         ++ctr32;
206         PUTU32(ivec + 12, ctr32);
207         if (ctr32 == 0)
208             ctr96_inc(ivec);
209         while (len--) {
210             out[n] = in[n] ^ ecount_buf[n];
211             ++n;
212         }
213     }
214
215     *num = n;
216 }