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