diff options
author | tb <> | 2023-04-25 17:54:10 +0000 |
---|---|---|
committer | tb <> | 2023-04-25 17:54:10 +0000 |
commit | 6a08d636beca95a31810925330735e180eec76be (patch) | |
tree | 15d28be1ddeadfc87cb2db51f6a81fe0cdb48120 | |
parent | c21d6e0b7e6ae815e6d53394e30671234a4f9864 (diff) | |
download | openbsd-6a08d636beca95a31810925330735e180eec76be.tar.gz openbsd-6a08d636beca95a31810925330735e180eec76be.tar.bz2 openbsd-6a08d636beca95a31810925330735e180eec76be.zip |
Remove CTS mode
ok jsing
-rw-r--r-- | src/lib/libcrypto/Makefile | 3 | ||||
-rw-r--r-- | src/lib/libcrypto/modes/cts128.c | 267 | ||||
-rw-r--r-- | src/lib/libcrypto/modes/modes.h | 30 |
3 files changed, 2 insertions, 298 deletions
diff --git a/src/lib/libcrypto/Makefile b/src/lib/libcrypto/Makefile index a993755d24..057eb9cc54 100644 --- a/src/lib/libcrypto/Makefile +++ b/src/lib/libcrypto/Makefile | |||
@@ -1,4 +1,4 @@ | |||
1 | # $OpenBSD: Makefile,v 1.111 2023/04/25 17:42:07 tb Exp $ | 1 | # $OpenBSD: Makefile,v 1.112 2023/04/25 17:54:10 tb Exp $ |
2 | 2 | ||
3 | LIB= crypto | 3 | LIB= crypto |
4 | LIBREBUILD=y | 4 | LIBREBUILD=y |
@@ -513,7 +513,6 @@ SRCS+= cbc128.c | |||
513 | SRCS+= ccm128.c | 513 | SRCS+= ccm128.c |
514 | SRCS+= cfb128.c | 514 | SRCS+= cfb128.c |
515 | SRCS+= ctr128.c | 515 | SRCS+= ctr128.c |
516 | #SRCS+= cts128.c | ||
517 | SRCS+= gcm128.c | 516 | SRCS+= gcm128.c |
518 | SRCS+= ofb128.c | 517 | SRCS+= ofb128.c |
519 | SRCS+= xts128.c | 518 | SRCS+= xts128.c |
diff --git a/src/lib/libcrypto/modes/cts128.c b/src/lib/libcrypto/modes/cts128.c deleted file mode 100644 index ec81dd2433..0000000000 --- a/src/lib/libcrypto/modes/cts128.c +++ /dev/null | |||
@@ -1,267 +0,0 @@ | |||
1 | /* $OpenBSD: cts128.c,v 1.6 2022/11/26 16:08:53 tb Exp $ */ | ||
2 | /* ==================================================================== | ||
3 | * Copyright (c) 2008 The OpenSSL Project. All rights reserved. | ||
4 | * | ||
5 | * Rights for redistribution and usage in source and binary | ||
6 | * forms are granted according to the OpenSSL license. | ||
7 | */ | ||
8 | |||
9 | #include <openssl/crypto.h> | ||
10 | #include "modes_local.h" | ||
11 | #include <string.h> | ||
12 | |||
13 | #ifndef MODES_DEBUG | ||
14 | # ifndef NDEBUG | ||
15 | # define NDEBUG | ||
16 | # endif | ||
17 | #endif | ||
18 | |||
19 | /* | ||
20 | * Trouble with Ciphertext Stealing, CTS, mode is that there is no | ||
21 | * common official specification, but couple of cipher/application | ||
22 | * specific ones: RFC2040 and RFC3962. Then there is 'Proposal to | ||
23 | * Extend CBC Mode By "Ciphertext Stealing"' at NIST site, which | ||
24 | * deviates from mentioned RFCs. Most notably it allows input to be | ||
25 | * of block length and it doesn't flip the order of the last two | ||
26 | * blocks. CTS is being discussed even in ECB context, but it's not | ||
27 | * adopted for any known application. This implementation provides | ||
28 | * two interfaces: one compliant with above mentioned RFCs and one | ||
29 | * compliant with the NIST proposal, both extending CBC mode. | ||
30 | */ | ||
31 | |||
32 | size_t CRYPTO_cts128_encrypt_block(const unsigned char *in, unsigned char *out, | ||
33 | size_t len, const void *key, | ||
34 | unsigned char ivec[16], block128_f block) | ||
35 | { size_t residue, n; | ||
36 | |||
37 | if (len <= 16) return 0; | ||
38 | |||
39 | if ((residue=len%16) == 0) residue = 16; | ||
40 | |||
41 | len -= residue; | ||
42 | |||
43 | CRYPTO_cbc128_encrypt(in,out,len,key,ivec,block); | ||
44 | |||
45 | in += len; | ||
46 | out += len; | ||
47 | |||
48 | for (n=0; n<residue; ++n) | ||
49 | ivec[n] ^= in[n]; | ||
50 | (*block)(ivec,ivec,key); | ||
51 | memcpy(out,out-16,residue); | ||
52 | memcpy(out-16,ivec,16); | ||
53 | |||
54 | return len+residue; | ||
55 | } | ||
56 | |||
57 | size_t CRYPTO_nistcts128_encrypt_block(const unsigned char *in, unsigned char *out, | ||
58 | size_t len, const void *key, | ||
59 | unsigned char ivec[16], block128_f block) | ||
60 | { size_t residue, n; | ||
61 | |||
62 | if (len < 16) return 0; | ||
63 | |||
64 | residue=len%16; | ||
65 | |||
66 | len -= residue; | ||
67 | |||
68 | CRYPTO_cbc128_encrypt(in,out,len,key,ivec,block); | ||
69 | |||
70 | if (residue==0) return len; | ||
71 | |||
72 | in += len; | ||
73 | out += len; | ||
74 | |||
75 | for (n=0; n<residue; ++n) | ||
76 | ivec[n] ^= in[n]; | ||
77 | (*block)(ivec,ivec,key); | ||
78 | memcpy(out-16+residue,ivec,16); | ||
79 | |||
80 | return len+residue; | ||
81 | } | ||
82 | |||
83 | size_t CRYPTO_cts128_encrypt(const unsigned char *in, unsigned char *out, | ||
84 | size_t len, const void *key, | ||
85 | unsigned char ivec[16], cbc128_f cbc) | ||
86 | { size_t residue; | ||
87 | union { size_t align; unsigned char c[16]; } tmp; | ||
88 | |||
89 | if (len <= 16) return 0; | ||
90 | |||
91 | if ((residue=len%16) == 0) residue = 16; | ||
92 | |||
93 | len -= residue; | ||
94 | |||
95 | (*cbc)(in,out,len,key,ivec,1); | ||
96 | |||
97 | in += len; | ||
98 | out += len; | ||
99 | |||
100 | memset(tmp.c,0,sizeof(tmp)); | ||
101 | memcpy(tmp.c,in,residue); | ||
102 | memcpy(out,out-16,residue); | ||
103 | (*cbc)(tmp.c,out-16,16,key,ivec,1); | ||
104 | return len+residue; | ||
105 | } | ||
106 | |||
107 | size_t CRYPTO_nistcts128_encrypt(const unsigned char *in, unsigned char *out, | ||
108 | size_t len, const void *key, | ||
109 | unsigned char ivec[16], cbc128_f cbc) | ||
110 | { size_t residue; | ||
111 | union { size_t align; unsigned char c[16]; } tmp; | ||
112 | |||
113 | if (len < 16) return 0; | ||
114 | |||
115 | residue=len%16; | ||
116 | |||
117 | len -= residue; | ||
118 | |||
119 | (*cbc)(in,out,len,key,ivec,1); | ||
120 | |||
121 | if (residue==0) return len; | ||
122 | |||
123 | in += len; | ||
124 | out += len; | ||
125 | |||
126 | memset(tmp.c,0,sizeof(tmp)); | ||
127 | memcpy(tmp.c,in,residue); | ||
128 | (*cbc)(tmp.c,out-16+residue,16,key,ivec,1); | ||
129 | return len+residue; | ||
130 | } | ||
131 | |||
132 | size_t CRYPTO_cts128_decrypt_block(const unsigned char *in, unsigned char *out, | ||
133 | size_t len, const void *key, | ||
134 | unsigned char ivec[16], block128_f block) | ||
135 | { size_t residue, n; | ||
136 | union { size_t align; unsigned char c[32]; } tmp; | ||
137 | |||
138 | if (len<=16) return 0; | ||
139 | |||
140 | if ((residue=len%16) == 0) residue = 16; | ||
141 | |||
142 | len -= 16+residue; | ||
143 | |||
144 | if (len) { | ||
145 | CRYPTO_cbc128_decrypt(in,out,len,key,ivec,block); | ||
146 | in += len; | ||
147 | out += len; | ||
148 | } | ||
149 | |||
150 | (*block)(in,tmp.c+16,key); | ||
151 | |||
152 | memcpy(tmp.c,tmp.c+16,16); | ||
153 | memcpy(tmp.c,in+16,residue); | ||
154 | (*block)(tmp.c,tmp.c,key); | ||
155 | |||
156 | for(n=0; n<16; ++n) { | ||
157 | unsigned char c = in[n]; | ||
158 | out[n] = tmp.c[n] ^ ivec[n]; | ||
159 | ivec[n] = c; | ||
160 | } | ||
161 | for(residue+=16; n<residue; ++n) | ||
162 | out[n] = tmp.c[n] ^ in[n]; | ||
163 | |||
164 | return 16+len+residue; | ||
165 | } | ||
166 | |||
167 | size_t CRYPTO_nistcts128_decrypt_block(const unsigned char *in, unsigned char *out, | ||
168 | size_t len, const void *key, | ||
169 | unsigned char ivec[16], block128_f block) | ||
170 | { size_t residue, n; | ||
171 | union { size_t align; unsigned char c[32]; } tmp; | ||
172 | |||
173 | if (len<16) return 0; | ||
174 | |||
175 | residue=len%16; | ||
176 | |||
177 | if (residue==0) { | ||
178 | CRYPTO_cbc128_decrypt(in,out,len,key,ivec,block); | ||
179 | return len; | ||
180 | } | ||
181 | |||
182 | len -= 16+residue; | ||
183 | |||
184 | if (len) { | ||
185 | CRYPTO_cbc128_decrypt(in,out,len,key,ivec,block); | ||
186 | in += len; | ||
187 | out += len; | ||
188 | } | ||
189 | |||
190 | (*block)(in+residue,tmp.c+16,key); | ||
191 | |||
192 | memcpy(tmp.c,tmp.c+16,16); | ||
193 | memcpy(tmp.c,in,residue); | ||
194 | (*block)(tmp.c,tmp.c,key); | ||
195 | |||
196 | for(n=0; n<16; ++n) { | ||
197 | unsigned char c = in[n]; | ||
198 | out[n] = tmp.c[n] ^ ivec[n]; | ||
199 | ivec[n] = in[n+residue]; | ||
200 | tmp.c[n] = c; | ||
201 | } | ||
202 | for(residue+=16; n<residue; ++n) | ||
203 | out[n] = tmp.c[n] ^ tmp.c[n-16]; | ||
204 | |||
205 | return 16+len+residue; | ||
206 | } | ||
207 | |||
208 | size_t CRYPTO_cts128_decrypt(const unsigned char *in, unsigned char *out, | ||
209 | size_t len, const void *key, | ||
210 | unsigned char ivec[16], cbc128_f cbc) | ||
211 | { size_t residue; | ||
212 | union { size_t align; unsigned char c[32]; } tmp; | ||
213 | |||
214 | if (len<=16) return 0; | ||
215 | |||
216 | if ((residue=len%16) == 0) residue = 16; | ||
217 | |||
218 | len -= 16+residue; | ||
219 | |||
220 | if (len) { | ||
221 | (*cbc)(in,out,len,key,ivec,0); | ||
222 | in += len; | ||
223 | out += len; | ||
224 | } | ||
225 | |||
226 | memset(tmp.c,0,sizeof(tmp)); | ||
227 | /* this places in[16] at &tmp.c[16] and decrypted block at &tmp.c[0] */ | ||
228 | (*cbc)(in,tmp.c,16,key,tmp.c+16,0); | ||
229 | |||
230 | memcpy(tmp.c,in+16,residue); | ||
231 | (*cbc)(tmp.c,tmp.c,32,key,ivec,0); | ||
232 | memcpy(out,tmp.c,16+residue); | ||
233 | return 16+len+residue; | ||
234 | } | ||
235 | |||
236 | size_t CRYPTO_nistcts128_decrypt(const unsigned char *in, unsigned char *out, | ||
237 | size_t len, const void *key, | ||
238 | unsigned char ivec[16], cbc128_f cbc) | ||
239 | { size_t residue; | ||
240 | union { size_t align; unsigned char c[32]; } tmp; | ||
241 | |||
242 | if (len<16) return 0; | ||
243 | |||
244 | residue=len%16; | ||
245 | |||
246 | if (residue==0) { | ||
247 | (*cbc)(in,out,len,key,ivec,0); | ||
248 | return len; | ||
249 | } | ||
250 | |||
251 | len -= 16+residue; | ||
252 | |||
253 | if (len) { | ||
254 | (*cbc)(in,out,len,key,ivec,0); | ||
255 | in += len; | ||
256 | out += len; | ||
257 | } | ||
258 | |||
259 | memset(tmp.c,0,sizeof(tmp)); | ||
260 | /* this places in[16] at &tmp.c[16] and decrypted block at &tmp.c[0] */ | ||
261 | (*cbc)(in+residue,tmp.c,16,key,tmp.c+16,0); | ||
262 | |||
263 | memcpy(tmp.c,in,residue); | ||
264 | (*cbc)(tmp.c,tmp.c,32,key,ivec,0); | ||
265 | memcpy(out,tmp.c,16+residue); | ||
266 | return 16+len+residue; | ||
267 | } | ||
diff --git a/src/lib/libcrypto/modes/modes.h b/src/lib/libcrypto/modes/modes.h index 3c9557ebeb..44d8326b5b 100644 --- a/src/lib/libcrypto/modes/modes.h +++ b/src/lib/libcrypto/modes/modes.h | |||
@@ -1,4 +1,4 @@ | |||
1 | /* $OpenBSD: modes.h,v 1.4 2023/04/16 08:14:34 tb Exp $ */ | 1 | /* $OpenBSD: modes.h,v 1.5 2023/04/25 17:54:10 tb Exp $ */ |
2 | /* ==================================================================== | 2 | /* ==================================================================== |
3 | * Copyright (c) 2008 The OpenSSL Project. All rights reserved. | 3 | * Copyright (c) 2008 The OpenSSL Project. All rights reserved. |
4 | * | 4 | * |
@@ -63,34 +63,6 @@ void CRYPTO_cfb128_1_encrypt(const unsigned char *in, unsigned char *out, | |||
63 | unsigned char ivec[16], int *num, | 63 | unsigned char ivec[16], int *num, |
64 | int enc, block128_f block); | 64 | int enc, block128_f block); |
65 | 65 | ||
66 | #if !defined(LIBRESSL_NEXT_API) || defined(LIBRESSL_INTERNAL) | ||
67 | size_t CRYPTO_cts128_encrypt_block(const unsigned char *in, unsigned char *out, | ||
68 | size_t len, const void *key, | ||
69 | unsigned char ivec[16], block128_f block); | ||
70 | size_t CRYPTO_cts128_encrypt(const unsigned char *in, unsigned char *out, | ||
71 | size_t len, const void *key, | ||
72 | unsigned char ivec[16], cbc128_f cbc); | ||
73 | size_t CRYPTO_cts128_decrypt_block(const unsigned char *in, unsigned char *out, | ||
74 | size_t len, const void *key, | ||
75 | unsigned char ivec[16], block128_f block); | ||
76 | size_t CRYPTO_cts128_decrypt(const unsigned char *in, unsigned char *out, | ||
77 | size_t len, const void *key, | ||
78 | unsigned char ivec[16], cbc128_f cbc); | ||
79 | |||
80 | size_t CRYPTO_nistcts128_encrypt_block(const unsigned char *in, unsigned char *out, | ||
81 | size_t len, const void *key, | ||
82 | unsigned char ivec[16], block128_f block); | ||
83 | size_t CRYPTO_nistcts128_encrypt(const unsigned char *in, unsigned char *out, | ||
84 | size_t len, const void *key, | ||
85 | unsigned char ivec[16], cbc128_f cbc); | ||
86 | size_t CRYPTO_nistcts128_decrypt_block(const unsigned char *in, unsigned char *out, | ||
87 | size_t len, const void *key, | ||
88 | unsigned char ivec[16], block128_f block); | ||
89 | size_t CRYPTO_nistcts128_decrypt(const unsigned char *in, unsigned char *out, | ||
90 | size_t len, const void *key, | ||
91 | unsigned char ivec[16], cbc128_f cbc); | ||
92 | #endif | ||
93 | |||
94 | typedef struct gcm128_context GCM128_CONTEXT; | 66 | typedef struct gcm128_context GCM128_CONTEXT; |
95 | 67 | ||
96 | GCM128_CONTEXT *CRYPTO_gcm128_new(void *key, block128_f block); | 68 | GCM128_CONTEXT *CRYPTO_gcm128_new(void *key, block128_f block); |