Add -show_chain option to print out verified chain.
[openssl.git] / crypto / des / des_enc.c
1 /* crypto/des/des_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/crypto.h>
60 #include "des_locl.h"
61 #include "spr.h"
62
63 void DES_encrypt1(DES_LONG *data, DES_key_schedule *ks, int enc)
64         {
65         register DES_LONG l,r,t,u;
66 #ifdef DES_PTR
67         register const unsigned char *des_SP=(const unsigned char *)DES_SPtrans;
68 #endif
69 #ifndef DES_UNROLL
70         register int i;
71 #endif
72         register DES_LONG *s;
73
74         r=data[0];
75         l=data[1];
76
77         IP(r,l);
78         /* Things have been modified so that the initial rotate is
79          * done outside the loop.  This required the
80          * DES_SPtrans values in sp.h to be rotated 1 bit to the right.
81          * One perl script later and things have a 5% speed up on a sparc2.
82          * Thanks to Richard Outerbridge <71755.204@CompuServe.COM>
83          * for pointing this out. */
84         /* clear the top bits on machines with 8byte longs */
85         /* shift left by 2 */
86         r=ROTATE(r,29)&0xffffffffL;
87         l=ROTATE(l,29)&0xffffffffL;
88
89         s=ks->ks->deslong;
90         /* I don't know if it is worth the effort of loop unrolling the
91          * inner loop */
92         if (enc)
93                 {
94 #ifdef DES_UNROLL
95                 D_ENCRYPT(l,r, 0); /*  1 */
96                 D_ENCRYPT(r,l, 2); /*  2 */
97                 D_ENCRYPT(l,r, 4); /*  3 */
98                 D_ENCRYPT(r,l, 6); /*  4 */
99                 D_ENCRYPT(l,r, 8); /*  5 */
100                 D_ENCRYPT(r,l,10); /*  6 */
101                 D_ENCRYPT(l,r,12); /*  7 */
102                 D_ENCRYPT(r,l,14); /*  8 */
103                 D_ENCRYPT(l,r,16); /*  9 */
104                 D_ENCRYPT(r,l,18); /*  10 */
105                 D_ENCRYPT(l,r,20); /*  11 */
106                 D_ENCRYPT(r,l,22); /*  12 */
107                 D_ENCRYPT(l,r,24); /*  13 */
108                 D_ENCRYPT(r,l,26); /*  14 */
109                 D_ENCRYPT(l,r,28); /*  15 */
110                 D_ENCRYPT(r,l,30); /*  16 */
111 #else
112                 for (i=0; i<32; i+=4)
113                         {
114                         D_ENCRYPT(l,r,i+0); /*  1 */
115                         D_ENCRYPT(r,l,i+2); /*  2 */
116                         }
117 #endif
118                 }
119         else
120                 {
121 #ifdef DES_UNROLL
122                 D_ENCRYPT(l,r,30); /* 16 */
123                 D_ENCRYPT(r,l,28); /* 15 */
124                 D_ENCRYPT(l,r,26); /* 14 */
125                 D_ENCRYPT(r,l,24); /* 13 */
126                 D_ENCRYPT(l,r,22); /* 12 */
127                 D_ENCRYPT(r,l,20); /* 11 */
128                 D_ENCRYPT(l,r,18); /* 10 */
129                 D_ENCRYPT(r,l,16); /*  9 */
130                 D_ENCRYPT(l,r,14); /*  8 */
131                 D_ENCRYPT(r,l,12); /*  7 */
132                 D_ENCRYPT(l,r,10); /*  6 */
133                 D_ENCRYPT(r,l, 8); /*  5 */
134                 D_ENCRYPT(l,r, 6); /*  4 */
135                 D_ENCRYPT(r,l, 4); /*  3 */
136                 D_ENCRYPT(l,r, 2); /*  2 */
137                 D_ENCRYPT(r,l, 0); /*  1 */
138 #else
139                 for (i=30; i>0; i-=4)
140                         {
141                         D_ENCRYPT(l,r,i-0); /* 16 */
142                         D_ENCRYPT(r,l,i-2); /* 15 */
143                         }
144 #endif
145                 }
146
147         /* rotate and clear the top bits on machines with 8byte longs */
148         l=ROTATE(l,3)&0xffffffffL;
149         r=ROTATE(r,3)&0xffffffffL;
150
151         FP(r,l);
152         data[0]=l;
153         data[1]=r;
154         l=r=t=u=0;
155         }
156
157 void DES_encrypt2(DES_LONG *data, DES_key_schedule *ks, int enc)
158         {
159         register DES_LONG l,r,t,u;
160 #ifdef DES_PTR
161         register const unsigned char *des_SP=(const unsigned char *)DES_SPtrans;
162 #endif
163 #ifndef DES_UNROLL
164         register int i;
165 #endif
166         register DES_LONG *s;
167
168         r=data[0];
169         l=data[1];
170
171         /* Things have been modified so that the initial rotate is
172          * done outside the loop.  This required the
173          * DES_SPtrans values in sp.h to be rotated 1 bit to the right.
174          * One perl script later and things have a 5% speed up on a sparc2.
175          * Thanks to Richard Outerbridge <71755.204@CompuServe.COM>
176          * for pointing this out. */
177         /* clear the top bits on machines with 8byte longs */
178         r=ROTATE(r,29)&0xffffffffL;
179         l=ROTATE(l,29)&0xffffffffL;
180
181         s=ks->ks->deslong;
182         /* I don't know if it is worth the effort of loop unrolling the
183          * inner loop */
184         if (enc)
185                 {
186 #ifdef DES_UNROLL
187                 D_ENCRYPT(l,r, 0); /*  1 */
188                 D_ENCRYPT(r,l, 2); /*  2 */
189                 D_ENCRYPT(l,r, 4); /*  3 */
190                 D_ENCRYPT(r,l, 6); /*  4 */
191                 D_ENCRYPT(l,r, 8); /*  5 */
192                 D_ENCRYPT(r,l,10); /*  6 */
193                 D_ENCRYPT(l,r,12); /*  7 */
194                 D_ENCRYPT(r,l,14); /*  8 */
195                 D_ENCRYPT(l,r,16); /*  9 */
196                 D_ENCRYPT(r,l,18); /*  10 */
197                 D_ENCRYPT(l,r,20); /*  11 */
198                 D_ENCRYPT(r,l,22); /*  12 */
199                 D_ENCRYPT(l,r,24); /*  13 */
200                 D_ENCRYPT(r,l,26); /*  14 */
201                 D_ENCRYPT(l,r,28); /*  15 */
202                 D_ENCRYPT(r,l,30); /*  16 */
203 #else
204                 for (i=0; i<32; i+=4)
205                         {
206                         D_ENCRYPT(l,r,i+0); /*  1 */
207                         D_ENCRYPT(r,l,i+2); /*  2 */
208                         }
209 #endif
210                 }
211         else
212                 {
213 #ifdef DES_UNROLL
214                 D_ENCRYPT(l,r,30); /* 16 */
215                 D_ENCRYPT(r,l,28); /* 15 */
216                 D_ENCRYPT(l,r,26); /* 14 */
217                 D_ENCRYPT(r,l,24); /* 13 */
218                 D_ENCRYPT(l,r,22); /* 12 */
219                 D_ENCRYPT(r,l,20); /* 11 */
220                 D_ENCRYPT(l,r,18); /* 10 */
221                 D_ENCRYPT(r,l,16); /*  9 */
222                 D_ENCRYPT(l,r,14); /*  8 */
223                 D_ENCRYPT(r,l,12); /*  7 */
224                 D_ENCRYPT(l,r,10); /*  6 */
225                 D_ENCRYPT(r,l, 8); /*  5 */
226                 D_ENCRYPT(l,r, 6); /*  4 */
227                 D_ENCRYPT(r,l, 4); /*  3 */
228                 D_ENCRYPT(l,r, 2); /*  2 */
229                 D_ENCRYPT(r,l, 0); /*  1 */
230 #else
231                 for (i=30; i>0; i-=4)
232                         {
233                         D_ENCRYPT(l,r,i-0); /* 16 */
234                         D_ENCRYPT(r,l,i-2); /* 15 */
235                         }
236 #endif
237                 }
238         /* rotate and clear the top bits on machines with 8byte longs */
239         data[0]=ROTATE(l,3)&0xffffffffL;
240         data[1]=ROTATE(r,3)&0xffffffffL;
241         l=r=t=u=0;
242         }
243
244 void DES_encrypt3(DES_LONG *data, DES_key_schedule *ks1,
245                   DES_key_schedule *ks2, DES_key_schedule *ks3)
246         {
247         register DES_LONG l,r;
248
249         l=data[0];
250         r=data[1];
251         IP(l,r);
252         data[0]=l;
253         data[1]=r;
254         DES_encrypt2((DES_LONG *)data,ks1,DES_ENCRYPT);
255         DES_encrypt2((DES_LONG *)data,ks2,DES_DECRYPT);
256         DES_encrypt2((DES_LONG *)data,ks3,DES_ENCRYPT);
257         l=data[0];
258         r=data[1];
259         FP(r,l);
260         data[0]=l;
261         data[1]=r;
262         }
263
264 void DES_decrypt3(DES_LONG *data, DES_key_schedule *ks1,
265                   DES_key_schedule *ks2, DES_key_schedule *ks3)
266         {
267         register DES_LONG l,r;
268
269         l=data[0];
270         r=data[1];
271         IP(l,r);
272         data[0]=l;
273         data[1]=r;
274         DES_encrypt2((DES_LONG *)data,ks3,DES_DECRYPT);
275         DES_encrypt2((DES_LONG *)data,ks2,DES_ENCRYPT);
276         DES_encrypt2((DES_LONG *)data,ks1,DES_DECRYPT);
277         l=data[0];
278         r=data[1];
279         FP(r,l);
280         data[0]=l;
281         data[1]=r;
282         }
283
284 #ifndef DES_DEFAULT_OPTIONS
285
286 #undef CBC_ENC_C__DONT_UPDATE_IV
287 #include "ncbc_enc.c" /* DES_ncbc_encrypt */
288
289 void DES_ede3_cbc_encrypt(const unsigned char *input, unsigned char *output,
290                           long length, DES_key_schedule *ks1,
291                           DES_key_schedule *ks2, DES_key_schedule *ks3,
292                           DES_cblock *ivec, int enc)
293         {
294         register DES_LONG tin0,tin1;
295         register DES_LONG tout0,tout1,xor0,xor1;
296         register const unsigned char *in;
297         unsigned char *out;
298         register long l=length;
299         DES_LONG tin[2];
300         unsigned char *iv;
301
302         in=input;
303         out=output;
304         iv = &(*ivec)[0];
305
306         if (enc)
307                 {
308                 c2l(iv,tout0);
309                 c2l(iv,tout1);
310                 for (l-=8; l>=0; l-=8)
311                         {
312                         c2l(in,tin0);
313                         c2l(in,tin1);
314                         tin0^=tout0;
315                         tin1^=tout1;
316
317                         tin[0]=tin0;
318                         tin[1]=tin1;
319                         DES_encrypt3((DES_LONG *)tin,ks1,ks2,ks3);
320                         tout0=tin[0];
321                         tout1=tin[1];
322
323                         l2c(tout0,out);
324                         l2c(tout1,out);
325                         }
326                 if (l != -8)
327                         {
328                         c2ln(in,tin0,tin1,l+8);
329                         tin0^=tout0;
330                         tin1^=tout1;
331
332                         tin[0]=tin0;
333                         tin[1]=tin1;
334                         DES_encrypt3((DES_LONG *)tin,ks1,ks2,ks3);
335                         tout0=tin[0];
336                         tout1=tin[1];
337
338                         l2c(tout0,out);
339                         l2c(tout1,out);
340                         }
341                 iv = &(*ivec)[0];
342                 l2c(tout0,iv);
343                 l2c(tout1,iv);
344                 }
345         else
346                 {
347                 register DES_LONG t0,t1;
348
349                 c2l(iv,xor0);
350                 c2l(iv,xor1);
351                 for (l-=8; l>=0; l-=8)
352                         {
353                         c2l(in,tin0);
354                         c2l(in,tin1);
355
356                         t0=tin0;
357                         t1=tin1;
358
359                         tin[0]=tin0;
360                         tin[1]=tin1;
361                         DES_decrypt3((DES_LONG *)tin,ks1,ks2,ks3);
362                         tout0=tin[0];
363                         tout1=tin[1];
364
365                         tout0^=xor0;
366                         tout1^=xor1;
367                         l2c(tout0,out);
368                         l2c(tout1,out);
369                         xor0=t0;
370                         xor1=t1;
371                         }
372                 if (l != -8)
373                         {
374                         c2l(in,tin0);
375                         c2l(in,tin1);
376                         
377                         t0=tin0;
378                         t1=tin1;
379
380                         tin[0]=tin0;
381                         tin[1]=tin1;
382                         DES_decrypt3((DES_LONG *)tin,ks1,ks2,ks3);
383                         tout0=tin[0];
384                         tout1=tin[1];
385                 
386                         tout0^=xor0;
387                         tout1^=xor1;
388                         l2cn(tout0,tout1,out,l+8);
389                         xor0=t0;
390                         xor1=t1;
391                         }
392
393                 iv = &(*ivec)[0];
394                 l2c(xor0,iv);
395                 l2c(xor1,iv);
396                 }
397         tin0=tin1=tout0=tout1=xor0=xor1=0;
398         tin[0]=tin[1]=0;
399         }
400
401 #endif /* DES_DEFAULT_OPTIONS */