Print this page
4853 illumos-gate is not lint-clean when built with openssl 1.0
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/lib/openssl/libsunw_crypto/des/des_enc.c
+++ new/usr/src/lib/openssl/libsunw_crypto/des/des_enc.c
1 1 /* crypto/des/des_enc.c */
2 2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3 3 * All rights reserved.
4 4 *
5 5 * This package is an SSL implementation written
6 6 * by Eric Young (eay@cryptsoft.com).
7 7 * The implementation was written so as to conform with Netscapes SSL.
8 8 *
9 9 * This library is free for commercial and non-commercial use as long as
10 10 * the following conditions are aheared to. The following conditions
11 11 * apply to all code found in this distribution, be it the RC4, RSA,
12 12 * lhash, DES, etc., code; not just the SSL code. The SSL documentation
13 13 * included with this distribution is covered by the same copyright terms
14 14 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15 15 *
16 16 * Copyright remains Eric Young's, and as such any Copyright notices in
17 17 * the code are not to be removed.
18 18 * If this package is used in a product, Eric Young should be given attribution
19 19 * as the author of the parts of the library used.
20 20 * This can be in the form of a textual message at program startup or
21 21 * in documentation (online or textual) provided with the package.
22 22 *
23 23 * Redistribution and use in source and binary forms, with or without
24 24 * modification, are permitted provided that the following conditions
25 25 * are met:
26 26 * 1. Redistributions of source code must retain the copyright
27 27 * notice, this list of conditions and the following disclaimer.
28 28 * 2. Redistributions in binary form must reproduce the above copyright
29 29 * notice, this list of conditions and the following disclaimer in the
30 30 * documentation and/or other materials provided with the distribution.
31 31 * 3. All advertising materials mentioning features or use of this software
32 32 * must display the following acknowledgement:
33 33 * "This product includes cryptographic software written by
34 34 * Eric Young (eay@cryptsoft.com)"
35 35 * The word 'cryptographic' can be left out if the rouines from the library
36 36 * being used are not cryptographic related :-).
37 37 * 4. If you include any Windows specific code (or a derivative thereof) from
38 38 * the apps directory (application code) you must include an acknowledgement:
39 39 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40 40 *
41 41 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42 42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43 43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44 44 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45 45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46 46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47 47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
↓ open down ↓ |
48 lines elided |
↑ open up ↑ |
49 49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50 50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51 51 * SUCH DAMAGE.
52 52 *
53 53 * The licence and distribution terms for any publically available version or
54 54 * derivative of this code cannot be changed. i.e. this code cannot simply be
55 55 * copied and put under another distribution licence
56 56 * [including the GNU Public Licence.]
57 57 */
58 58
59 -#include "des_locl.h"
60 -#include "spr.h"
59 +#include <des_locl.h>
60 +#include <spr.h>
61 61
62 62 void DES_encrypt1(DES_LONG *data, DES_key_schedule *ks, int enc)
63 63 {
64 64 register DES_LONG l,r,t,u;
65 65 #ifdef DES_PTR
66 66 register const unsigned char *des_SP=(const unsigned char *)DES_SPtrans;
67 67 #endif
68 68 #ifndef DES_UNROLL
69 69 register int i;
70 70 #endif
71 71 register DES_LONG *s;
72 72
73 73 r=data[0];
74 74 l=data[1];
75 75
76 76 IP(r,l);
77 77 /* Things have been modified so that the initial rotate is
78 78 * done outside the loop. This required the
79 79 * DES_SPtrans values in sp.h to be rotated 1 bit to the right.
80 80 * One perl script later and things have a 5% speed up on a sparc2.
81 81 * Thanks to Richard Outerbridge <71755.204@CompuServe.COM>
82 82 * for pointing this out. */
83 83 /* clear the top bits on machines with 8byte longs */
84 84 /* shift left by 2 */
85 85 r=ROTATE(r,29)&0xffffffffL;
86 86 l=ROTATE(l,29)&0xffffffffL;
87 87
88 88 s=ks->ks->deslong;
89 89 /* I don't know if it is worth the effort of loop unrolling the
90 90 * inner loop */
91 91 if (enc)
92 92 {
93 93 #ifdef DES_UNROLL
94 94 D_ENCRYPT(l,r, 0); /* 1 */
95 95 D_ENCRYPT(r,l, 2); /* 2 */
96 96 D_ENCRYPT(l,r, 4); /* 3 */
97 97 D_ENCRYPT(r,l, 6); /* 4 */
98 98 D_ENCRYPT(l,r, 8); /* 5 */
99 99 D_ENCRYPT(r,l,10); /* 6 */
100 100 D_ENCRYPT(l,r,12); /* 7 */
101 101 D_ENCRYPT(r,l,14); /* 8 */
102 102 D_ENCRYPT(l,r,16); /* 9 */
103 103 D_ENCRYPT(r,l,18); /* 10 */
104 104 D_ENCRYPT(l,r,20); /* 11 */
105 105 D_ENCRYPT(r,l,22); /* 12 */
106 106 D_ENCRYPT(l,r,24); /* 13 */
107 107 D_ENCRYPT(r,l,26); /* 14 */
108 108 D_ENCRYPT(l,r,28); /* 15 */
109 109 D_ENCRYPT(r,l,30); /* 16 */
110 110 #else
111 111 for (i=0; i<32; i+=4)
112 112 {
113 113 D_ENCRYPT(l,r,i+0); /* 1 */
114 114 D_ENCRYPT(r,l,i+2); /* 2 */
115 115 }
116 116 #endif
117 117 }
118 118 else
119 119 {
120 120 #ifdef DES_UNROLL
121 121 D_ENCRYPT(l,r,30); /* 16 */
122 122 D_ENCRYPT(r,l,28); /* 15 */
123 123 D_ENCRYPT(l,r,26); /* 14 */
124 124 D_ENCRYPT(r,l,24); /* 13 */
125 125 D_ENCRYPT(l,r,22); /* 12 */
126 126 D_ENCRYPT(r,l,20); /* 11 */
127 127 D_ENCRYPT(l,r,18); /* 10 */
128 128 D_ENCRYPT(r,l,16); /* 9 */
129 129 D_ENCRYPT(l,r,14); /* 8 */
130 130 D_ENCRYPT(r,l,12); /* 7 */
131 131 D_ENCRYPT(l,r,10); /* 6 */
132 132 D_ENCRYPT(r,l, 8); /* 5 */
133 133 D_ENCRYPT(l,r, 6); /* 4 */
134 134 D_ENCRYPT(r,l, 4); /* 3 */
135 135 D_ENCRYPT(l,r, 2); /* 2 */
136 136 D_ENCRYPT(r,l, 0); /* 1 */
137 137 #else
138 138 for (i=30; i>0; i-=4)
139 139 {
140 140 D_ENCRYPT(l,r,i-0); /* 16 */
141 141 D_ENCRYPT(r,l,i-2); /* 15 */
142 142 }
143 143 #endif
144 144 }
145 145
146 146 /* rotate and clear the top bits on machines with 8byte longs */
147 147 l=ROTATE(l,3)&0xffffffffL;
148 148 r=ROTATE(r,3)&0xffffffffL;
149 149
150 150 FP(r,l);
151 151 data[0]=l;
152 152 data[1]=r;
153 153 l=r=t=u=0;
154 154 }
155 155
156 156 void DES_encrypt2(DES_LONG *data, DES_key_schedule *ks, int enc)
157 157 {
158 158 register DES_LONG l,r,t,u;
159 159 #ifdef DES_PTR
160 160 register const unsigned char *des_SP=(const unsigned char *)DES_SPtrans;
161 161 #endif
162 162 #ifndef DES_UNROLL
163 163 register int i;
164 164 #endif
165 165 register DES_LONG *s;
166 166
167 167 r=data[0];
168 168 l=data[1];
169 169
170 170 /* Things have been modified so that the initial rotate is
171 171 * done outside the loop. This required the
172 172 * DES_SPtrans values in sp.h to be rotated 1 bit to the right.
173 173 * One perl script later and things have a 5% speed up on a sparc2.
174 174 * Thanks to Richard Outerbridge <71755.204@CompuServe.COM>
175 175 * for pointing this out. */
176 176 /* clear the top bits on machines with 8byte longs */
177 177 r=ROTATE(r,29)&0xffffffffL;
178 178 l=ROTATE(l,29)&0xffffffffL;
179 179
180 180 s=ks->ks->deslong;
181 181 /* I don't know if it is worth the effort of loop unrolling the
182 182 * inner loop */
183 183 if (enc)
184 184 {
185 185 #ifdef DES_UNROLL
186 186 D_ENCRYPT(l,r, 0); /* 1 */
187 187 D_ENCRYPT(r,l, 2); /* 2 */
188 188 D_ENCRYPT(l,r, 4); /* 3 */
189 189 D_ENCRYPT(r,l, 6); /* 4 */
190 190 D_ENCRYPT(l,r, 8); /* 5 */
191 191 D_ENCRYPT(r,l,10); /* 6 */
192 192 D_ENCRYPT(l,r,12); /* 7 */
193 193 D_ENCRYPT(r,l,14); /* 8 */
194 194 D_ENCRYPT(l,r,16); /* 9 */
195 195 D_ENCRYPT(r,l,18); /* 10 */
196 196 D_ENCRYPT(l,r,20); /* 11 */
197 197 D_ENCRYPT(r,l,22); /* 12 */
198 198 D_ENCRYPT(l,r,24); /* 13 */
199 199 D_ENCRYPT(r,l,26); /* 14 */
200 200 D_ENCRYPT(l,r,28); /* 15 */
201 201 D_ENCRYPT(r,l,30); /* 16 */
202 202 #else
203 203 for (i=0; i<32; i+=4)
204 204 {
205 205 D_ENCRYPT(l,r,i+0); /* 1 */
206 206 D_ENCRYPT(r,l,i+2); /* 2 */
207 207 }
208 208 #endif
209 209 }
210 210 else
211 211 {
212 212 #ifdef DES_UNROLL
213 213 D_ENCRYPT(l,r,30); /* 16 */
214 214 D_ENCRYPT(r,l,28); /* 15 */
215 215 D_ENCRYPT(l,r,26); /* 14 */
216 216 D_ENCRYPT(r,l,24); /* 13 */
217 217 D_ENCRYPT(l,r,22); /* 12 */
218 218 D_ENCRYPT(r,l,20); /* 11 */
219 219 D_ENCRYPT(l,r,18); /* 10 */
220 220 D_ENCRYPT(r,l,16); /* 9 */
221 221 D_ENCRYPT(l,r,14); /* 8 */
222 222 D_ENCRYPT(r,l,12); /* 7 */
223 223 D_ENCRYPT(l,r,10); /* 6 */
224 224 D_ENCRYPT(r,l, 8); /* 5 */
225 225 D_ENCRYPT(l,r, 6); /* 4 */
226 226 D_ENCRYPT(r,l, 4); /* 3 */
227 227 D_ENCRYPT(l,r, 2); /* 2 */
228 228 D_ENCRYPT(r,l, 0); /* 1 */
229 229 #else
230 230 for (i=30; i>0; i-=4)
231 231 {
232 232 D_ENCRYPT(l,r,i-0); /* 16 */
233 233 D_ENCRYPT(r,l,i-2); /* 15 */
234 234 }
235 235 #endif
236 236 }
237 237 /* rotate and clear the top bits on machines with 8byte longs */
238 238 data[0]=ROTATE(l,3)&0xffffffffL;
239 239 data[1]=ROTATE(r,3)&0xffffffffL;
240 240 l=r=t=u=0;
241 241 }
242 242
243 243 void DES_encrypt3(DES_LONG *data, DES_key_schedule *ks1,
244 244 DES_key_schedule *ks2, DES_key_schedule *ks3)
245 245 {
246 246 register DES_LONG l,r;
247 247
248 248 l=data[0];
249 249 r=data[1];
250 250 IP(l,r);
251 251 data[0]=l;
252 252 data[1]=r;
253 253 DES_encrypt2((DES_LONG *)data,ks1,DES_ENCRYPT);
254 254 DES_encrypt2((DES_LONG *)data,ks2,DES_DECRYPT);
255 255 DES_encrypt2((DES_LONG *)data,ks3,DES_ENCRYPT);
256 256 l=data[0];
257 257 r=data[1];
258 258 FP(r,l);
259 259 data[0]=l;
260 260 data[1]=r;
261 261 }
262 262
263 263 void DES_decrypt3(DES_LONG *data, DES_key_schedule *ks1,
264 264 DES_key_schedule *ks2, DES_key_schedule *ks3)
265 265 {
266 266 register DES_LONG l,r;
267 267
268 268 l=data[0];
269 269 r=data[1];
270 270 IP(l,r);
271 271 data[0]=l;
272 272 data[1]=r;
273 273 DES_encrypt2((DES_LONG *)data,ks3,DES_DECRYPT);
274 274 DES_encrypt2((DES_LONG *)data,ks2,DES_ENCRYPT);
275 275 DES_encrypt2((DES_LONG *)data,ks1,DES_DECRYPT);
276 276 l=data[0];
277 277 r=data[1];
278 278 FP(r,l);
279 279 data[0]=l;
280 280 data[1]=r;
281 281 }
282 282
283 283 #ifndef DES_DEFAULT_OPTIONS
284 284
285 285 #undef CBC_ENC_C__DONT_UPDATE_IV
286 286 #include "ncbc_enc.c" /* DES_ncbc_encrypt */
287 287
288 288 void DES_ede3_cbc_encrypt(const unsigned char *input, unsigned char *output,
289 289 long length, DES_key_schedule *ks1,
290 290 DES_key_schedule *ks2, DES_key_schedule *ks3,
291 291 DES_cblock *ivec, int enc)
292 292 {
293 293 register DES_LONG tin0,tin1;
294 294 register DES_LONG tout0,tout1,xor0,xor1;
295 295 register const unsigned char *in;
296 296 unsigned char *out;
297 297 register long l=length;
298 298 DES_LONG tin[2];
299 299 unsigned char *iv;
300 300
301 301 in=input;
302 302 out=output;
303 303 iv = &(*ivec)[0];
304 304
305 305 if (enc)
306 306 {
307 307 c2l(iv,tout0);
308 308 c2l(iv,tout1);
309 309 for (l-=8; l>=0; l-=8)
310 310 {
311 311 c2l(in,tin0);
312 312 c2l(in,tin1);
313 313 tin0^=tout0;
314 314 tin1^=tout1;
315 315
316 316 tin[0]=tin0;
317 317 tin[1]=tin1;
318 318 DES_encrypt3((DES_LONG *)tin,ks1,ks2,ks3);
319 319 tout0=tin[0];
320 320 tout1=tin[1];
321 321
322 322 l2c(tout0,out);
323 323 l2c(tout1,out);
324 324 }
325 325 if (l != -8)
326 326 {
327 327 c2ln(in,tin0,tin1,l+8);
328 328 tin0^=tout0;
329 329 tin1^=tout1;
330 330
331 331 tin[0]=tin0;
332 332 tin[1]=tin1;
333 333 DES_encrypt3((DES_LONG *)tin,ks1,ks2,ks3);
334 334 tout0=tin[0];
335 335 tout1=tin[1];
336 336
337 337 l2c(tout0,out);
338 338 l2c(tout1,out);
339 339 }
340 340 iv = &(*ivec)[0];
341 341 l2c(tout0,iv);
342 342 l2c(tout1,iv);
343 343 }
344 344 else
345 345 {
346 346 register DES_LONG t0,t1;
347 347
348 348 c2l(iv,xor0);
349 349 c2l(iv,xor1);
350 350 for (l-=8; l>=0; l-=8)
351 351 {
352 352 c2l(in,tin0);
353 353 c2l(in,tin1);
354 354
355 355 t0=tin0;
356 356 t1=tin1;
357 357
358 358 tin[0]=tin0;
359 359 tin[1]=tin1;
360 360 DES_decrypt3((DES_LONG *)tin,ks1,ks2,ks3);
361 361 tout0=tin[0];
362 362 tout1=tin[1];
363 363
364 364 tout0^=xor0;
365 365 tout1^=xor1;
366 366 l2c(tout0,out);
367 367 l2c(tout1,out);
368 368 xor0=t0;
369 369 xor1=t1;
370 370 }
371 371 if (l != -8)
372 372 {
373 373 c2l(in,tin0);
374 374 c2l(in,tin1);
375 375
376 376 t0=tin0;
377 377 t1=tin1;
378 378
379 379 tin[0]=tin0;
380 380 tin[1]=tin1;
381 381 DES_decrypt3((DES_LONG *)tin,ks1,ks2,ks3);
382 382 tout0=tin[0];
383 383 tout1=tin[1];
384 384
385 385 tout0^=xor0;
386 386 tout1^=xor1;
387 387 l2cn(tout0,tout1,out,l+8);
388 388 xor0=t0;
389 389 xor1=t1;
390 390 }
391 391
392 392 iv = &(*ivec)[0];
393 393 l2c(xor0,iv);
394 394 l2c(xor1,iv);
395 395 }
396 396 tin0=tin1=tout0=tout1=xor0=xor1=0;
397 397 tin[0]=tin[1]=0;
398 398 }
399 399
400 400 #endif /* DES_DEFAULT_OPTIONS */
|
↓ open down ↓ |
330 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX