Add include directory options for assembler files that include from crypto/
[openssl.git] / crypto / modes / cbc128.c
1 /* ====================================================================
2  * Copyright (c) 2008 The OpenSSL Project.  All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  *
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in
13  *    the documentation and/or other materials provided with the
14  *    distribution.
15  *
16  * 3. All advertising materials mentioning features or use of this
17  *    software must display the following acknowledgment:
18  *    "This product includes software developed by the OpenSSL Project
19  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
20  *
21  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
22  *    endorse or promote products derived from this software without
23  *    prior written permission. For written permission, please contact
24  *    openssl-core@openssl.org.
25  *
26  * 5. Products derived from this software may not be called "OpenSSL"
27  *    nor may "OpenSSL" appear in their names without prior written
28  *    permission of the OpenSSL Project.
29  *
30  * 6. Redistributions of any form whatsoever must retain the following
31  *    acknowledgment:
32  *    "This product includes software developed by the OpenSSL Project
33  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
34  *
35  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
36  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
37  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
38  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
39  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
40  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
41  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
42  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
43  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
44  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
45  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
46  * OF THE POSSIBILITY OF SUCH DAMAGE.
47  * ====================================================================
48  *
49  */
50
51 #include <openssl/crypto.h>
52 #include "modes_lcl.h"
53 #include <string.h>
54
55 #if !defined(STRICT_ALIGNMENT) && !defined(PEDANTIC)
56 # define STRICT_ALIGNMENT 0
57 #endif
58
59 void CRYPTO_cbc128_encrypt(const unsigned char *in, unsigned char *out,
60                            size_t len, const void *key,
61                            unsigned char ivec[16], block128_f block)
62 {
63     size_t n;
64     const unsigned char *iv = ivec;
65
66 #if !defined(OPENSSL_SMALL_FOOTPRINT)
67     if (STRICT_ALIGNMENT &&
68         ((size_t)in | (size_t)out | (size_t)ivec) % sizeof(size_t) != 0) {
69         while (len >= 16) {
70             for (n = 0; n < 16; ++n)
71                 out[n] = in[n] ^ iv[n];
72             (*block) (out, out, key);
73             iv = out;
74             len -= 16;
75             in += 16;
76             out += 16;
77         }
78     } else {
79         while (len >= 16) {
80             for (n = 0; n < 16; n += sizeof(size_t))
81                 *(size_t *)(out + n) =
82                     *(size_t *)(in + n) ^ *(size_t *)(iv + n);
83             (*block) (out, out, key);
84             iv = out;
85             len -= 16;
86             in += 16;
87             out += 16;
88         }
89     }
90 #endif
91     while (len) {
92         for (n = 0; n < 16 && n < len; ++n)
93             out[n] = in[n] ^ iv[n];
94         for (; n < 16; ++n)
95             out[n] = iv[n];
96         (*block) (out, out, key);
97         iv = out;
98         if (len <= 16)
99             break;
100         len -= 16;
101         in += 16;
102         out += 16;
103     }
104     memcpy(ivec, iv, 16);
105 }
106
107 void CRYPTO_cbc128_decrypt(const unsigned char *in, unsigned char *out,
108                            size_t len, const void *key,
109                            unsigned char ivec[16], block128_f block)
110 {
111     size_t n;
112     union {
113         size_t t[16 / sizeof(size_t)];
114         unsigned char c[16];
115     } tmp;
116
117 #if !defined(OPENSSL_SMALL_FOOTPRINT)
118     if (in != out) {
119         const unsigned char *iv = ivec;
120
121         if (STRICT_ALIGNMENT &&
122             ((size_t)in | (size_t)out | (size_t)ivec) % sizeof(size_t) != 0) {
123             while (len >= 16) {
124                 (*block) (in, out, key);
125                 for (n = 0; n < 16; ++n)
126                     out[n] ^= iv[n];
127                 iv = in;
128                 len -= 16;
129                 in += 16;
130                 out += 16;
131             }
132         } else if (16 % sizeof(size_t) == 0) { /* always true */
133             while (len >= 16) {
134                 size_t *out_t = (size_t *)out, *iv_t = (size_t *)iv;
135
136                 (*block) (in, out, key);
137                 for (n = 0; n < 16 / sizeof(size_t); n++)
138                     out_t[n] ^= iv_t[n];
139                 iv = in;
140                 len -= 16;
141                 in += 16;
142                 out += 16;
143             }
144         }
145         memcpy(ivec, iv, 16);
146     } else {
147         if (STRICT_ALIGNMENT &&
148             ((size_t)in | (size_t)out | (size_t)ivec) % sizeof(size_t) != 0) {
149             unsigned char c;
150             while (len >= 16) {
151                 (*block) (in, tmp.c, key);
152                 for (n = 0; n < 16; ++n) {
153                     c = in[n];
154                     out[n] = tmp.c[n] ^ ivec[n];
155                     ivec[n] = c;
156                 }
157                 len -= 16;
158                 in += 16;
159                 out += 16;
160             }
161         } else if (16 % sizeof(size_t) == 0) { /* always true */
162             while (len >= 16) {
163                 size_t c, *out_t = (size_t *)out, *ivec_t = (size_t *)ivec;
164                 const size_t *in_t = (const size_t *)in;
165
166                 (*block) (in, tmp.c, key);
167                 for (n = 0; n < 16 / sizeof(size_t); n++) {
168                     c = in_t[n];
169                     out_t[n] = tmp.t[n] ^ ivec_t[n];
170                     ivec_t[n] = c;
171                 }
172                 len -= 16;
173                 in += 16;
174                 out += 16;
175             }
176         }
177     }
178 #endif
179     while (len) {
180         unsigned char c;
181         (*block) (in, tmp.c, key);
182         for (n = 0; n < 16 && n < len; ++n) {
183             c = in[n];
184             out[n] = tmp.c[n] ^ ivec[n];
185             ivec[n] = c;
186         }
187         if (len <= 16) {
188             for (; n < 16; ++n)
189                 ivec[n] = in[n];
190             break;
191         }
192         len -= 16;
193         in += 16;
194         out += 16;
195     }
196 }