Avoid undefined behavior with unaligned accesses
[openssl.git] / crypto / modes / cfb128.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  * The input and output encrypted as though 128bit cfb mode is being used.
22  * The extra state information to record how much of the 128bit block we have
23  * used is contained in *num;
24  */
25 void CRYPTO_cfb128_encrypt(const unsigned char *in, unsigned char *out,
26                            size_t len, const void *key,
27                            unsigned char ivec[16], int *num,
28                            int enc, block128_f block)
29 {
30     unsigned int n;
31     size_t l = 0;
32
33     n = *num;
34
35     if (enc) {
36 #if !defined(OPENSSL_SMALL_FOOTPRINT)
37         if (16 % sizeof(size_t) == 0) { /* always true actually */
38             do {
39                 while (n && len) {
40                     *(out++) = ivec[n] ^= *(in++);
41                     --len;
42                     n = (n + 1) % 16;
43                 }
44 # if defined(STRICT_ALIGNMENT)
45                 if (((size_t)in | (size_t)out | (size_t)ivec) %
46                     sizeof(size_t) != 0)
47                     break;
48 # endif
49                 while (len >= 16) {
50                     (*block) (ivec, ivec, key);
51                     for (; n < 16; n += sizeof(size_t)) {
52                         *(size_t_aX *)(out + n) =
53                             *(size_t_aX *)(ivec + n)
54                                 ^= *(size_t_aX *)(in + n);
55                     }
56                     len -= 16;
57                     out += 16;
58                     in += 16;
59                     n = 0;
60                 }
61                 if (len) {
62                     (*block) (ivec, ivec, key);
63                     while (len--) {
64                         out[n] = ivec[n] ^= in[n];
65                         ++n;
66                     }
67                 }
68                 *num = n;
69                 return;
70             } while (0);
71         }
72         /* the rest would be commonly eliminated by x86* compiler */
73 #endif
74         while (l < len) {
75             if (n == 0) {
76                 (*block) (ivec, ivec, key);
77             }
78             out[l] = ivec[n] ^= in[l];
79             ++l;
80             n = (n + 1) % 16;
81         }
82         *num = n;
83     } else {
84 #if !defined(OPENSSL_SMALL_FOOTPRINT)
85         if (16 % sizeof(size_t) == 0) { /* always true actually */
86             do {
87                 while (n && len) {
88                     unsigned char c;
89                     *(out++) = ivec[n] ^ (c = *(in++));
90                     ivec[n] = c;
91                     --len;
92                     n = (n + 1) % 16;
93                 }
94 # if defined(STRICT_ALIGNMENT)
95                 if (((size_t)in | (size_t)out | (size_t)ivec) %
96                     sizeof(size_t) != 0)
97                     break;
98 # endif
99                 while (len >= 16) {
100                     (*block) (ivec, ivec, key);
101                     for (; n < 16; n += sizeof(size_t)) {
102                         size_t t = *(size_t_aX *)(in + n);
103                         *(size_t_aX *)(out + n)
104                             = *(size_t_aX *)(ivec + n) ^ t;
105                         *(size_t_aX *)(ivec + n) = t;
106                     }
107                     len -= 16;
108                     out += 16;
109                     in += 16;
110                     n = 0;
111                 }
112                 if (len) {
113                     (*block) (ivec, ivec, key);
114                     while (len--) {
115                         unsigned char c;
116                         out[n] = ivec[n] ^ (c = in[n]);
117                         ivec[n] = c;
118                         ++n;
119                     }
120                 }
121                 *num = n;
122                 return;
123             } while (0);
124         }
125         /* the rest would be commonly eliminated by x86* compiler */
126 #endif
127         while (l < len) {
128             unsigned char c;
129             if (n == 0) {
130                 (*block) (ivec, ivec, key);
131             }
132             out[l] = ivec[n] ^ (c = in[l]);
133             ivec[n] = c;
134             ++l;
135             n = (n + 1) % 16;
136         }
137         *num = n;
138     }
139 }
140
141 /*
142  * This expects a single block of size nbits for both in and out. Note that
143  * it corrupts any extra bits in the last byte of out
144  */
145 static void cfbr_encrypt_block(const unsigned char *in, unsigned char *out,
146                                int nbits, const void *key,
147                                unsigned char ivec[16], int enc,
148                                block128_f block)
149 {
150     int n, rem, num;
151     unsigned char ovec[16 * 2 + 1]; /* +1 because we dereference (but don't
152                                      * use) one byte off the end */
153
154     if (nbits <= 0 || nbits > 128)
155         return;
156
157     /* fill in the first half of the new IV with the current IV */
158     memcpy(ovec, ivec, 16);
159     /* construct the new IV */
160     (*block) (ivec, ivec, key);
161     num = (nbits + 7) / 8;
162     if (enc)                    /* encrypt the input */
163         for (n = 0; n < num; ++n)
164             out[n] = (ovec[16 + n] = in[n] ^ ivec[n]);
165     else                        /* decrypt the input */
166         for (n = 0; n < num; ++n)
167             out[n] = (ovec[16 + n] = in[n]) ^ ivec[n];
168     /* shift ovec left... */
169     rem = nbits % 8;
170     num = nbits / 8;
171     if (rem == 0)
172         memcpy(ivec, ovec + num, 16);
173     else
174         for (n = 0; n < 16; ++n)
175             ivec[n] = ovec[n + num] << rem | ovec[n + num + 1] >> (8 - rem);
176
177     /* it is not necessary to cleanse ovec, since the IV is not secret */
178 }
179
180 /* N.B. This expects the input to be packed, MS bit first */
181 void CRYPTO_cfb128_1_encrypt(const unsigned char *in, unsigned char *out,
182                              size_t bits, const void *key,
183                              unsigned char ivec[16], int *num,
184                              int enc, block128_f block)
185 {
186     size_t n;
187     unsigned char c[1], d[1];
188
189     for (n = 0; n < bits; ++n) {
190         c[0] = (in[n / 8] & (1 << (7 - n % 8))) ? 0x80 : 0;
191         cfbr_encrypt_block(c, d, 1, key, ivec, enc, block);
192         out[n / 8] = (out[n / 8] & ~(1 << (unsigned int)(7 - n % 8))) |
193             ((d[0] & 0x80) >> (unsigned int)(n % 8));
194     }
195 }
196
197 void CRYPTO_cfb128_8_encrypt(const unsigned char *in, unsigned char *out,
198                              size_t length, const void *key,
199                              unsigned char ivec[16], int *num,
200                              int enc, block128_f block)
201 {
202     size_t n;
203
204     for (n = 0; n < length; ++n)
205         cfbr_encrypt_block(&in[n], &out[n], 8, key, ivec, enc, block);
206 }