Harden ASN.1 BIO handling of large amounts of data.
[openssl.git] / crypto / des / set_key.c
1 /* crypto/des/set_key.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 /*-
60  * set_key.c v 1.4 eay 24/9/91
61  * 1.4 Speed up by 400% :-)
62  * 1.3 added register declarations.
63  * 1.2 unrolled make_key_sched a bit more
64  * 1.1 added norm_expand_bits
65  * 1.0 First working version
66  */
67 #include <openssl/crypto.h>
68 #include "des_locl.h"
69
70 OPENSSL_IMPLEMENT_GLOBAL(int, DES_check_key, 0)
71                                                     /*
72                                                      * defaults to false
73                                                      */
74 static const unsigned char odd_parity[256] = {
75     1, 1, 2, 2, 4, 4, 7, 7, 8, 8, 11, 11, 13, 13, 14, 14,
76     16, 16, 19, 19, 21, 21, 22, 22, 25, 25, 26, 26, 28, 28, 31, 31,
77     32, 32, 35, 35, 37, 37, 38, 38, 41, 41, 42, 42, 44, 44, 47, 47,
78     49, 49, 50, 50, 52, 52, 55, 55, 56, 56, 59, 59, 61, 61, 62, 62,
79     64, 64, 67, 67, 69, 69, 70, 70, 73, 73, 74, 74, 76, 76, 79, 79,
80     81, 81, 82, 82, 84, 84, 87, 87, 88, 88, 91, 91, 93, 93, 94, 94,
81     97, 97, 98, 98, 100, 100, 103, 103, 104, 104, 107, 107, 109, 109, 110,
82     110,
83     112, 112, 115, 115, 117, 117, 118, 118, 121, 121, 122, 122, 124, 124, 127,
84     127,
85     128, 128, 131, 131, 133, 133, 134, 134, 137, 137, 138, 138, 140, 140, 143,
86     143,
87     145, 145, 146, 146, 148, 148, 151, 151, 152, 152, 155, 155, 157, 157, 158,
88     158,
89     161, 161, 162, 162, 164, 164, 167, 167, 168, 168, 171, 171, 173, 173, 174,
90     174,
91     176, 176, 179, 179, 181, 181, 182, 182, 185, 185, 186, 186, 188, 188, 191,
92     191,
93     193, 193, 194, 194, 196, 196, 199, 199, 200, 200, 203, 203, 205, 205, 206,
94     206,
95     208, 208, 211, 211, 213, 213, 214, 214, 217, 217, 218, 218, 220, 220, 223,
96     223,
97     224, 224, 227, 227, 229, 229, 230, 230, 233, 233, 234, 234, 236, 236, 239,
98     239,
99     241, 241, 242, 242, 244, 244, 247, 247, 248, 248, 251, 251, 253, 253, 254,
100     254
101 };
102
103 void DES_set_odd_parity(DES_cblock *key)
104 {
105     unsigned int i;
106
107     for (i = 0; i < DES_KEY_SZ; i++)
108         (*key)[i] = odd_parity[(*key)[i]];
109 }
110
111 int DES_check_key_parity(const_DES_cblock *key)
112 {
113     unsigned int i;
114
115     for (i = 0; i < DES_KEY_SZ; i++) {
116         if ((*key)[i] != odd_parity[(*key)[i]])
117             return (0);
118     }
119     return (1);
120 }
121
122 /*-
123  * Weak and semi week keys as take from
124  * %A D.W. Davies
125  * %A W.L. Price
126  * %T Security for Computer Networks
127  * %I John Wiley & Sons
128  * %D 1984
129  * Many thanks to smb@ulysses.att.com (Steven Bellovin) for the reference
130  * (and actual cblock values).
131  */
132 #define NUM_WEAK_KEY    16
133 static const DES_cblock weak_keys[NUM_WEAK_KEY] = {
134     /* weak keys */
135     {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
136     {0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE},
137     {0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E},
138     {0xE0, 0xE0, 0xE0, 0xE0, 0xF1, 0xF1, 0xF1, 0xF1},
139     /* semi-weak keys */
140     {0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE},
141     {0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01},
142     {0x1F, 0xE0, 0x1F, 0xE0, 0x0E, 0xF1, 0x0E, 0xF1},
143     {0xE0, 0x1F, 0xE0, 0x1F, 0xF1, 0x0E, 0xF1, 0x0E},
144     {0x01, 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1},
145     {0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1, 0x01},
146     {0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E, 0xFE},
147     {0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E},
148     {0x01, 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E},
149     {0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E, 0x01},
150     {0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE},
151     {0xFE, 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1}
152 };
153
154 int DES_is_weak_key(const_DES_cblock *key)
155 {
156     int i;
157
158     for (i = 0; i < NUM_WEAK_KEY; i++)
159         /*
160          * Added == 0 to comparison, I obviously don't run this section very
161          * often :-(, thanks to engineering@MorningStar.Com for the fix eay
162          * 93/06/29 Another problem, I was comparing only the first 4 bytes,
163          * 97/03/18
164          */
165         if (memcmp(weak_keys[i], key, sizeof(DES_cblock)) == 0)
166             return (1);
167     return (0);
168 }
169
170 /*-
171  * NOW DEFINED IN des_local.h
172  * See ecb_encrypt.c for a pseudo description of these macros.
173  * #define PERM_OP(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\
174  *      (b)^=(t),\
175  *      (a)=((a)^((t)<<(n))))
176  */
177
178 #define HPERM_OP(a,t,n,m) ((t)=((((a)<<(16-(n)))^(a))&(m)),\
179         (a)=(a)^(t)^(t>>(16-(n))))
180
181 static const DES_LONG des_skb[8][64] = {
182     {
183      /* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
184      0x00000000L, 0x00000010L, 0x20000000L, 0x20000010L,
185      0x00010000L, 0x00010010L, 0x20010000L, 0x20010010L,
186      0x00000800L, 0x00000810L, 0x20000800L, 0x20000810L,
187      0x00010800L, 0x00010810L, 0x20010800L, 0x20010810L,
188      0x00000020L, 0x00000030L, 0x20000020L, 0x20000030L,
189      0x00010020L, 0x00010030L, 0x20010020L, 0x20010030L,
190      0x00000820L, 0x00000830L, 0x20000820L, 0x20000830L,
191      0x00010820L, 0x00010830L, 0x20010820L, 0x20010830L,
192      0x00080000L, 0x00080010L, 0x20080000L, 0x20080010L,
193      0x00090000L, 0x00090010L, 0x20090000L, 0x20090010L,
194      0x00080800L, 0x00080810L, 0x20080800L, 0x20080810L,
195      0x00090800L, 0x00090810L, 0x20090800L, 0x20090810L,
196      0x00080020L, 0x00080030L, 0x20080020L, 0x20080030L,
197      0x00090020L, 0x00090030L, 0x20090020L, 0x20090030L,
198      0x00080820L, 0x00080830L, 0x20080820L, 0x20080830L,
199      0x00090820L, 0x00090830L, 0x20090820L, 0x20090830L,
200      },
201     {
202      /* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */
203      0x00000000L, 0x02000000L, 0x00002000L, 0x02002000L,
204      0x00200000L, 0x02200000L, 0x00202000L, 0x02202000L,
205      0x00000004L, 0x02000004L, 0x00002004L, 0x02002004L,
206      0x00200004L, 0x02200004L, 0x00202004L, 0x02202004L,
207      0x00000400L, 0x02000400L, 0x00002400L, 0x02002400L,
208      0x00200400L, 0x02200400L, 0x00202400L, 0x02202400L,
209      0x00000404L, 0x02000404L, 0x00002404L, 0x02002404L,
210      0x00200404L, 0x02200404L, 0x00202404L, 0x02202404L,
211      0x10000000L, 0x12000000L, 0x10002000L, 0x12002000L,
212      0x10200000L, 0x12200000L, 0x10202000L, 0x12202000L,
213      0x10000004L, 0x12000004L, 0x10002004L, 0x12002004L,
214      0x10200004L, 0x12200004L, 0x10202004L, 0x12202004L,
215      0x10000400L, 0x12000400L, 0x10002400L, 0x12002400L,
216      0x10200400L, 0x12200400L, 0x10202400L, 0x12202400L,
217      0x10000404L, 0x12000404L, 0x10002404L, 0x12002404L,
218      0x10200404L, 0x12200404L, 0x10202404L, 0x12202404L,
219      },
220     {
221      /* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */
222      0x00000000L, 0x00000001L, 0x00040000L, 0x00040001L,
223      0x01000000L, 0x01000001L, 0x01040000L, 0x01040001L,
224      0x00000002L, 0x00000003L, 0x00040002L, 0x00040003L,
225      0x01000002L, 0x01000003L, 0x01040002L, 0x01040003L,
226      0x00000200L, 0x00000201L, 0x00040200L, 0x00040201L,
227      0x01000200L, 0x01000201L, 0x01040200L, 0x01040201L,
228      0x00000202L, 0x00000203L, 0x00040202L, 0x00040203L,
229      0x01000202L, 0x01000203L, 0x01040202L, 0x01040203L,
230      0x08000000L, 0x08000001L, 0x08040000L, 0x08040001L,
231      0x09000000L, 0x09000001L, 0x09040000L, 0x09040001L,
232      0x08000002L, 0x08000003L, 0x08040002L, 0x08040003L,
233      0x09000002L, 0x09000003L, 0x09040002L, 0x09040003L,
234      0x08000200L, 0x08000201L, 0x08040200L, 0x08040201L,
235      0x09000200L, 0x09000201L, 0x09040200L, 0x09040201L,
236      0x08000202L, 0x08000203L, 0x08040202L, 0x08040203L,
237      0x09000202L, 0x09000203L, 0x09040202L, 0x09040203L,
238      },
239     {
240      /* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */
241      0x00000000L, 0x00100000L, 0x00000100L, 0x00100100L,
242      0x00000008L, 0x00100008L, 0x00000108L, 0x00100108L,
243      0x00001000L, 0x00101000L, 0x00001100L, 0x00101100L,
244      0x00001008L, 0x00101008L, 0x00001108L, 0x00101108L,
245      0x04000000L, 0x04100000L, 0x04000100L, 0x04100100L,
246      0x04000008L, 0x04100008L, 0x04000108L, 0x04100108L,
247      0x04001000L, 0x04101000L, 0x04001100L, 0x04101100L,
248      0x04001008L, 0x04101008L, 0x04001108L, 0x04101108L,
249      0x00020000L, 0x00120000L, 0x00020100L, 0x00120100L,
250      0x00020008L, 0x00120008L, 0x00020108L, 0x00120108L,
251      0x00021000L, 0x00121000L, 0x00021100L, 0x00121100L,
252      0x00021008L, 0x00121008L, 0x00021108L, 0x00121108L,
253      0x04020000L, 0x04120000L, 0x04020100L, 0x04120100L,
254      0x04020008L, 0x04120008L, 0x04020108L, 0x04120108L,
255      0x04021000L, 0x04121000L, 0x04021100L, 0x04121100L,
256      0x04021008L, 0x04121008L, 0x04021108L, 0x04121108L,
257      },
258     {
259      /* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
260      0x00000000L, 0x10000000L, 0x00010000L, 0x10010000L,
261      0x00000004L, 0x10000004L, 0x00010004L, 0x10010004L,
262      0x20000000L, 0x30000000L, 0x20010000L, 0x30010000L,
263      0x20000004L, 0x30000004L, 0x20010004L, 0x30010004L,
264      0x00100000L, 0x10100000L, 0x00110000L, 0x10110000L,
265      0x00100004L, 0x10100004L, 0x00110004L, 0x10110004L,
266      0x20100000L, 0x30100000L, 0x20110000L, 0x30110000L,
267      0x20100004L, 0x30100004L, 0x20110004L, 0x30110004L,
268      0x00001000L, 0x10001000L, 0x00011000L, 0x10011000L,
269      0x00001004L, 0x10001004L, 0x00011004L, 0x10011004L,
270      0x20001000L, 0x30001000L, 0x20011000L, 0x30011000L,
271      0x20001004L, 0x30001004L, 0x20011004L, 0x30011004L,
272      0x00101000L, 0x10101000L, 0x00111000L, 0x10111000L,
273      0x00101004L, 0x10101004L, 0x00111004L, 0x10111004L,
274      0x20101000L, 0x30101000L, 0x20111000L, 0x30111000L,
275      0x20101004L, 0x30101004L, 0x20111004L, 0x30111004L,
276      },
277     {
278      /* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */
279      0x00000000L, 0x08000000L, 0x00000008L, 0x08000008L,
280      0x00000400L, 0x08000400L, 0x00000408L, 0x08000408L,
281      0x00020000L, 0x08020000L, 0x00020008L, 0x08020008L,
282      0x00020400L, 0x08020400L, 0x00020408L, 0x08020408L,
283      0x00000001L, 0x08000001L, 0x00000009L, 0x08000009L,
284      0x00000401L, 0x08000401L, 0x00000409L, 0x08000409L,
285      0x00020001L, 0x08020001L, 0x00020009L, 0x08020009L,
286      0x00020401L, 0x08020401L, 0x00020409L, 0x08020409L,
287      0x02000000L, 0x0A000000L, 0x02000008L, 0x0A000008L,
288      0x02000400L, 0x0A000400L, 0x02000408L, 0x0A000408L,
289      0x02020000L, 0x0A020000L, 0x02020008L, 0x0A020008L,
290      0x02020400L, 0x0A020400L, 0x02020408L, 0x0A020408L,
291      0x02000001L, 0x0A000001L, 0x02000009L, 0x0A000009L,
292      0x02000401L, 0x0A000401L, 0x02000409L, 0x0A000409L,
293      0x02020001L, 0x0A020001L, 0x02020009L, 0x0A020009L,
294      0x02020401L, 0x0A020401L, 0x02020409L, 0x0A020409L,
295      },
296     {
297      /* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */
298      0x00000000L, 0x00000100L, 0x00080000L, 0x00080100L,
299      0x01000000L, 0x01000100L, 0x01080000L, 0x01080100L,
300      0x00000010L, 0x00000110L, 0x00080010L, 0x00080110L,
301      0x01000010L, 0x01000110L, 0x01080010L, 0x01080110L,
302      0x00200000L, 0x00200100L, 0x00280000L, 0x00280100L,
303      0x01200000L, 0x01200100L, 0x01280000L, 0x01280100L,
304      0x00200010L, 0x00200110L, 0x00280010L, 0x00280110L,
305      0x01200010L, 0x01200110L, 0x01280010L, 0x01280110L,
306      0x00000200L, 0x00000300L, 0x00080200L, 0x00080300L,
307      0x01000200L, 0x01000300L, 0x01080200L, 0x01080300L,
308      0x00000210L, 0x00000310L, 0x00080210L, 0x00080310L,
309      0x01000210L, 0x01000310L, 0x01080210L, 0x01080310L,
310      0x00200200L, 0x00200300L, 0x00280200L, 0x00280300L,
311      0x01200200L, 0x01200300L, 0x01280200L, 0x01280300L,
312      0x00200210L, 0x00200310L, 0x00280210L, 0x00280310L,
313      0x01200210L, 0x01200310L, 0x01280210L, 0x01280310L,
314      },
315     {
316      /* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */
317      0x00000000L, 0x04000000L, 0x00040000L, 0x04040000L,
318      0x00000002L, 0x04000002L, 0x00040002L, 0x04040002L,
319      0x00002000L, 0x04002000L, 0x00042000L, 0x04042000L,
320      0x00002002L, 0x04002002L, 0x00042002L, 0x04042002L,
321      0x00000020L, 0x04000020L, 0x00040020L, 0x04040020L,
322      0x00000022L, 0x04000022L, 0x00040022L, 0x04040022L,
323      0x00002020L, 0x04002020L, 0x00042020L, 0x04042020L,
324      0x00002022L, 0x04002022L, 0x00042022L, 0x04042022L,
325      0x00000800L, 0x04000800L, 0x00040800L, 0x04040800L,
326      0x00000802L, 0x04000802L, 0x00040802L, 0x04040802L,
327      0x00002800L, 0x04002800L, 0x00042800L, 0x04042800L,
328      0x00002802L, 0x04002802L, 0x00042802L, 0x04042802L,
329      0x00000820L, 0x04000820L, 0x00040820L, 0x04040820L,
330      0x00000822L, 0x04000822L, 0x00040822L, 0x04040822L,
331      0x00002820L, 0x04002820L, 0x00042820L, 0x04042820L,
332      0x00002822L, 0x04002822L, 0x00042822L, 0x04042822L,
333      }
334 };
335
336 int DES_set_key(const_DES_cblock *key, DES_key_schedule *schedule)
337 {
338     if (DES_check_key) {
339         return DES_set_key_checked(key, schedule);
340     } else {
341         DES_set_key_unchecked(key, schedule);
342         return 0;
343     }
344 }
345
346 /*-
347  * return 0 if key parity is odd (correct),
348  * return -1 if key parity error,
349  * return -2 if illegal weak key.
350  */
351 int DES_set_key_checked(const_DES_cblock *key, DES_key_schedule *schedule)
352 {
353     if (!DES_check_key_parity(key))
354         return (-1);
355     if (DES_is_weak_key(key))
356         return (-2);
357     DES_set_key_unchecked(key, schedule);
358     return 0;
359 }
360
361 void DES_set_key_unchecked(const_DES_cblock *key, DES_key_schedule *schedule)
362 #ifdef OPENSSL_FIPS
363 {
364     fips_cipher_abort(DES);
365     private_DES_set_key_unchecked(key, schedule);
366 }
367
368 void private_DES_set_key_unchecked(const_DES_cblock *key,
369                                    DES_key_schedule *schedule)
370 #endif
371 {
372     static const int shifts2[16] =
373         { 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0 };
374     register DES_LONG c, d, t, s, t2;
375     register const unsigned char *in;
376     register DES_LONG *k;
377     register int i;
378
379 #ifdef OPENBSD_DEV_CRYPTO
380     memcpy(schedule->key, key, sizeof schedule->key);
381     schedule->session = NULL;
382 #endif
383     k = &schedule->ks->deslong[0];
384     in = &(*key)[0];
385
386     c2l(in, c);
387     c2l(in, d);
388
389     /*
390      * do PC1 in 47 simple operations :-) Thanks to John Fletcher
391      * (john_fletcher@lccmail.ocf.llnl.gov) for the inspiration. :-)
392      */
393     PERM_OP(d, c, t, 4, 0x0f0f0f0fL);
394     HPERM_OP(c, t, -2, 0xcccc0000L);
395     HPERM_OP(d, t, -2, 0xcccc0000L);
396     PERM_OP(d, c, t, 1, 0x55555555L);
397     PERM_OP(c, d, t, 8, 0x00ff00ffL);
398     PERM_OP(d, c, t, 1, 0x55555555L);
399     d = (((d & 0x000000ffL) << 16L) | (d & 0x0000ff00L) |
400          ((d & 0x00ff0000L) >> 16L) | ((c & 0xf0000000L) >> 4L));
401     c &= 0x0fffffffL;
402
403     for (i = 0; i < ITERATIONS; i++) {
404         if (shifts2[i]) {
405             c = ((c >> 2L) | (c << 26L));
406             d = ((d >> 2L) | (d << 26L));
407         } else {
408             c = ((c >> 1L) | (c << 27L));
409             d = ((d >> 1L) | (d << 27L));
410         }
411         c &= 0x0fffffffL;
412         d &= 0x0fffffffL;
413         /*
414          * could be a few less shifts but I am to lazy at this point in time
415          * to investigate
416          */
417         s = des_skb[0][(c) & 0x3f] |
418             des_skb[1][((c >> 6L) & 0x03) | ((c >> 7L) & 0x3c)] |
419             des_skb[2][((c >> 13L) & 0x0f) | ((c >> 14L) & 0x30)] |
420             des_skb[3][((c >> 20L) & 0x01) | ((c >> 21L) & 0x06) |
421                        ((c >> 22L) & 0x38)];
422         t = des_skb[4][(d) & 0x3f] |
423             des_skb[5][((d >> 7L) & 0x03) | ((d >> 8L) & 0x3c)] |
424             des_skb[6][(d >> 15L) & 0x3f] |
425             des_skb[7][((d >> 21L) & 0x0f) | ((d >> 22L) & 0x30)];
426
427         /* table contained 0213 4657 */
428         t2 = ((t << 16L) | (s & 0x0000ffffL)) & 0xffffffffL;
429         *(k++) = ROTATE(t2, 30) & 0xffffffffL;
430
431         t2 = ((s >> 16L) | (t & 0xffff0000L));
432         *(k++) = ROTATE(t2, 26) & 0xffffffffL;
433     }
434 }
435
436 int DES_key_sched(const_DES_cblock *key, DES_key_schedule *schedule)
437 {
438     return (DES_set_key(key, schedule));
439 }
440
441 /*-
442 #undef des_fixup_key_parity
443 void des_fixup_key_parity(des_cblock *key)
444         {
445         des_set_odd_parity(key);
446         }
447 */