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