]>
sourceware.org Git - glibc.git/blob - sunrpc/des_impl.c
1 /* Copyright (C) 1992 Eric Young - see COPYING for more details */
2 /* Collected from libdes and modified for SECURE RPC by Martin Kuck 1994 */
7 static const unsigned long des_SPtrans
[8][64] =
10 0x00820200, 0x00020000, 0x80800000, 0x80820200,
11 0x00800000, 0x80020200, 0x80020000, 0x80800000,
12 0x80020200, 0x00820200, 0x00820000, 0x80000200,
13 0x80800200, 0x00800000, 0x00000000, 0x80020000,
14 0x00020000, 0x80000000, 0x00800200, 0x00020200,
15 0x80820200, 0x00820000, 0x80000200, 0x00800200,
16 0x80000000, 0x00000200, 0x00020200, 0x80820000,
17 0x00000200, 0x80800200, 0x80820000, 0x00000000,
18 0x00000000, 0x80820200, 0x00800200, 0x80020000,
19 0x00820200, 0x00020000, 0x80000200, 0x00800200,
20 0x80820000, 0x00000200, 0x00020200, 0x80800000,
21 0x80020200, 0x80000000, 0x80800000, 0x00820000,
22 0x80820200, 0x00020200, 0x00820000, 0x80800200,
23 0x00800000, 0x80000200, 0x80020000, 0x00000000,
24 0x00020000, 0x00800000, 0x80800200, 0x00820200,
25 0x80000000, 0x80820000, 0x00000200, 0x80020200},
28 0x10042004, 0x00000000, 0x00042000, 0x10040000,
29 0x10000004, 0x00002004, 0x10002000, 0x00042000,
30 0x00002000, 0x10040004, 0x00000004, 0x10002000,
31 0x00040004, 0x10042000, 0x10040000, 0x00000004,
32 0x00040000, 0x10002004, 0x10040004, 0x00002000,
33 0x00042004, 0x10000000, 0x00000000, 0x00040004,
34 0x10002004, 0x00042004, 0x10042000, 0x10000004,
35 0x10000000, 0x00040000, 0x00002004, 0x10042004,
36 0x00040004, 0x10042000, 0x10002000, 0x00042004,
37 0x10042004, 0x00040004, 0x10000004, 0x00000000,
38 0x10000000, 0x00002004, 0x00040000, 0x10040004,
39 0x00002000, 0x10000000, 0x00042004, 0x10002004,
40 0x10042000, 0x00002000, 0x00000000, 0x10000004,
41 0x00000004, 0x10042004, 0x00042000, 0x10040000,
42 0x10040004, 0x00040000, 0x00002004, 0x10002000,
43 0x10002004, 0x00000004, 0x10040000, 0x00042000},
46 0x41000000, 0x01010040, 0x00000040, 0x41000040,
47 0x40010000, 0x01000000, 0x41000040, 0x00010040,
48 0x01000040, 0x00010000, 0x01010000, 0x40000000,
49 0x41010040, 0x40000040, 0x40000000, 0x41010000,
50 0x00000000, 0x40010000, 0x01010040, 0x00000040,
51 0x40000040, 0x41010040, 0x00010000, 0x41000000,
52 0x41010000, 0x01000040, 0x40010040, 0x01010000,
53 0x00010040, 0x00000000, 0x01000000, 0x40010040,
54 0x01010040, 0x00000040, 0x40000000, 0x00010000,
55 0x40000040, 0x40010000, 0x01010000, 0x41000040,
56 0x00000000, 0x01010040, 0x00010040, 0x41010000,
57 0x40010000, 0x01000000, 0x41010040, 0x40000000,
58 0x40010040, 0x41000000, 0x01000000, 0x41010040,
59 0x00010000, 0x01000040, 0x41000040, 0x00010040,
60 0x01000040, 0x00000000, 0x41010000, 0x40000040,
61 0x41000000, 0x40010040, 0x00000040, 0x01010000},
64 0x00100402, 0x04000400, 0x00000002, 0x04100402,
65 0x00000000, 0x04100000, 0x04000402, 0x00100002,
66 0x04100400, 0x04000002, 0x04000000, 0x00000402,
67 0x04000002, 0x00100402, 0x00100000, 0x04000000,
68 0x04100002, 0x00100400, 0x00000400, 0x00000002,
69 0x00100400, 0x04000402, 0x04100000, 0x00000400,
70 0x00000402, 0x00000000, 0x00100002, 0x04100400,
71 0x04000400, 0x04100002, 0x04100402, 0x00100000,
72 0x04100002, 0x00000402, 0x00100000, 0x04000002,
73 0x00100400, 0x04000400, 0x00000002, 0x04100000,
74 0x04000402, 0x00000000, 0x00000400, 0x00100002,
75 0x00000000, 0x04100002, 0x04100400, 0x00000400,
76 0x04000000, 0x04100402, 0x00100402, 0x00100000,
77 0x04100402, 0x00000002, 0x04000400, 0x00100402,
78 0x00100002, 0x00100400, 0x04100000, 0x04000402,
79 0x00000402, 0x04000000, 0x04000002, 0x04100400},
82 0x02000000, 0x00004000, 0x00000100, 0x02004108,
83 0x02004008, 0x02000100, 0x00004108, 0x02004000,
84 0x00004000, 0x00000008, 0x02000008, 0x00004100,
85 0x02000108, 0x02004008, 0x02004100, 0x00000000,
86 0x00004100, 0x02000000, 0x00004008, 0x00000108,
87 0x02000100, 0x00004108, 0x00000000, 0x02000008,
88 0x00000008, 0x02000108, 0x02004108, 0x00004008,
89 0x02004000, 0x00000100, 0x00000108, 0x02004100,
90 0x02004100, 0x02000108, 0x00004008, 0x02004000,
91 0x00004000, 0x00000008, 0x02000008, 0x02000100,
92 0x02000000, 0x00004100, 0x02004108, 0x00000000,
93 0x00004108, 0x02000000, 0x00000100, 0x00004008,
94 0x02000108, 0x00000100, 0x00000000, 0x02004108,
95 0x02004008, 0x02004100, 0x00000108, 0x00004000,
96 0x00004100, 0x02004008, 0x02000100, 0x00000108,
97 0x00000008, 0x00004108, 0x02004000, 0x02000008},
100 0x20000010, 0x00080010, 0x00000000, 0x20080800,
101 0x00080010, 0x00000800, 0x20000810, 0x00080000,
102 0x00000810, 0x20080810, 0x00080800, 0x20000000,
103 0x20000800, 0x20000010, 0x20080000, 0x00080810,
104 0x00080000, 0x20000810, 0x20080010, 0x00000000,
105 0x00000800, 0x00000010, 0x20080800, 0x20080010,
106 0x20080810, 0x20080000, 0x20000000, 0x00000810,
107 0x00000010, 0x00080800, 0x00080810, 0x20000800,
108 0x00000810, 0x20000000, 0x20000800, 0x00080810,
109 0x20080800, 0x00080010, 0x00000000, 0x20000800,
110 0x20000000, 0x00000800, 0x20080010, 0x00080000,
111 0x00080010, 0x20080810, 0x00080800, 0x00000010,
112 0x20080810, 0x00080800, 0x00080000, 0x20000810,
113 0x20000010, 0x20080000, 0x00080810, 0x00000000,
114 0x00000800, 0x20000010, 0x20000810, 0x20080800,
115 0x20080000, 0x00000810, 0x00000010, 0x20080010},
118 0x00001000, 0x00000080, 0x00400080, 0x00400001,
119 0x00401081, 0x00001001, 0x00001080, 0x00000000,
120 0x00400000, 0x00400081, 0x00000081, 0x00401000,
121 0x00000001, 0x00401080, 0x00401000, 0x00000081,
122 0x00400081, 0x00001000, 0x00001001, 0x00401081,
123 0x00000000, 0x00400080, 0x00400001, 0x00001080,
124 0x00401001, 0x00001081, 0x00401080, 0x00000001,
125 0x00001081, 0x00401001, 0x00000080, 0x00400000,
126 0x00001081, 0x00401000, 0x00401001, 0x00000081,
127 0x00001000, 0x00000080, 0x00400000, 0x00401001,
128 0x00400081, 0x00001081, 0x00001080, 0x00000000,
129 0x00000080, 0x00400001, 0x00000001, 0x00400080,
130 0x00000000, 0x00400081, 0x00400080, 0x00001080,
131 0x00000081, 0x00001000, 0x00401081, 0x00400000,
132 0x00401080, 0x00000001, 0x00001001, 0x00401081,
133 0x00400001, 0x00401080, 0x00401000, 0x00001001},
136 0x08200020, 0x08208000, 0x00008020, 0x00000000,
137 0x08008000, 0x00200020, 0x08200000, 0x08208020,
138 0x00000020, 0x08000000, 0x00208000, 0x00008020,
139 0x00208020, 0x08008020, 0x08000020, 0x08200000,
140 0x00008000, 0x00208020, 0x00200020, 0x08008000,
141 0x08208020, 0x08000020, 0x00000000, 0x00208000,
142 0x08000000, 0x00200000, 0x08008020, 0x08200020,
143 0x00200000, 0x00008000, 0x08208000, 0x00000020,
144 0x00200000, 0x00008000, 0x08000020, 0x08208020,
145 0x00008020, 0x08000000, 0x00000000, 0x00208000,
146 0x08200020, 0x08008020, 0x08008000, 0x00200020,
147 0x08208000, 0x00000020, 0x00200020, 0x08008000,
148 0x08208020, 0x00200000, 0x08200000, 0x08000020,
149 0x00208000, 0x00008020, 0x08008020, 0x08200000,
150 0x00000020, 0x08208000, 0x00208020, 0x00000000,
151 0x08000000, 0x08200020, 0x00008000, 0x00208020}};
153 static const unsigned long des_skb
[8][64] =
155 { /* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
156 0x00000000, 0x00000010, 0x20000000, 0x20000010,
157 0x00010000, 0x00010010, 0x20010000, 0x20010010,
158 0x00000800, 0x00000810, 0x20000800, 0x20000810,
159 0x00010800, 0x00010810, 0x20010800, 0x20010810,
160 0x00000020, 0x00000030, 0x20000020, 0x20000030,
161 0x00010020, 0x00010030, 0x20010020, 0x20010030,
162 0x00000820, 0x00000830, 0x20000820, 0x20000830,
163 0x00010820, 0x00010830, 0x20010820, 0x20010830,
164 0x00080000, 0x00080010, 0x20080000, 0x20080010,
165 0x00090000, 0x00090010, 0x20090000, 0x20090010,
166 0x00080800, 0x00080810, 0x20080800, 0x20080810,
167 0x00090800, 0x00090810, 0x20090800, 0x20090810,
168 0x00080020, 0x00080030, 0x20080020, 0x20080030,
169 0x00090020, 0x00090030, 0x20090020, 0x20090030,
170 0x00080820, 0x00080830, 0x20080820, 0x20080830,
171 0x00090820, 0x00090830, 0x20090820, 0x20090830},
172 { /* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */
173 0x00000000, 0x02000000, 0x00002000, 0x02002000,
174 0x00200000, 0x02200000, 0x00202000, 0x02202000,
175 0x00000004, 0x02000004, 0x00002004, 0x02002004,
176 0x00200004, 0x02200004, 0x00202004, 0x02202004,
177 0x00000400, 0x02000400, 0x00002400, 0x02002400,
178 0x00200400, 0x02200400, 0x00202400, 0x02202400,
179 0x00000404, 0x02000404, 0x00002404, 0x02002404,
180 0x00200404, 0x02200404, 0x00202404, 0x02202404,
181 0x10000000, 0x12000000, 0x10002000, 0x12002000,
182 0x10200000, 0x12200000, 0x10202000, 0x12202000,
183 0x10000004, 0x12000004, 0x10002004, 0x12002004,
184 0x10200004, 0x12200004, 0x10202004, 0x12202004,
185 0x10000400, 0x12000400, 0x10002400, 0x12002400,
186 0x10200400, 0x12200400, 0x10202400, 0x12202400,
187 0x10000404, 0x12000404, 0x10002404, 0x12002404,
188 0x10200404, 0x12200404, 0x10202404, 0x12202404},
189 { /* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */
190 0x00000000, 0x00000001, 0x00040000, 0x00040001,
191 0x01000000, 0x01000001, 0x01040000, 0x01040001,
192 0x00000002, 0x00000003, 0x00040002, 0x00040003,
193 0x01000002, 0x01000003, 0x01040002, 0x01040003,
194 0x00000200, 0x00000201, 0x00040200, 0x00040201,
195 0x01000200, 0x01000201, 0x01040200, 0x01040201,
196 0x00000202, 0x00000203, 0x00040202, 0x00040203,
197 0x01000202, 0x01000203, 0x01040202, 0x01040203,
198 0x08000000, 0x08000001, 0x08040000, 0x08040001,
199 0x09000000, 0x09000001, 0x09040000, 0x09040001,
200 0x08000002, 0x08000003, 0x08040002, 0x08040003,
201 0x09000002, 0x09000003, 0x09040002, 0x09040003,
202 0x08000200, 0x08000201, 0x08040200, 0x08040201,
203 0x09000200, 0x09000201, 0x09040200, 0x09040201,
204 0x08000202, 0x08000203, 0x08040202, 0x08040203,
205 0x09000202, 0x09000203, 0x09040202, 0x09040203},
206 { /* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */
207 0x00000000, 0x00100000, 0x00000100, 0x00100100,
208 0x00000008, 0x00100008, 0x00000108, 0x00100108,
209 0x00001000, 0x00101000, 0x00001100, 0x00101100,
210 0x00001008, 0x00101008, 0x00001108, 0x00101108,
211 0x04000000, 0x04100000, 0x04000100, 0x04100100,
212 0x04000008, 0x04100008, 0x04000108, 0x04100108,
213 0x04001000, 0x04101000, 0x04001100, 0x04101100,
214 0x04001008, 0x04101008, 0x04001108, 0x04101108,
215 0x00020000, 0x00120000, 0x00020100, 0x00120100,
216 0x00020008, 0x00120008, 0x00020108, 0x00120108,
217 0x00021000, 0x00121000, 0x00021100, 0x00121100,
218 0x00021008, 0x00121008, 0x00021108, 0x00121108,
219 0x04020000, 0x04120000, 0x04020100, 0x04120100,
220 0x04020008, 0x04120008, 0x04020108, 0x04120108,
221 0x04021000, 0x04121000, 0x04021100, 0x04121100,
222 0x04021008, 0x04121008, 0x04021108, 0x04121108},
223 { /* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
224 0x00000000, 0x10000000, 0x00010000, 0x10010000,
225 0x00000004, 0x10000004, 0x00010004, 0x10010004,
226 0x20000000, 0x30000000, 0x20010000, 0x30010000,
227 0x20000004, 0x30000004, 0x20010004, 0x30010004,
228 0x00100000, 0x10100000, 0x00110000, 0x10110000,
229 0x00100004, 0x10100004, 0x00110004, 0x10110004,
230 0x20100000, 0x30100000, 0x20110000, 0x30110000,
231 0x20100004, 0x30100004, 0x20110004, 0x30110004,
232 0x00001000, 0x10001000, 0x00011000, 0x10011000,
233 0x00001004, 0x10001004, 0x00011004, 0x10011004,
234 0x20001000, 0x30001000, 0x20011000, 0x30011000,
235 0x20001004, 0x30001004, 0x20011004, 0x30011004,
236 0x00101000, 0x10101000, 0x00111000, 0x10111000,
237 0x00101004, 0x10101004, 0x00111004, 0x10111004,
238 0x20101000, 0x30101000, 0x20111000, 0x30111000,
239 0x20101004, 0x30101004, 0x20111004, 0x30111004},
240 { /* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */
241 0x00000000, 0x08000000, 0x00000008, 0x08000008,
242 0x00000400, 0x08000400, 0x00000408, 0x08000408,
243 0x00020000, 0x08020000, 0x00020008, 0x08020008,
244 0x00020400, 0x08020400, 0x00020408, 0x08020408,
245 0x00000001, 0x08000001, 0x00000009, 0x08000009,
246 0x00000401, 0x08000401, 0x00000409, 0x08000409,
247 0x00020001, 0x08020001, 0x00020009, 0x08020009,
248 0x00020401, 0x08020401, 0x00020409, 0x08020409,
249 0x02000000, 0x0A000000, 0x02000008, 0x0A000008,
250 0x02000400, 0x0A000400, 0x02000408, 0x0A000408,
251 0x02020000, 0x0A020000, 0x02020008, 0x0A020008,
252 0x02020400, 0x0A020400, 0x02020408, 0x0A020408,
253 0x02000001, 0x0A000001, 0x02000009, 0x0A000009,
254 0x02000401, 0x0A000401, 0x02000409, 0x0A000409,
255 0x02020001, 0x0A020001, 0x02020009, 0x0A020009,
256 0x02020401, 0x0A020401, 0x02020409, 0x0A020409},
257 { /* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */
258 0x00000000, 0x00000100, 0x00080000, 0x00080100,
259 0x01000000, 0x01000100, 0x01080000, 0x01080100,
260 0x00000010, 0x00000110, 0x00080010, 0x00080110,
261 0x01000010, 0x01000110, 0x01080010, 0x01080110,
262 0x00200000, 0x00200100, 0x00280000, 0x00280100,
263 0x01200000, 0x01200100, 0x01280000, 0x01280100,
264 0x00200010, 0x00200110, 0x00280010, 0x00280110,
265 0x01200010, 0x01200110, 0x01280010, 0x01280110,
266 0x00000200, 0x00000300, 0x00080200, 0x00080300,
267 0x01000200, 0x01000300, 0x01080200, 0x01080300,
268 0x00000210, 0x00000310, 0x00080210, 0x00080310,
269 0x01000210, 0x01000310, 0x01080210, 0x01080310,
270 0x00200200, 0x00200300, 0x00280200, 0x00280300,
271 0x01200200, 0x01200300, 0x01280200, 0x01280300,
272 0x00200210, 0x00200310, 0x00280210, 0x00280310,
273 0x01200210, 0x01200310, 0x01280210, 0x01280310},
274 { /* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */
275 0x00000000, 0x04000000, 0x00040000, 0x04040000,
276 0x00000002, 0x04000002, 0x00040002, 0x04040002,
277 0x00002000, 0x04002000, 0x00042000, 0x04042000,
278 0x00002002, 0x04002002, 0x00042002, 0x04042002,
279 0x00000020, 0x04000020, 0x00040020, 0x04040020,
280 0x00000022, 0x04000022, 0x00040022, 0x04040022,
281 0x00002020, 0x04002020, 0x00042020, 0x04042020,
282 0x00002022, 0x04002022, 0x00042022, 0x04042022,
283 0x00000800, 0x04000800, 0x00040800, 0x04040800,
284 0x00000802, 0x04000802, 0x00040802, 0x04040802,
285 0x00002800, 0x04002800, 0x00042800, 0x04042800,
286 0x00002802, 0x04002802, 0x00042802, 0x04042802,
287 0x00000820, 0x04000820, 0x00040820, 0x04040820,
288 0x00000822, 0x04000822, 0x00040822, 0x04040822,
289 0x00002820, 0x04002820, 0x00042820, 0x04042820,
290 0x00002822, 0x04002822, 0x00042822, 0x04042822},
293 #define c2l(c,l) (l =((unsigned long)(*((c)++))) , \
294 l|=((unsigned long)(*((c)++)))<< 8, \
295 l|=((unsigned long)(*((c)++)))<<16, \
296 l|=((unsigned long)(*((c)++)))<<24)
298 #define l2c(l,c) (*((c)++)=(unsigned char)(((l) )&0xff), \
299 *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
300 *((c)++)=(unsigned char)(((l)>>16)&0xff), \
301 *((c)++)=(unsigned char)(((l)>>24)&0xff))
305 * The problem is more of a geometric problem that random bit fiddling.
306 * 0 1 2 3 4 5 6 7 62 54 46 38 30 22 14 6
307 * 8 9 10 11 12 13 14 15 60 52 44 36 28 20 12 4
308 * 16 17 18 19 20 21 22 23 58 50 42 34 26 18 10 2
309 * 24 25 26 27 28 29 30 31 to 56 48 40 32 24 16 8 0
311 * 32 33 34 35 36 37 38 39 63 55 47 39 31 23 15 7
312 * 40 41 42 43 44 45 46 47 61 53 45 37 29 21 13 5
313 * 48 49 50 51 52 53 54 55 59 51 43 35 27 19 11 3
314 * 56 57 58 59 60 61 62 63 57 49 41 33 25 17 9 1
316 * The output has been subject to swaps of the form
317 * 0 1 -> 3 1 but the odd and even bits have been put into
319 * different words. The main trick is to remember that
320 * t=((l>>size)^r)&(mask);
323 * can be used to swap and move bits between words.
325 * So l = 0 1 2 3 r = 16 17 18 19
326 * 4 5 6 7 20 21 22 23
327 * 8 9 10 11 24 25 26 27
328 * 12 13 14 15 28 29 30 31
329 * becomes (for size == 2 and mask == 0x3333)
330 * t = 2^16 3^17 -- -- l = 0 1 16 17 r = 2 3 18 19
331 * 6^20 7^21 -- -- 4 5 20 21 6 7 22 23
332 * 10^24 11^25 -- -- 8 9 24 25 10 11 24 25
333 * 14^28 15^29 -- -- 12 13 28 29 14 15 28 29
335 * Thanks for hints from Richard Outerbridge - he told me IP&FP
336 * could be done in 15 xor, 10 shifts and 5 ands.
337 * When I finally started to think of the problem in 2D
338 * I first got ~42 operations without xors. When I remembered
339 * how to use xors :-) I got it to its final state.
342 #define PERM_OP(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\
346 #define HPERM_OP(a,t,n,m) ((t)=((((a)<<(16-(n)))^(a))&(m)),\
347 (a)=(a)^(t)^(t>>(16-(n))))
350 /* The changes to this macro may help or hinder, depending on the
351 * compiler and the achitecture. gcc2 always seems to do well :-).
352 * Inspired by Dana How <how@isl.stanford.edu>
353 * DO NOT use the alternative version on machines with 8 byte longs.
356 #define D_ENCRYPT(L,R,S) \
359 t=((t>>2)+(t<<30)); \
361 *(const unsigned long *)(des_SP+0x0100+((t )&0xfc))+ \
362 *(const unsigned long *)(des_SP+0x0300+((t>> 8)&0xfc))+ \
363 *(const unsigned long *)(des_SP+0x0500+((t>>16)&0xfc))+ \
364 *(const unsigned long *)(des_SP+0x0700+((t>>24)&0xfc))+ \
365 *(const unsigned long *)(des_SP+ ((u )&0xfc))+ \
366 *(const unsigned long *)(des_SP+0x0200+((u>> 8)&0xfc))+ \
367 *(const unsigned long *)(des_SP+0x0400+((u>>16)&0xfc))+ \
368 *(const unsigned long *)(des_SP+0x0600+((u>>24)&0xfc));
369 #else /* original version */
370 #define D_ENCRYPT(L,R,S) \
373 t=((t>>4)+(t<<28)); \
374 L^= des_SPtrans[1][(t )&0x3f]| \
375 des_SPtrans[3][(t>> 8)&0x3f]| \
376 des_SPtrans[5][(t>>16)&0x3f]| \
377 des_SPtrans[7][(t>>24)&0x3f]| \
378 des_SPtrans[0][(u )&0x3f]| \
379 des_SPtrans[2][(u>> 8)&0x3f]| \
380 des_SPtrans[4][(u>>16)&0x3f]| \
381 des_SPtrans[6][(u>>24)&0x3f];
384 #define ITERATIONS 16
386 static const char shifts2
[16] =
387 {0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0};
389 static void des_set_key (char *, unsigned long *) internal_function
;
390 static void des_encrypt (unsigned long *, unsigned long *, int)
392 int _des_crypt (char *, unsigned, struct desparams
*);
396 des_set_key (char *key
, unsigned long *schedule
)
398 register unsigned long c
, d
, t
, s
;
399 register unsigned char *in
;
400 register unsigned long *k
;
403 k
= (unsigned long *) schedule
;
404 in
= (unsigned char *) key
;
409 /* I now do it in 47 simple operations :-)
410 * Thanks to John Fletcher (john_fletcher@lccmail.ocf.llnl.gov)
411 * for the inspiration. :-) */
412 PERM_OP (d
, c
, t
, 4, 0x0f0f0f0f);
413 HPERM_OP (c
, t
, -2, 0xcccc0000);
414 HPERM_OP (d
, t
, -2, 0xcccc0000);
415 PERM_OP (d
, c
, t
, 1, 0x55555555);
416 PERM_OP (c
, d
, t
, 8, 0x00ff00ff);
417 PERM_OP (d
, c
, t
, 1, 0x55555555);
418 d
= (((d
& 0x000000ff) << 16) | (d
& 0x0000ff00) |
419 ((d
& 0x00ff0000) >> 16) | ((c
& 0xf0000000) >> 4));
422 for (i
= 0; i
< ITERATIONS
; i
++)
426 c
= ((c
>> 2) | (c
<< 26));
427 d
= ((d
>> 2) | (d
<< 26));
431 c
= ((c
>> 1) | (c
<< 27));
432 d
= ((d
>> 1) | (d
<< 27));
436 /* could be a few less shifts but I am to lazy at this
437 * point in time to investigate */
438 s
= des_skb
[0][(c
) & 0x3f] |
439 des_skb
[1][((c
>> 6) & 0x03) | ((c
>> 7) & 0x3c)] |
440 des_skb
[2][((c
>> 13) & 0x0f) | ((c
>> 14) & 0x30)] |
441 des_skb
[3][((c
>> 20) & 0x01) | ((c
>> 21) & 0x06) | ((c
>> 22) & 0x38)];
442 t
= des_skb
[4][(d
) & 0x3f] |
443 des_skb
[5][((d
>> 7) & 0x03) | ((d
>> 8) & 0x3c)] |
444 des_skb
[6][(d
>> 15) & 0x3f] |
445 des_skb
[7][((d
>> 21) & 0x0f) | ((d
>> 22) & 0x30)];
447 /* table contained 0213 4657 */
448 *(k
++) = ((t
<< 16) | (s
& 0x0000ffff)) & 0xffffffff;
449 s
= ((s
>> 16) | (t
& 0xffff0000));
451 s
= (s
<< 4) | (s
>> 28);
452 *(k
++) = s
& 0xffffffff;
459 des_encrypt (unsigned long *buf
, unsigned long *schedule
, int encrypt
)
461 register unsigned long l
, r
, t
, u
;
463 register const unsigned char *des_SP
= (const unsigned char *) des_SPtrans
;
466 register unsigned long *s
;
472 PERM_OP (r
, l
, t
, 4, 0x0f0f0f0f);
473 PERM_OP (l
, r
, t
, 16, 0x0000ffff);
474 PERM_OP (r
, l
, t
, 2, 0x33333333);
475 PERM_OP (l
, r
, t
, 8, 0x00ff00ff);
476 PERM_OP (r
, l
, t
, 1, 0x55555555);
477 /* r and l are reversed - remember that :-) - fix
478 * it in the next step */
480 /* Things have been modified so that the initial rotate is
481 * done outside the loop. This required the
482 * des_SPtrans values in sp.h to be rotated 1 bit to the right.
483 * One perl script later and things have a 5% speed up on a sparc2.
484 * Thanks to Richard Outerbridge <71755.204@CompuServe.COM>
485 * for pointing this out. */
486 t
= (r
<< 1) | (r
>> 31);
487 r
= (l
<< 1) | (l
>> 31);
490 /* clear the top bits on machines with 8byte longs */
494 s
= (unsigned long *) schedule
;
495 /* I don't know if it is worth the effort of loop unrolling the
499 for (i
= 0; i
< 32; i
+= 4)
501 D_ENCRYPT (l
, r
, i
+ 0); /* 1 */
502 D_ENCRYPT (r
, l
, i
+ 2); /* 2 */
507 for (i
= 30; i
> 0; i
-= 4)
509 D_ENCRYPT (l
, r
, i
- 0); /* 16 */
510 D_ENCRYPT (r
, l
, i
- 2); /* 15 */
513 l
= (l
>> 1) | (l
<< 31);
514 r
= (r
>> 1) | (r
<< 31);
515 /* clear the top bits on machines with 8byte longs */
520 * we will not do the swap so just remember they are
521 * reversed for the rest of the subroutine
522 * luckily FP fixes this problem :-) */
524 PERM_OP (r
, l
, t
, 1, 0x55555555);
525 PERM_OP (l
, r
, t
, 8, 0x00ff00ff);
526 PERM_OP (r
, l
, t
, 2, 0x33333333);
527 PERM_OP (l
, r
, t
, 16, 0x0000ffff);
528 PERM_OP (r
, l
, t
, 4, 0x0f0f0f0f);
538 _des_crypt (char *buf
, unsigned len
, struct desparams
*desp
)
540 unsigned long schedule
[32];
541 register unsigned long tin0
, tin1
;
542 register unsigned long tout0
, tout1
, xor0
, xor1
;
543 register unsigned char *in
, *out
;
544 unsigned long tbuf
[2];
545 unsigned char *iv
, *oiv
;
548 cbc_mode
= (desp
->des_mode
== CBC
) ? 1 : 0;
550 in
= (unsigned char *) buf
;
551 out
= (unsigned char *) buf
;
552 oiv
= iv
= (unsigned char *) desp
->des_ivec
;
554 des_set_key (desp
->des_key
, schedule
);
556 tin0
= tin1
= 0; /* For GCC */
557 if (desp
->des_dir
== ENCRYPT
)
561 for (; len
> 0; len
-= 8)
572 des_encrypt (tbuf
, schedule
, 1);
585 for (; len
> 0; len
-= 8)
591 des_encrypt (tbuf
, schedule
, 0);
594 tout0
= tbuf
[0] ^ xor0
;
595 tout1
= tbuf
[1] ^ xor1
;
610 tin0
= tin1
= tout0
= tout1
= xor0
= xor1
= 0;
611 tbuf
[0] = tbuf
[1] = 0;
612 __bzero (schedule
, sizeof (schedule
));
This page took 0.06931 seconds and 5 git commands to generate.