GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: lib/libcrypto/modes/cbc128.c Lines: 25 57 43.9 %
Date: 2017-11-07 Branches: 11 36 30.6 %

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

42
	while (len) {
186
		unsigned char c;
187
		(*block)(in, tmp.c, key);
188
		for(n=0; n<16 && n<len; ++n) {
189
			c = in[n];
190
			out[n] = tmp.c[n] ^ ivec[n];
191
			ivec[n] = c;
192
		}
193
		if (len<=16) {
194
			for (; n<16; ++n)
195
				ivec[n] = in[n];
196
			break;
197
		}
198
		len -= 16;
199
		in  += 16;
200
		out += 16;
201
	}
202
42
}