]>
Commit | Line | Data |
---|---|---|
4f22f405 RS |
1 | /* |
2 | * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved. | |
d02b48c6 | 3 | * |
4f22f405 RS |
4 | * Licensed under the OpenSSL license (the "License"). You may not use |
5 | * this file except in compliance with the License. You can obtain a copy | |
6 | * in the file LICENSE in the source distribution or at | |
7 | * https://www.openssl.org/source/license.html | |
d02b48c6 RE |
8 | */ |
9 | ||
d02b48c6 | 10 | #ifndef HEADER_DES_LOCL_H |
0f113f3e | 11 | # define HEADER_DES_LOCL_H |
d02b48c6 | 12 | |
0f113f3e | 13 | # include <openssl/e_os2.h> |
a5bc1e85 | 14 | |
0f113f3e MC |
15 | # include <stdio.h> |
16 | # include <stdlib.h> | |
bfcdd4d0 | 17 | # include <string.h> |
0f113f3e | 18 | |
0f113f3e | 19 | # include <openssl/des.h> |
d02b48c6 | 20 | |
0f113f3e MC |
21 | # ifdef OPENSSL_BUILD_SHLIBCRYPTO |
22 | # undef OPENSSL_EXTERN | |
23 | # define OPENSSL_EXTERN OPENSSL_EXPORT | |
24 | # endif | |
26da3e65 | 25 | |
0f113f3e MC |
26 | # define ITERATIONS 16 |
27 | # define HALF_ITERATIONS 8 | |
d02b48c6 RE |
28 | |
29 | /* used in des_read and des_write */ | |
0f113f3e MC |
30 | # define MAXWRITE (1024*16) |
31 | # define BSIZE (MAXWRITE+4) | |
d02b48c6 | 32 | |
0f113f3e MC |
33 | # define c2l(c,l) (l =((DES_LONG)(*((c)++))) , \ |
34 | l|=((DES_LONG)(*((c)++)))<< 8L, \ | |
35 | l|=((DES_LONG)(*((c)++)))<<16L, \ | |
36 | l|=((DES_LONG)(*((c)++)))<<24L) | |
d02b48c6 RE |
37 | |
38 | /* NOTE - c is not incremented as per c2l */ | |
0f113f3e MC |
39 | # define c2ln(c,l1,l2,n) { \ |
40 | c+=n; \ | |
41 | l1=l2=0; \ | |
42 | switch (n) { \ | |
43 | case 8: l2 =((DES_LONG)(*(--(c))))<<24L; \ | |
44 | case 7: l2|=((DES_LONG)(*(--(c))))<<16L; \ | |
45 | case 6: l2|=((DES_LONG)(*(--(c))))<< 8L; \ | |
46 | case 5: l2|=((DES_LONG)(*(--(c)))); \ | |
47 | case 4: l1 =((DES_LONG)(*(--(c))))<<24L; \ | |
48 | case 3: l1|=((DES_LONG)(*(--(c))))<<16L; \ | |
49 | case 2: l1|=((DES_LONG)(*(--(c))))<< 8L; \ | |
50 | case 1: l1|=((DES_LONG)(*(--(c)))); \ | |
51 | } \ | |
52 | } | |
53 | ||
54 | # define l2c(l,c) (*((c)++)=(unsigned char)(((l) )&0xff), \ | |
55 | *((c)++)=(unsigned char)(((l)>> 8L)&0xff), \ | |
56 | *((c)++)=(unsigned char)(((l)>>16L)&0xff), \ | |
57 | *((c)++)=(unsigned char)(((l)>>24L)&0xff)) | |
58 | ||
59 | /* | |
60 | * replacements for htonl and ntohl since I have no idea what to do when | |
61 | * faced with machines with 8 byte longs. | |
62 | */ | |
63 | # define HDRSIZE 4 | |
d02b48c6 | 64 | |
0f113f3e MC |
65 | # define n2l(c,l) (l =((DES_LONG)(*((c)++)))<<24L, \ |
66 | l|=((DES_LONG)(*((c)++)))<<16L, \ | |
67 | l|=((DES_LONG)(*((c)++)))<< 8L, \ | |
68 | l|=((DES_LONG)(*((c)++)))) | |
d02b48c6 | 69 | |
0f113f3e MC |
70 | # define l2n(l,c) (*((c)++)=(unsigned char)(((l)>>24L)&0xff), \ |
71 | *((c)++)=(unsigned char)(((l)>>16L)&0xff), \ | |
72 | *((c)++)=(unsigned char)(((l)>> 8L)&0xff), \ | |
73 | *((c)++)=(unsigned char)(((l) )&0xff)) | |
d02b48c6 | 74 | |
0f113f3e MC |
75 | /* NOTE - c is not incremented as per l2c */ |
76 | # define l2cn(l1,l2,c,n) { \ | |
77 | c+=n; \ | |
78 | switch (n) { \ | |
79 | case 8: *(--(c))=(unsigned char)(((l2)>>24L)&0xff); \ | |
80 | case 7: *(--(c))=(unsigned char)(((l2)>>16L)&0xff); \ | |
81 | case 6: *(--(c))=(unsigned char)(((l2)>> 8L)&0xff); \ | |
82 | case 5: *(--(c))=(unsigned char)(((l2) )&0xff); \ | |
83 | case 4: *(--(c))=(unsigned char)(((l1)>>24L)&0xff); \ | |
84 | case 3: *(--(c))=(unsigned char)(((l1)>>16L)&0xff); \ | |
85 | case 2: *(--(c))=(unsigned char)(((l1)>> 8L)&0xff); \ | |
86 | case 1: *(--(c))=(unsigned char)(((l1) )&0xff); \ | |
87 | } \ | |
88 | } | |
89 | ||
90 | # if (defined(OPENSSL_SYS_WIN32) && defined(_MSC_VER)) | |
91 | # define ROTATE(a,n) (_lrotr(a,n)) | |
92 | # elif defined(__ICC) | |
93 | # define ROTATE(a,n) (_rotr(a,n)) | |
94 | # elif defined(__GNUC__) && __GNUC__>=2 && !defined(__STRICT_ANSI__) && !defined(OPENSSL_NO_ASM) && !defined(OPENSSL_NO_INLINE_ASM) && !defined(PEDANTIC) | |
95 | # if defined(__i386) || defined(__i386__) || defined(__x86_64) || defined(__x86_64__) | |
96 | # define ROTATE(a,n) ({ register unsigned int ret; \ | |
97 | asm ("rorl %1,%0" \ | |
98 | : "=r"(ret) \ | |
99 | : "I"(n),"0"(a) \ | |
100 | : "cc"); \ | |
101 | ret; \ | |
102 | }) | |
103 | # endif | |
104 | # endif | |
105 | # ifndef ROTATE | |
106 | # define ROTATE(a,n) (((a)>>(n))+((a)<<(32-(n)))) | |
107 | # endif | |
d02b48c6 | 108 | |
0f113f3e MC |
109 | /* |
110 | * Don't worry about the LOAD_DATA() stuff, that is used by fcrypt() to add | |
111 | * it's little bit to the front | |
112 | */ | |
d02b48c6 | 113 | |
0f113f3e MC |
114 | # ifdef DES_FCRYPT |
115 | ||
116 | # define LOAD_DATA_tmp(R,S,u,t,E0,E1) \ | |
117 | { DES_LONG tmp; LOAD_DATA(R,S,u,t,E0,E1,tmp); } | |
118 | ||
119 | # define LOAD_DATA(R,S,u,t,E0,E1,tmp) \ | |
120 | t=R^(R>>16L); \ | |
121 | u=t&E0; t&=E1; \ | |
122 | tmp=(u<<16); u^=R^s[S ]; u^=tmp; \ | |
123 | tmp=(t<<16); t^=R^s[S+1]; t^=tmp | |
124 | # else | |
125 | # define LOAD_DATA_tmp(a,b,c,d,e,f) LOAD_DATA(a,b,c,d,e,f,g) | |
126 | # define LOAD_DATA(R,S,u,t,E0,E1,tmp) \ | |
127 | u=R^s[S ]; \ | |
128 | t=R^s[S+1] | |
129 | # endif | |
d02b48c6 | 130 | |
0f113f3e MC |
131 | /* |
132 | * It recently occurred to me that 0^0^0^0^0^0^0 == 0, so there is no reason | |
133 | * to not xor all the sub items together. This potentially saves a register | |
134 | * since things can be xored directly into L | |
135 | */ | |
d02b48c6 | 136 | |
3e9e810f | 137 | # define D_ENCRYPT(LL,R,S) { \ |
0f113f3e MC |
138 | LOAD_DATA_tmp(R,S,u,t,E0,E1); \ |
139 | t=ROTATE(t,4); \ | |
140 | LL^= \ | |
3e9e810f RS |
141 | DES_SPtrans[0][(u>> 2L)&0x3f]^ \ |
142 | DES_SPtrans[2][(u>>10L)&0x3f]^ \ | |
143 | DES_SPtrans[4][(u>>18L)&0x3f]^ \ | |
144 | DES_SPtrans[6][(u>>26L)&0x3f]^ \ | |
145 | DES_SPtrans[1][(t>> 2L)&0x3f]^ \ | |
146 | DES_SPtrans[3][(t>>10L)&0x3f]^ \ | |
147 | DES_SPtrans[5][(t>>18L)&0x3f]^ \ | |
148 | DES_SPtrans[7][(t>>26L)&0x3f]; } | |
d02b48c6 | 149 | |
0f113f3e MC |
150 | /*- |
151 | * IP and FP | |
152 | * The problem is more of a geometric problem that random bit fiddling. | |
153 | 0 1 2 3 4 5 6 7 62 54 46 38 30 22 14 6 | |
154 | 8 9 10 11 12 13 14 15 60 52 44 36 28 20 12 4 | |
155 | 16 17 18 19 20 21 22 23 58 50 42 34 26 18 10 2 | |
156 | 24 25 26 27 28 29 30 31 to 56 48 40 32 24 16 8 0 | |
157 | ||
158 | 32 33 34 35 36 37 38 39 63 55 47 39 31 23 15 7 | |
159 | 40 41 42 43 44 45 46 47 61 53 45 37 29 21 13 5 | |
160 | 48 49 50 51 52 53 54 55 59 51 43 35 27 19 11 3 | |
161 | 56 57 58 59 60 61 62 63 57 49 41 33 25 17 9 1 | |
162 | ||
163 | The output has been subject to swaps of the form | |
164 | 0 1 -> 3 1 but the odd and even bits have been put into | |
165 | 2 3 2 0 | |
166 | different words. The main trick is to remember that | |
167 | t=((l>>size)^r)&(mask); | |
168 | r^=t; | |
169 | l^=(t<<size); | |
170 | can be used to swap and move bits between words. | |
171 | ||
172 | So l = 0 1 2 3 r = 16 17 18 19 | |
173 | 4 5 6 7 20 21 22 23 | |
174 | 8 9 10 11 24 25 26 27 | |
175 | 12 13 14 15 28 29 30 31 | |
176 | becomes (for size == 2 and mask == 0x3333) | |
177 | t = 2^16 3^17 -- -- l = 0 1 16 17 r = 2 3 18 19 | |
178 | 6^20 7^21 -- -- 4 5 20 21 6 7 22 23 | |
179 | 10^24 11^25 -- -- 8 9 24 25 10 11 24 25 | |
180 | 14^28 15^29 -- -- 12 13 28 29 14 15 28 29 | |
181 | ||
182 | Thanks for hints from Richard Outerbridge - he told me IP&FP | |
183 | could be done in 15 xor, 10 shifts and 5 ands. | |
184 | When I finally started to think of the problem in 2D | |
185 | I first got ~42 operations without xors. When I remembered | |
186 | how to use xors :-) I got it to its final state. | |
187 | */ | |
188 | # define PERM_OP(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\ | |
189 | (b)^=(t),\ | |
190 | (a)^=((t)<<(n))) | |
191 | ||
192 | # define IP(l,r) \ | |
193 | { \ | |
194 | register DES_LONG tt; \ | |
195 | PERM_OP(r,l,tt, 4,0x0f0f0f0fL); \ | |
196 | PERM_OP(l,r,tt,16,0x0000ffffL); \ | |
197 | PERM_OP(r,l,tt, 2,0x33333333L); \ | |
198 | PERM_OP(l,r,tt, 8,0x00ff00ffL); \ | |
199 | PERM_OP(r,l,tt, 1,0x55555555L); \ | |
200 | } | |
201 | ||
202 | # define FP(l,r) \ | |
203 | { \ | |
204 | register DES_LONG tt; \ | |
205 | PERM_OP(l,r,tt, 1,0x55555555L); \ | |
206 | PERM_OP(r,l,tt, 8,0x00ff00ffL); \ | |
207 | PERM_OP(l,r,tt, 2,0x33333333L); \ | |
208 | PERM_OP(r,l,tt,16,0x0000ffffL); \ | |
209 | PERM_OP(l,r,tt, 4,0x0f0f0f0fL); \ | |
210 | } | |
d02b48c6 | 211 | |
e62991a0 | 212 | extern const DES_LONG DES_SPtrans[8][64]; |
d02b48c6 | 213 | |
0f113f3e MC |
214 | void fcrypt_body(DES_LONG *out, DES_key_schedule *ks, |
215 | DES_LONG Eswap0, DES_LONG Eswap1); | |
3d6312e8 | 216 | |
d02b48c6 | 217 | #endif |