Branch data Line data Source code
1 : : /* crypto/bf/bf_enc.c */
2 : : /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3 : : * All rights reserved.
4 : : *
5 : : * This package is an SSL implementation written
6 : : * by Eric Young (eay@cryptsoft.com).
7 : : * The implementation was written so as to conform with Netscapes SSL.
8 : : *
9 : : * This library is free for commercial and non-commercial use as long as
10 : : * the following conditions are aheared to. The following conditions
11 : : * apply to all code found in this distribution, be it the RC4, RSA,
12 : : * lhash, DES, etc., code; not just the SSL code. The SSL documentation
13 : : * included with this distribution is covered by the same copyright terms
14 : : * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15 : : *
16 : : * Copyright remains Eric Young's, and as such any Copyright notices in
17 : : * the code are not to be removed.
18 : : * If this package is used in a product, Eric Young should be given attribution
19 : : * as the author of the parts of the library used.
20 : : * This can be in the form of a textual message at program startup or
21 : : * in documentation (online or textual) provided with the package.
22 : : *
23 : : * Redistribution and use in source and binary forms, with or without
24 : : * modification, are permitted provided that the following conditions
25 : : * are met:
26 : : * 1. Redistributions of source code must retain the copyright
27 : : * notice, this list of conditions and the following disclaimer.
28 : : * 2. Redistributions in binary form must reproduce the above copyright
29 : : * notice, this list of conditions and the following disclaimer in the
30 : : * documentation and/or other materials provided with the distribution.
31 : : * 3. All advertising materials mentioning features or use of this software
32 : : * must display the following acknowledgement:
33 : : * "This product includes cryptographic software written by
34 : : * Eric Young (eay@cryptsoft.com)"
35 : : * The word 'cryptographic' can be left out if the rouines from the library
36 : : * being used are not cryptographic related :-).
37 : : * 4. If you include any Windows specific code (or a derivative thereof) from
38 : : * the apps directory (application code) you must include an acknowledgement:
39 : : * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40 : : *
41 : : * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42 : : * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43 : : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44 : : * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45 : : * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46 : : * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47 : : * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 : : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49 : : * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50 : : * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51 : : * SUCH DAMAGE.
52 : : *
53 : : * The licence and distribution terms for any publically available version or
54 : : * derivative of this code cannot be changed. i.e. this code cannot simply be
55 : : * copied and put under another distribution licence
56 : : * [including the GNU Public Licence.]
57 : : */
58 : :
59 : : #include <openssl/blowfish.h>
60 : : #include "bf_locl.h"
61 : :
62 : : /* Blowfish as implemented from 'Blowfish: Springer-Verlag paper'
63 : : * (From LECTURE NOTES IN COMPUTER SCIENCE 809, FAST SOFTWARE ENCRYPTION,
64 : : * CAMBRIDGE SECURITY WORKSHOP, CAMBRIDGE, U.K., DECEMBER 9-11, 1993)
65 : : */
66 : :
67 : : #if (BF_ROUNDS != 16) && (BF_ROUNDS != 20)
68 : : #error If you set BF_ROUNDS to some value other than 16 or 20, you will have \
69 : : to modify the code.
70 : : #endif
71 : :
72 : 45107 : void BF_encrypt(BF_LONG *data, const BF_KEY *key)
73 : : {
74 : : #ifndef BF_PTR2
75 : : register BF_LONG l,r;
76 : : register const BF_LONG *p,*s;
77 : :
78 : 45107 : p=key->P;
79 : 45107 : s= &(key->S[0]);
80 : 45107 : l=data[0];
81 : 45107 : r=data[1];
82 : :
83 : 45107 : l^=p[0];
84 : 45107 : BF_ENC(r,l,s,p[ 1]);
85 : 45107 : BF_ENC(l,r,s,p[ 2]);
86 : 45107 : BF_ENC(r,l,s,p[ 3]);
87 : 45107 : BF_ENC(l,r,s,p[ 4]);
88 : 45107 : BF_ENC(r,l,s,p[ 5]);
89 : 45107 : BF_ENC(l,r,s,p[ 6]);
90 : 45107 : BF_ENC(r,l,s,p[ 7]);
91 : 45107 : BF_ENC(l,r,s,p[ 8]);
92 : 45107 : BF_ENC(r,l,s,p[ 9]);
93 : 45107 : BF_ENC(l,r,s,p[10]);
94 : 45107 : BF_ENC(r,l,s,p[11]);
95 : 45107 : BF_ENC(l,r,s,p[12]);
96 : 45107 : BF_ENC(r,l,s,p[13]);
97 : 45107 : BF_ENC(l,r,s,p[14]);
98 : 45107 : BF_ENC(r,l,s,p[15]);
99 : 45107 : BF_ENC(l,r,s,p[16]);
100 : : #if BF_ROUNDS == 20
101 : : BF_ENC(r,l,s,p[17]);
102 : : BF_ENC(l,r,s,p[18]);
103 : : BF_ENC(r,l,s,p[19]);
104 : : BF_ENC(l,r,s,p[20]);
105 : : #endif
106 : 45107 : r^=p[BF_ROUNDS+1];
107 : :
108 : 45107 : data[1]=l&0xffffffffL;
109 : 45107 : data[0]=r&0xffffffffL;
110 : : #else
111 : : register BF_LONG l,r,t,*k;
112 : :
113 : : l=data[0];
114 : : r=data[1];
115 : : k=(BF_LONG*)key;
116 : :
117 : : l^=k[0];
118 : : BF_ENC(r,l,k, 1);
119 : : BF_ENC(l,r,k, 2);
120 : : BF_ENC(r,l,k, 3);
121 : : BF_ENC(l,r,k, 4);
122 : : BF_ENC(r,l,k, 5);
123 : : BF_ENC(l,r,k, 6);
124 : : BF_ENC(r,l,k, 7);
125 : : BF_ENC(l,r,k, 8);
126 : : BF_ENC(r,l,k, 9);
127 : : BF_ENC(l,r,k,10);
128 : : BF_ENC(r,l,k,11);
129 : : BF_ENC(l,r,k,12);
130 : : BF_ENC(r,l,k,13);
131 : : BF_ENC(l,r,k,14);
132 : : BF_ENC(r,l,k,15);
133 : : BF_ENC(l,r,k,16);
134 : : #if BF_ROUNDS == 20
135 : : BF_ENC(r,l,k,17);
136 : : BF_ENC(l,r,k,18);
137 : : BF_ENC(r,l,k,19);
138 : : BF_ENC(l,r,k,20);
139 : : #endif
140 : : r^=k[BF_ROUNDS+1];
141 : :
142 : : data[1]=l&0xffffffffL;
143 : : data[0]=r&0xffffffffL;
144 : : #endif
145 : 45107 : }
146 : :
147 : : #ifndef BF_DEFAULT_OPTIONS
148 : :
149 : 808 : void BF_decrypt(BF_LONG *data, const BF_KEY *key)
150 : : {
151 : : #ifndef BF_PTR2
152 : : register BF_LONG l,r;
153 : : register const BF_LONG *p,*s;
154 : :
155 : 808 : p=key->P;
156 : 808 : s= &(key->S[0]);
157 : 808 : l=data[0];
158 : 808 : r=data[1];
159 : :
160 : 808 : l^=p[BF_ROUNDS+1];
161 : : #if BF_ROUNDS == 20
162 : : BF_ENC(r,l,s,p[20]);
163 : : BF_ENC(l,r,s,p[19]);
164 : : BF_ENC(r,l,s,p[18]);
165 : : BF_ENC(l,r,s,p[17]);
166 : : #endif
167 : 808 : BF_ENC(r,l,s,p[16]);
168 : 808 : BF_ENC(l,r,s,p[15]);
169 : 808 : BF_ENC(r,l,s,p[14]);
170 : 808 : BF_ENC(l,r,s,p[13]);
171 : 808 : BF_ENC(r,l,s,p[12]);
172 : 808 : BF_ENC(l,r,s,p[11]);
173 : 808 : BF_ENC(r,l,s,p[10]);
174 : 808 : BF_ENC(l,r,s,p[ 9]);
175 : 808 : BF_ENC(r,l,s,p[ 8]);
176 : 808 : BF_ENC(l,r,s,p[ 7]);
177 : 808 : BF_ENC(r,l,s,p[ 6]);
178 : 808 : BF_ENC(l,r,s,p[ 5]);
179 : 808 : BF_ENC(r,l,s,p[ 4]);
180 : 808 : BF_ENC(l,r,s,p[ 3]);
181 : 808 : BF_ENC(r,l,s,p[ 2]);
182 : 808 : BF_ENC(l,r,s,p[ 1]);
183 : 808 : r^=p[0];
184 : :
185 : 808 : data[1]=l&0xffffffffL;
186 : 808 : data[0]=r&0xffffffffL;
187 : : #else
188 : : register BF_LONG l,r,t,*k;
189 : :
190 : : l=data[0];
191 : : r=data[1];
192 : : k=(BF_LONG *)key;
193 : :
194 : : l^=k[BF_ROUNDS+1];
195 : : #if BF_ROUNDS == 20
196 : : BF_ENC(r,l,k,20);
197 : : BF_ENC(l,r,k,19);
198 : : BF_ENC(r,l,k,18);
199 : : BF_ENC(l,r,k,17);
200 : : #endif
201 : : BF_ENC(r,l,k,16);
202 : : BF_ENC(l,r,k,15);
203 : : BF_ENC(r,l,k,14);
204 : : BF_ENC(l,r,k,13);
205 : : BF_ENC(r,l,k,12);
206 : : BF_ENC(l,r,k,11);
207 : : BF_ENC(r,l,k,10);
208 : : BF_ENC(l,r,k, 9);
209 : : BF_ENC(r,l,k, 8);
210 : : BF_ENC(l,r,k, 7);
211 : : BF_ENC(r,l,k, 6);
212 : : BF_ENC(l,r,k, 5);
213 : : BF_ENC(r,l,k, 4);
214 : : BF_ENC(l,r,k, 3);
215 : : BF_ENC(r,l,k, 2);
216 : : BF_ENC(l,r,k, 1);
217 : : r^=k[0];
218 : :
219 : : data[1]=l&0xffffffffL;
220 : : data[0]=r&0xffffffffL;
221 : : #endif
222 : 808 : }
223 : :
224 : 122 : void BF_cbc_encrypt(const unsigned char *in, unsigned char *out, long length,
225 : : const BF_KEY *schedule, unsigned char *ivec, int encrypt)
226 : : {
227 : : register BF_LONG tin0,tin1;
228 : : register BF_LONG tout0,tout1,xor0,xor1;
229 : 122 : register long l=length;
230 : : BF_LONG tin[2];
231 : :
232 [ + + ]: 122 : if (encrypt)
233 : : {
234 : 69 : n2l(ivec,tout0);
235 : 69 : n2l(ivec,tout1);
236 : 69 : ivec-=8;
237 [ + + ]: 584 : for (l-=8; l>=0; l-=8)
238 : : {
239 : 515 : n2l(in,tin0);
240 : 515 : n2l(in,tin1);
241 : 515 : tin0^=tout0;
242 : 515 : tin1^=tout1;
243 : 515 : tin[0]=tin0;
244 : 515 : tin[1]=tin1;
245 : 515 : BF_encrypt(tin,schedule);
246 : 515 : tout0=tin[0];
247 : 515 : tout1=tin[1];
248 : 515 : l2n(tout0,out);
249 : 515 : l2n(tout1,out);
250 : : }
251 [ + + ]: 69 : if (l != -8)
252 : : {
253 [ - - - + : 1 : n2ln(in,tin0,tin1,l+8);
- - - -
- ]
254 : 1 : tin0^=tout0;
255 : 1 : tin1^=tout1;
256 : 1 : tin[0]=tin0;
257 : 1 : tin[1]=tin1;
258 : 1 : BF_encrypt(tin,schedule);
259 : 1 : tout0=tin[0];
260 : 1 : tout1=tin[1];
261 : 1 : l2n(tout0,out);
262 : 1 : l2n(tout1,out);
263 : : }
264 : 69 : l2n(tout0,ivec);
265 : 69 : l2n(tout1,ivec);
266 : : }
267 : : else
268 : : {
269 : 53 : n2l(ivec,xor0);
270 : 53 : n2l(ivec,xor1);
271 : 53 : ivec-=8;
272 [ + + ]: 568 : for (l-=8; l>=0; l-=8)
273 : : {
274 : 515 : n2l(in,tin0);
275 : 515 : n2l(in,tin1);
276 : 515 : tin[0]=tin0;
277 : 515 : tin[1]=tin1;
278 : 515 : BF_decrypt(tin,schedule);
279 : 515 : tout0=tin[0]^xor0;
280 : 515 : tout1=tin[1]^xor1;
281 : 515 : l2n(tout0,out);
282 : 515 : l2n(tout1,out);
283 : 515 : xor0=tin0;
284 : 515 : xor1=tin1;
285 : : }
286 [ + + ]: 53 : if (l != -8)
287 : : {
288 : 1 : n2l(in,tin0);
289 : 1 : n2l(in,tin1);
290 : 1 : tin[0]=tin0;
291 : 1 : tin[1]=tin1;
292 : 1 : BF_decrypt(tin,schedule);
293 : 1 : tout0=tin[0]^xor0;
294 : 1 : tout1=tin[1]^xor1;
295 [ - - - + : 1 : l2nn(tout0,tout1,out,l+8);
- - - -
- ]
296 : 1 : xor0=tin0;
297 : 1 : xor1=tin1;
298 : : }
299 : 53 : l2n(xor0,ivec);
300 : 53 : l2n(xor1,ivec);
301 : : }
302 : 122 : tin0=tin1=tout0=tout1=xor0=xor1=0;
303 : : tin[0]=tin[1]=0;
304 : 122 : }
305 : :
306 : : #endif
|
