?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- fix Building without Nagra not possible at Nagra_Merlin https://trac.streamboard...
[oscam.git] / cscrypt / mdc2.c
blobdeb5f8bee42b85342d514c8c480e45c63711de77
1 #include "../globals.h"
2 #include "mdc2.h"
3
4
5 #undef c2l
6 #define c2l(c,l) (l =((DES_LONG)(*((c)++))) , \
7 l|=((DES_LONG)(*((c)++)))<< 8L, \
8 l|=((DES_LONG)(*((c)++)))<<16L, \
9 l|=((DES_LONG)(*((c)++)))<<24L)
10
11 #undef l2c
12 #define l2c(l,c) (*((c)++)=(unsigned char)(((l) )&0xff), \
13 *((c)++)=(unsigned char)(((l)>> 8L)&0xff), \
14 *((c)++)=(unsigned char)(((l)>>16L)&0xff), \
15 *((c)++)=(unsigned char)(((l)>>24L)&0xff))
16
17 # define FP(l,r) \
18 { \
19 register DES_LONG tt; \
20 PERM_OP(l,r,tt, 1,0x55555555L); \
21 PERM_OP(r,l,tt, 8,0x00ff00ffL); \
22 PERM_OP(l,r,tt, 2,0x33333333L); \
23 PERM_OP(r,l,tt,16,0x0000ffffL); \
24 PERM_OP(l,r,tt, 4,0x0f0f0f0fL); \
25 }
26
27 #if !defined(WITH_LIBCRYPTO)
28 const DES_LONG DES_SPtrans[8][64] =
29 {
30 {
31 /* nibble 0 */
32 0x02080800L, 0x00080000L, 0x02000002L, 0x02080802L,
33 0x02000000L, 0x00080802L, 0x00080002L, 0x02000002L,
34 0x00080802L, 0x02080800L, 0x02080000L, 0x00000802L,
35 0x02000802L, 0x02000000L, 0x00000000L, 0x00080002L,
36 0x00080000L, 0x00000002L, 0x02000800L, 0x00080800L,
37 0x02080802L, 0x02080000L, 0x00000802L, 0x02000800L,
38 0x00000002L, 0x00000800L, 0x00080800L, 0x02080002L,
39 0x00000800L, 0x02000802L, 0x02080002L, 0x00000000L,
40 0x00000000L, 0x02080802L, 0x02000800L, 0x00080002L,
41 0x02080800L, 0x00080000L, 0x00000802L, 0x02000800L,
42 0x02080002L, 0x00000800L, 0x00080800L, 0x02000002L,
43 0x00080802L, 0x00000002L, 0x02000002L, 0x02080000L,
44 0x02080802L, 0x00080800L, 0x02080000L, 0x02000802L,
45 0x02000000L, 0x00000802L, 0x00080002L, 0x00000000L,
46 0x00080000L, 0x02000000L, 0x02000802L, 0x02080800L,
47 0x00000002L, 0x02080002L, 0x00000800L, 0x00080802L,
48 },
49 {
50 /* nibble 1 */
51 0x40108010L, 0x00000000L, 0x00108000L, 0x40100000L,
52 0x40000010L, 0x00008010L, 0x40008000L, 0x00108000L,
53 0x00008000L, 0x40100010L, 0x00000010L, 0x40008000L,
54 0x00100010L, 0x40108000L, 0x40100000L, 0x00000010L,
55 0x00100000L, 0x40008010L, 0x40100010L, 0x00008000L,
56 0x00108010L, 0x40000000L, 0x00000000L, 0x00100010L,
57 0x40008010L, 0x00108010L, 0x40108000L, 0x40000010L,
58 0x40000000L, 0x00100000L, 0x00008010L, 0x40108010L,
59 0x00100010L, 0x40108000L, 0x40008000L, 0x00108010L,
60 0x40108010L, 0x00100010L, 0x40000010L, 0x00000000L,
61 0x40000000L, 0x00008010L, 0x00100000L, 0x40100010L,
62 0x00008000L, 0x40000000L, 0x00108010L, 0x40008010L,
63 0x40108000L, 0x00008000L, 0x00000000L, 0x40000010L,
64 0x00000010L, 0x40108010L, 0x00108000L, 0x40100000L,
65 0x40100010L, 0x00100000L, 0x00008010L, 0x40008000L,
66 0x40008010L, 0x00000010L, 0x40100000L, 0x00108000L,
67 },
68 {
69 /* nibble 2 */
70 0x04000001L, 0x04040100L, 0x00000100L, 0x04000101L,
71 0x00040001L, 0x04000000L, 0x04000101L, 0x00040100L,
72 0x04000100L, 0x00040000L, 0x04040000L, 0x00000001L,
73 0x04040101L, 0x00000101L, 0x00000001L, 0x04040001L,
74 0x00000000L, 0x00040001L, 0x04040100L, 0x00000100L,
75 0x00000101L, 0x04040101L, 0x00040000L, 0x04000001L,
76 0x04040001L, 0x04000100L, 0x00040101L, 0x04040000L,
77 0x00040100L, 0x00000000L, 0x04000000L, 0x00040101L,
78 0x04040100L, 0x00000100L, 0x00000001L, 0x00040000L,
79 0x00000101L, 0x00040001L, 0x04040000L, 0x04000101L,
80 0x00000000L, 0x04040100L, 0x00040100L, 0x04040001L,
81 0x00040001L, 0x04000000L, 0x04040101L, 0x00000001L,
82 0x00040101L, 0x04000001L, 0x04000000L, 0x04040101L,
83 0x00040000L, 0x04000100L, 0x04000101L, 0x00040100L,
84 0x04000100L, 0x00000000L, 0x04040001L, 0x00000101L,
85 0x04000001L, 0x00040101L, 0x00000100L, 0x04040000L,
86 },
87 {
88 /* nibble 3 */
89 0x00401008L, 0x10001000L, 0x00000008L, 0x10401008L,
90 0x00000000L, 0x10400000L, 0x10001008L, 0x00400008L,
91 0x10401000L, 0x10000008L, 0x10000000L, 0x00001008L,
92 0x10000008L, 0x00401008L, 0x00400000L, 0x10000000L,
93 0x10400008L, 0x00401000L, 0x00001000L, 0x00000008L,
94 0x00401000L, 0x10001008L, 0x10400000L, 0x00001000L,
95 0x00001008L, 0x00000000L, 0x00400008L, 0x10401000L,
96 0x10001000L, 0x10400008L, 0x10401008L, 0x00400000L,
97 0x10400008L, 0x00001008L, 0x00400000L, 0x10000008L,
98 0x00401000L, 0x10001000L, 0x00000008L, 0x10400000L,
99 0x10001008L, 0x00000000L, 0x00001000L, 0x00400008L,
100 0x00000000L, 0x10400008L, 0x10401000L, 0x00001000L,
101 0x10000000L, 0x10401008L, 0x00401008L, 0x00400000L,
102 0x10401008L, 0x00000008L, 0x10001000L, 0x00401008L,
103 0x00400008L, 0x00401000L, 0x10400000L, 0x10001008L,
104 0x00001008L, 0x10000000L, 0x10000008L, 0x10401000L,
105 },
106 {
107 /* nibble 4 */
108 0x08000000L, 0x00010000L, 0x00000400L, 0x08010420L,
109 0x08010020L, 0x08000400L, 0x00010420L, 0x08010000L,
110 0x00010000L, 0x00000020L, 0x08000020L, 0x00010400L,
111 0x08000420L, 0x08010020L, 0x08010400L, 0x00000000L,
112 0x00010400L, 0x08000000L, 0x00010020L, 0x00000420L,
113 0x08000400L, 0x00010420L, 0x00000000L, 0x08000020L,
114 0x00000020L, 0x08000420L, 0x08010420L, 0x00010020L,
115 0x08010000L, 0x00000400L, 0x00000420L, 0x08010400L,
116 0x08010400L, 0x08000420L, 0x00010020L, 0x08010000L,
117 0x00010000L, 0x00000020L, 0x08000020L, 0x08000400L,
118 0x08000000L, 0x00010400L, 0x08010420L, 0x00000000L,
119 0x00010420L, 0x08000000L, 0x00000400L, 0x00010020L,
120 0x08000420L, 0x00000400L, 0x00000000L, 0x08010420L,
121 0x08010020L, 0x08010400L, 0x00000420L, 0x00010000L,
122 0x00010400L, 0x08010020L, 0x08000400L, 0x00000420L,
123 0x00000020L, 0x00010420L, 0x08010000L, 0x08000020L,
124 },
125 {
126 /* nibble 5 */
127 0x80000040L, 0x00200040L, 0x00000000L, 0x80202000L,
128 0x00200040L, 0x00002000L, 0x80002040L, 0x00200000L,
129 0x00002040L, 0x80202040L, 0x00202000L, 0x80000000L,
130 0x80002000L, 0x80000040L, 0x80200000L, 0x00202040L,
131 0x00200000L, 0x80002040L, 0x80200040L, 0x00000000L,
132 0x00002000L, 0x00000040L, 0x80202000L, 0x80200040L,
133 0x80202040L, 0x80200000L, 0x80000000L, 0x00002040L,
134 0x00000040L, 0x00202000L, 0x00202040L, 0x80002000L,
135 0x00002040L, 0x80000000L, 0x80002000L, 0x00202040L,
136 0x80202000L, 0x00200040L, 0x00000000L, 0x80002000L,
137 0x80000000L, 0x00002000L, 0x80200040L, 0x00200000L,
138 0x00200040L, 0x80202040L, 0x00202000L, 0x00000040L,
139 0x80202040L, 0x00202000L, 0x00200000L, 0x80002040L,
140 0x80000040L, 0x80200000L, 0x00202040L, 0x00000000L,
141 0x00002000L, 0x80000040L, 0x80002040L, 0x80202000L,
142 0x80200000L, 0x00002040L, 0x00000040L, 0x80200040L,
143 },
144 {
145 /* nibble 6 */
146 0x00004000L, 0x00000200L, 0x01000200L, 0x01000004L,
147 0x01004204L, 0x00004004L, 0x00004200L, 0x00000000L,
148 0x01000000L, 0x01000204L, 0x00000204L, 0x01004000L,
149 0x00000004L, 0x01004200L, 0x01004000L, 0x00000204L,
150 0x01000204L, 0x00004000L, 0x00004004L, 0x01004204L,
151 0x00000000L, 0x01000200L, 0x01000004L, 0x00004200L,
152 0x01004004L, 0x00004204L, 0x01004200L, 0x00000004L,
153 0x00004204L, 0x01004004L, 0x00000200L, 0x01000000L,
154 0x00004204L, 0x01004000L, 0x01004004L, 0x00000204L,
155 0x00004000L, 0x00000200L, 0x01000000L, 0x01004004L,
156 0x01000204L, 0x00004204L, 0x00004200L, 0x00000000L,
157 0x00000200L, 0x01000004L, 0x00000004L, 0x01000200L,
158 0x00000000L, 0x01000204L, 0x01000200L, 0x00004200L,
159 0x00000204L, 0x00004000L, 0x01004204L, 0x01000000L,
160 0x01004200L, 0x00000004L, 0x00004004L, 0x01004204L,
161 0x01000004L, 0x01004200L, 0x01004000L, 0x00004004L,
162 },
163 {
164 /* nibble 7 */
165 0x20800080L, 0x20820000L, 0x00020080L, 0x00000000L,
166 0x20020000L, 0x00800080L, 0x20800000L, 0x20820080L,
167 0x00000080L, 0x20000000L, 0x00820000L, 0x00020080L,
168 0x00820080L, 0x20020080L, 0x20000080L, 0x20800000L,
169 0x00020000L, 0x00820080L, 0x00800080L, 0x20020000L,
170 0x20820080L, 0x20000080L, 0x00000000L, 0x00820000L,
171 0x20000000L, 0x00800000L, 0x20020080L, 0x20800080L,
172 0x00800000L, 0x00020000L, 0x20820000L, 0x00000080L,
173 0x00800000L, 0x00020000L, 0x20000080L, 0x20820080L,
174 0x00020080L, 0x20000000L, 0x00000000L, 0x00820000L,
175 0x20800080L, 0x20020080L, 0x20020000L, 0x00800080L,
176 0x20820000L, 0x00000080L, 0x00800080L, 0x20020000L,
177 0x20820080L, 0x00800000L, 0x20800000L, 0x20000080L,
178 0x00820000L, 0x00020080L, 0x20020080L, 0x20800000L,
179 0x00000080L, 0x20820000L, 0x00820080L, 0x00000000L,
180 0x20000000L, 0x20800080L, 0x00020000L, 0x00820080L,
181 }
182 };
183 #endif
184
185
186 #define LOAD_DATA_tmp(a,b,c,d,e,f) LOAD_DATA(a,b,c,d,e,f,g)
187 #define LOAD_DATA(R,S,u,t,E0,E1,tmp) \
188 u=R^s[S ]; \
189 t=R^s[S+1]
190
191 #define D_ENCRYPT(LL,R,S) { \
192 LOAD_DATA_tmp(R,S,u,t,E0,E1); \
193 t=ROTATE(t,4); \
194 LL^= \
195 DES_SPtrans[0][(u>> 2L)&0x3f]^ \
196 DES_SPtrans[2][(u>>10L)&0x3f]^ \
197 DES_SPtrans[4][(u>>18L)&0x3f]^ \
198 DES_SPtrans[6][(u>>26L)&0x3f]^ \
199 DES_SPtrans[1][(t>> 2L)&0x3f]^ \
200 DES_SPtrans[3][(t>>10L)&0x3f]^ \
201 DES_SPtrans[5][(t>>18L)&0x3f]^ \
202 DES_SPtrans[7][(t>>26L)&0x3f]; }
203
204 #define IP(l,r) \
205 { \
206 register DES_LONG tt; \
207 PERM_OP(r,l,tt, 4,0x0f0f0f0fL); \
208 PERM_OP(l,r,tt,16,0x0000ffffL); \
209 PERM_OP(r,l,tt, 2,0x33333333L); \
210 PERM_OP(l,r,tt, 8,0x00ff00ffL); \
211 PERM_OP(r,l,tt, 1,0x55555555L); \
212 }
213
214 #define PERM_OP(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\
215 (b)^=(t),\
216 (a)^=((t)<<(n)))
217
218 #define ROTATE(a,n) (((a)>>(n))+((a)<<(32-(n))))
219
220
221
222 static const unsigned char odd_parity[256] =
223 {
224 1, 1, 2, 2, 4, 4, 7, 7, 8, 8, 11, 11, 13, 13, 14, 14,
225 16, 16, 19, 19, 21, 21, 22, 22, 25, 25, 26, 26, 28, 28, 31, 31,
226 32, 32, 35, 35, 37, 37, 38, 38, 41, 41, 42, 42, 44, 44, 47, 47,
227 49, 49, 50, 50, 52, 52, 55, 55, 56, 56, 59, 59, 61, 61, 62, 62,
228 64, 64, 67, 67, 69, 69, 70, 70, 73, 73, 74, 74, 76, 76, 79, 79,
229 81, 81, 82, 82, 84, 84, 87, 87, 88, 88, 91, 91, 93, 93, 94, 94,
230 97, 97, 98, 98, 100, 100, 103, 103, 104, 104, 107, 107, 109, 109, 110,
231 110,
232 112, 112, 115, 115, 117, 117, 118, 118, 121, 121, 122, 122, 124, 124, 127,
233 127,
234 128, 128, 131, 131, 133, 133, 134, 134, 137, 137, 138, 138, 140, 140, 143,
235 143,
236 145, 145, 146, 146, 148, 148, 151, 151, 152, 152, 155, 155, 157, 157, 158,
237 158,
238 161, 161, 162, 162, 164, 164, 167, 167, 168, 168, 171, 171, 173, 173, 174,
239 174,
240 176, 176, 179, 179, 181, 181, 182, 182, 185, 185, 186, 186, 188, 188, 191,
241 191,
242 193, 193, 194, 194, 196, 196, 199, 199, 200, 200, 203, 203, 205, 205, 206,
243 206,
244 208, 208, 211, 211, 213, 213, 214, 214, 217, 217, 218, 218, 220, 220, 223,
245 223,
246 224, 224, 227, 227, 229, 229, 230, 230, 233, 233, 234, 234, 236, 236, 239,
247 239,
248 241, 241, 242, 242, 244, 244, 247, 247, 248, 248, 251, 251, 253, 253, 254,
249 254
250 };
251
252 #define HPERM_OP(a,t,n,m) ((t)=((((a)<<(16-(n)))^(a))&(m)),\
253 (a)=(a)^(t)^(t>>(16-(n))))
254
255 # define ITERATIONS 16
256 # define HALF_ITERATIONS 8
257
258 static const DES_LONG des_skb[8][64] =
259 {
260 {
261 /* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
262 0x00000000L, 0x00000010L, 0x20000000L, 0x20000010L,
263 0x00010000L, 0x00010010L, 0x20010000L, 0x20010010L,
264 0x00000800L, 0x00000810L, 0x20000800L, 0x20000810L,
265 0x00010800L, 0x00010810L, 0x20010800L, 0x20010810L,
266 0x00000020L, 0x00000030L, 0x20000020L, 0x20000030L,
267 0x00010020L, 0x00010030L, 0x20010020L, 0x20010030L,
268 0x00000820L, 0x00000830L, 0x20000820L, 0x20000830L,
269 0x00010820L, 0x00010830L, 0x20010820L, 0x20010830L,
270 0x00080000L, 0x00080010L, 0x20080000L, 0x20080010L,
271 0x00090000L, 0x00090010L, 0x20090000L, 0x20090010L,
272 0x00080800L, 0x00080810L, 0x20080800L, 0x20080810L,
273 0x00090800L, 0x00090810L, 0x20090800L, 0x20090810L,
274 0x00080020L, 0x00080030L, 0x20080020L, 0x20080030L,
275 0x00090020L, 0x00090030L, 0x20090020L, 0x20090030L,
276 0x00080820L, 0x00080830L, 0x20080820L, 0x20080830L,
277 0x00090820L, 0x00090830L, 0x20090820L, 0x20090830L,
278 },
279 {
280 /* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */
281 0x00000000L, 0x02000000L, 0x00002000L, 0x02002000L,
282 0x00200000L, 0x02200000L, 0x00202000L, 0x02202000L,
283 0x00000004L, 0x02000004L, 0x00002004L, 0x02002004L,
284 0x00200004L, 0x02200004L, 0x00202004L, 0x02202004L,
285 0x00000400L, 0x02000400L, 0x00002400L, 0x02002400L,
286 0x00200400L, 0x02200400L, 0x00202400L, 0x02202400L,
287 0x00000404L, 0x02000404L, 0x00002404L, 0x02002404L,
288 0x00200404L, 0x02200404L, 0x00202404L, 0x02202404L,
289 0x10000000L, 0x12000000L, 0x10002000L, 0x12002000L,
290 0x10200000L, 0x12200000L, 0x10202000L, 0x12202000L,
291 0x10000004L, 0x12000004L, 0x10002004L, 0x12002004L,
292 0x10200004L, 0x12200004L, 0x10202004L, 0x12202004L,
293 0x10000400L, 0x12000400L, 0x10002400L, 0x12002400L,
294 0x10200400L, 0x12200400L, 0x10202400L, 0x12202400L,
295 0x10000404L, 0x12000404L, 0x10002404L, 0x12002404L,
296 0x10200404L, 0x12200404L, 0x10202404L, 0x12202404L,
297 },
298 {
299 /* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */
300 0x00000000L, 0x00000001L, 0x00040000L, 0x00040001L,
301 0x01000000L, 0x01000001L, 0x01040000L, 0x01040001L,
302 0x00000002L, 0x00000003L, 0x00040002L, 0x00040003L,
303 0x01000002L, 0x01000003L, 0x01040002L, 0x01040003L,
304 0x00000200L, 0x00000201L, 0x00040200L, 0x00040201L,
305 0x01000200L, 0x01000201L, 0x01040200L, 0x01040201L,
306 0x00000202L, 0x00000203L, 0x00040202L, 0x00040203L,
307 0x01000202L, 0x01000203L, 0x01040202L, 0x01040203L,
308 0x08000000L, 0x08000001L, 0x08040000L, 0x08040001L,
309 0x09000000L, 0x09000001L, 0x09040000L, 0x09040001L,
310 0x08000002L, 0x08000003L, 0x08040002L, 0x08040003L,
311 0x09000002L, 0x09000003L, 0x09040002L, 0x09040003L,
312 0x08000200L, 0x08000201L, 0x08040200L, 0x08040201L,
313 0x09000200L, 0x09000201L, 0x09040200L, 0x09040201L,
314 0x08000202L, 0x08000203L, 0x08040202L, 0x08040203L,
315 0x09000202L, 0x09000203L, 0x09040202L, 0x09040203L,
316 },
317 {
318 /* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */
319 0x00000000L, 0x00100000L, 0x00000100L, 0x00100100L,
320 0x00000008L, 0x00100008L, 0x00000108L, 0x00100108L,
321 0x00001000L, 0x00101000L, 0x00001100L, 0x00101100L,
322 0x00001008L, 0x00101008L, 0x00001108L, 0x00101108L,
323 0x04000000L, 0x04100000L, 0x04000100L, 0x04100100L,
324 0x04000008L, 0x04100008L, 0x04000108L, 0x04100108L,
325 0x04001000L, 0x04101000L, 0x04001100L, 0x04101100L,
326 0x04001008L, 0x04101008L, 0x04001108L, 0x04101108L,
327 0x00020000L, 0x00120000L, 0x00020100L, 0x00120100L,
328 0x00020008L, 0x00120008L, 0x00020108L, 0x00120108L,
329 0x00021000L, 0x00121000L, 0x00021100L, 0x00121100L,
330 0x00021008L, 0x00121008L, 0x00021108L, 0x00121108L,
331 0x04020000L, 0x04120000L, 0x04020100L, 0x04120100L,
332 0x04020008L, 0x04120008L, 0x04020108L, 0x04120108L,
333 0x04021000L, 0x04121000L, 0x04021100L, 0x04121100L,
334 0x04021008L, 0x04121008L, 0x04021108L, 0x04121108L,
335 },
336 {
337 /* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
338 0x00000000L, 0x10000000L, 0x00010000L, 0x10010000L,
339 0x00000004L, 0x10000004L, 0x00010004L, 0x10010004L,
340 0x20000000L, 0x30000000L, 0x20010000L, 0x30010000L,
341 0x20000004L, 0x30000004L, 0x20010004L, 0x30010004L,
342 0x00100000L, 0x10100000L, 0x00110000L, 0x10110000L,
343 0x00100004L, 0x10100004L, 0x00110004L, 0x10110004L,
344 0x20100000L, 0x30100000L, 0x20110000L, 0x30110000L,
345 0x20100004L, 0x30100004L, 0x20110004L, 0x30110004L,
346 0x00001000L, 0x10001000L, 0x00011000L, 0x10011000L,
347 0x00001004L, 0x10001004L, 0x00011004L, 0x10011004L,
348 0x20001000L, 0x30001000L, 0x20011000L, 0x30011000L,
349 0x20001004L, 0x30001004L, 0x20011004L, 0x30011004L,
350 0x00101000L, 0x10101000L, 0x00111000L, 0x10111000L,
351 0x00101004L, 0x10101004L, 0x00111004L, 0x10111004L,
352 0x20101000L, 0x30101000L, 0x20111000L, 0x30111000L,
353 0x20101004L, 0x30101004L, 0x20111004L, 0x30111004L,
354 },
355 {
356 /* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */
357 0x00000000L, 0x08000000L, 0x00000008L, 0x08000008L,
358 0x00000400L, 0x08000400L, 0x00000408L, 0x08000408L,
359 0x00020000L, 0x08020000L, 0x00020008L, 0x08020008L,
360 0x00020400L, 0x08020400L, 0x00020408L, 0x08020408L,
361 0x00000001L, 0x08000001L, 0x00000009L, 0x08000009L,
362 0x00000401L, 0x08000401L, 0x00000409L, 0x08000409L,
363 0x00020001L, 0x08020001L, 0x00020009L, 0x08020009L,
364 0x00020401L, 0x08020401L, 0x00020409L, 0x08020409L,
365 0x02000000L, 0x0A000000L, 0x02000008L, 0x0A000008L,
366 0x02000400L, 0x0A000400L, 0x02000408L, 0x0A000408L,
367 0x02020000L, 0x0A020000L, 0x02020008L, 0x0A020008L,
368 0x02020400L, 0x0A020400L, 0x02020408L, 0x0A020408L,
369 0x02000001L, 0x0A000001L, 0x02000009L, 0x0A000009L,
370 0x02000401L, 0x0A000401L, 0x02000409L, 0x0A000409L,
371 0x02020001L, 0x0A020001L, 0x02020009L, 0x0A020009L,
372 0x02020401L, 0x0A020401L, 0x02020409L, 0x0A020409L,
373 },
374 {
375 /* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */
376 0x00000000L, 0x00000100L, 0x00080000L, 0x00080100L,
377 0x01000000L, 0x01000100L, 0x01080000L, 0x01080100L,
378 0x00000010L, 0x00000110L, 0x00080010L, 0x00080110L,
379 0x01000010L, 0x01000110L, 0x01080010L, 0x01080110L,
380 0x00200000L, 0x00200100L, 0x00280000L, 0x00280100L,
381 0x01200000L, 0x01200100L, 0x01280000L, 0x01280100L,
382 0x00200010L, 0x00200110L, 0x00280010L, 0x00280110L,
383 0x01200010L, 0x01200110L, 0x01280010L, 0x01280110L,
384 0x00000200L, 0x00000300L, 0x00080200L, 0x00080300L,
385 0x01000200L, 0x01000300L, 0x01080200L, 0x01080300L,
386 0x00000210L, 0x00000310L, 0x00080210L, 0x00080310L,
387 0x01000210L, 0x01000310L, 0x01080210L, 0x01080310L,
388 0x00200200L, 0x00200300L, 0x00280200L, 0x00280300L,
389 0x01200200L, 0x01200300L, 0x01280200L, 0x01280300L,
390 0x00200210L, 0x00200310L, 0x00280210L, 0x00280310L,
391 0x01200210L, 0x01200310L, 0x01280210L, 0x01280310L,
392 },
393 {
394 /* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */
395 0x00000000L, 0x04000000L, 0x00040000L, 0x04040000L,
396 0x00000002L, 0x04000002L, 0x00040002L, 0x04040002L,
397 0x00002000L, 0x04002000L, 0x00042000L, 0x04042000L,
398 0x00002002L, 0x04002002L, 0x00042002L, 0x04042002L,
399 0x00000020L, 0x04000020L, 0x00040020L, 0x04040020L,
400 0x00000022L, 0x04000022L, 0x00040022L, 0x04040022L,
401 0x00002020L, 0x04002020L, 0x00042020L, 0x04042020L,
402 0x00002022L, 0x04002022L, 0x00042022L, 0x04042022L,
403 0x00000800L, 0x04000800L, 0x00040800L, 0x04040800L,
404 0x00000802L, 0x04000802L, 0x00040802L, 0x04040802L,
405 0x00002800L, 0x04002800L, 0x00042800L, 0x04042800L,
406 0x00002802L, 0x04002802L, 0x00042802L, 0x04042802L,
407 0x00000820L, 0x04000820L, 0x00040820L, 0x04040820L,
408 0x00000822L, 0x04000822L, 0x00040822L, 0x04040822L,
409 0x00002820L, 0x04002820L, 0x00042820L, 0x04042820L,
410 0x00002822L, 0x04002822L, 0x00042822L, 0x04042822L,
411 }
412 };
413
414 void DES_set_key_unchecked(const_DES_cblock *key, DES_key_schedule *schedule)
415 {
416 static const int shifts2[16] =
417 { 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0 };
418 register DES_LONG c, d, t, s, t2;
419 register const unsigned char *in;
420 register DES_LONG *k;
421 register int i;
422
423 #ifdef OPENBSD_DEV_CRYPTO
424 memcpy(schedule->key, key, sizeof schedule->key);
425 schedule->session = NULL;
426 #endif
427 k = &schedule->ks->deslong[0];
428 in = &(*key)[0];
429
430 c2l(in, c);
431 c2l(in, d);
432
433 /*
434 * do PC1 in 47 simple operations :-) Thanks to John Fletcher
435 * (john_fletcher@lccmail.ocf.llnl.gov) for the inspiration. :-)
436 */
437 PERM_OP(d, c, t, 4, 0x0f0f0f0fL);
438 HPERM_OP(c, t, -2, 0xcccc0000L);
439 HPERM_OP(d, t, -2, 0xcccc0000L);
440 PERM_OP(d, c, t, 1, 0x55555555L);
441 PERM_OP(c, d, t, 8, 0x00ff00ffL);
442 PERM_OP(d, c, t, 1, 0x55555555L);
443 d = (((d & 0x000000ffL) << 16L) | (d & 0x0000ff00L) |
444 ((d & 0x00ff0000L) >> 16L) | ((c & 0xf0000000L) >> 4L));
445 c &= 0x0fffffffL;
446
447 for (i = 0; i < ITERATIONS; i++)
448 {
449 if (shifts2[i])
450 {
451 c = ((c >> 2L) | (c << 26L));
452 d = ((d >> 2L) | (d << 26L));
453 }
454 else
455 {
456 c = ((c >> 1L) | (c << 27L));
457 d = ((d >> 1L) | (d << 27L));
458 }
459 c &= 0x0fffffffL;
460 d &= 0x0fffffffL;
461 /*
462 * could be a few less shifts but I am to lazy at this point in time
463 * to investigate
464 */
465 s = des_skb[0][(c) & 0x3f] |
466 des_skb[1][((c >> 6L) & 0x03) | ((c >> 7L) & 0x3c)] |
467 des_skb[2][((c >> 13L) & 0x0f) | ((c >> 14L) & 0x30)] |
468 des_skb[3][((c >> 20L) & 0x01) | ((c >> 21L) & 0x06) |
469 ((c >> 22L) & 0x38)];
470 t = des_skb[4][(d) & 0x3f] |
471 des_skb[5][((d >> 7L) & 0x03) | ((d >> 8L) & 0x3c)] |
472 des_skb[6][(d >> 15L) & 0x3f] |
473 des_skb[7][((d >> 21L) & 0x0f) | ((d >> 22L) & 0x30)];
474
475 /* table contained 0213 4657 */
476 t2 = ((t << 16L) | (s & 0x0000ffffL)) & 0xffffffffL;
477 *(k++) = ROTATE(t2, 30) & 0xffffffffL;
478
479 t2 = ((s >> 16L) | (t & 0xffff0000L));
480 *(k++) = ROTATE(t2, 26) & 0xffffffffL;
481 }
482 }
483
484 void DES_set_odd_parity(DES_cblock *key)
485 {
486 unsigned int i;
487
488 for (i = 0; i < DES_KEY_SZ; i++)
489 (*key)[i] = odd_parity[(*key)[i]];
490 }
491
492
493 #if !defined(WITH_LIBCRYPTO)
494 void DES_encrypt1(DES_LONG *data, DES_key_schedule *ks, int enc)
495 {
496 register DES_LONG l=0, r=0, t=0, u=0;
497 //l = r = t = u = 0;
498
499 register DES_LONG *s;
500
501 r = data[0];
502 l = data[1];
503
504 IP(r, l);
505 /*
506 * Things have been modified so that the initial rotate is done outside
507 * the loop. This required the DES_SPtrans values in sp.h to be rotated
508 * 1 bit to the right. One perl script later and things have a 5% speed
509 * up on a sparc2. Thanks to Richard Outerbridge
510 * <71755.204@CompuServe.COM> for pointing this out.
511 */
512 /* clear the top bits on machines with 8byte longs */
513 /* shift left by 2 */
514 r = ROTATE(r, 29) & 0xffffffffL;
515 l = ROTATE(l, 29) & 0xffffffffL;
516
517 s = ks->ks->deslong;
518 /*
519 * I don't know if it is worth the effort of loop unrolling the inner
520 * loop
521 */
522 if (enc)
523 {
524 D_ENCRYPT(l, r, 0); /* 1 */
525 D_ENCRYPT(r, l, 2); /* 2 */
526 D_ENCRYPT(l, r, 4); /* 3 */
527 D_ENCRYPT(r, l, 6); /* 4 */
528 D_ENCRYPT(l, r, 8); /* 5 */
529 D_ENCRYPT(r, l, 10); /* 6 */
530 D_ENCRYPT(l, r, 12); /* 7 */
531 D_ENCRYPT(r, l, 14); /* 8 */
532 D_ENCRYPT(l, r, 16); /* 9 */
533 D_ENCRYPT(r, l, 18); /* 10 */
534 D_ENCRYPT(l, r, 20); /* 11 */
535 D_ENCRYPT(r, l, 22); /* 12 */
536 D_ENCRYPT(l, r, 24); /* 13 */
537 D_ENCRYPT(r, l, 26); /* 14 */
538 D_ENCRYPT(l, r, 28); /* 15 */
539 D_ENCRYPT(r, l, 30); /* 16 */
540 }
541 else
542 {
543 D_ENCRYPT(l, r, 30); /* 16 */
544 D_ENCRYPT(r, l, 28); /* 15 */
545 D_ENCRYPT(l, r, 26); /* 14 */
546 D_ENCRYPT(r, l, 24); /* 13 */
547 D_ENCRYPT(l, r, 22); /* 12 */
548 D_ENCRYPT(r, l, 20); /* 11 */
549 D_ENCRYPT(l, r, 18); /* 10 */
550 D_ENCRYPT(r, l, 16); /* 9 */
551 D_ENCRYPT(l, r, 14); /* 8 */
552 D_ENCRYPT(r, l, 12); /* 7 */
553 D_ENCRYPT(l, r, 10); /* 6 */
554 D_ENCRYPT(r, l, 8); /* 5 */
555 D_ENCRYPT(l, r, 6); /* 4 */
556 D_ENCRYPT(r, l, 4); /* 3 */
557 D_ENCRYPT(l, r, 2); /* 2 */
558 D_ENCRYPT(r, l, 0); /* 1 */
559 }
560
561 /* rotate and clear the top bits on machines with 8byte longs */
562 l = ROTATE(l, 3) & 0xffffffffL;
563 r = ROTATE(r, 3) & 0xffffffffL;
564
565 FP(r, l);
566 data[0] = l;
567 data[1] = r;
568 }
569 #endif
570
571
572 static void mdc2_body(MDC2_CTX *c, const unsigned char *in, size_t len);
573 int MDC2_Init(MDC2_CTX *c)
574 {
575 c->num = 0;
576 c->pad_type = 1;
577 memset(&(c->h[0]), 0x52, MDC2_BLOCK);
578 memset(&(c->hh[0]), 0x25, MDC2_BLOCK);
579 return 1;
580 }
581
582 int MDC2_Update(MDC2_CTX *c, const unsigned char *in, size_t len)
583 {
584 size_t i, j;
585
586 i = c->num;
587 if (i != 0)
588 {
589 if (len < MDC2_BLOCK - i)
590 {
591 /* partial block */
592 memcpy(&(c->data[i]), in, len);
593 c->num += (int)len;
594 return 1;
595 }
596 else
597 {
598 /* filled one */
599 j = MDC2_BLOCK - i;
600 memcpy(&(c->data[i]), in, j);
601 len -= j;
602 in += j;
603 c->num = 0;
604 mdc2_body(c, &(c->data[0]), MDC2_BLOCK);
605 }
606 }
607 i = len & ~((size_t)MDC2_BLOCK - 1);
608 if (i > 0)
609 mdc2_body(c, in, i);
610 j = len - i;
611 if (j > 0)
612 {
613 memcpy(&(c->data[0]), &(in[i]), j);
614 c->num = (int)j;
615 }
616 return 1;
617 }
618
619 static void mdc2_body(MDC2_CTX *c, const unsigned char *in, size_t len)
620 {
621 register DES_LONG tin0, tin1;
622 register DES_LONG ttin0, ttin1;
623 DES_LONG d[2], dd[2];
624 DES_key_schedule k;
625 unsigned char *p;
626 size_t i;
627
628 for (i = 0; i < len; i += 8)
629 {
630 c2l(in, tin0);
631 d[0] = dd[0] = tin0;
632 c2l(in, tin1);
633 d[1] = dd[1] = tin1;
634 c->h[0] = (c->h[0] & 0x9f) | 0x40;
635 c->hh[0] = (c->hh[0] & 0x9f) | 0x20;
636
637 DES_set_odd_parity(&c->h);
638 DES_set_key_unchecked(&c->h, &k);
639 DES_encrypt1(d, &k, 1);
640
641 DES_set_odd_parity(&c->hh);
642 DES_set_key_unchecked(&c->hh, &k);
643 DES_encrypt1(dd, &k, 1);
644
645 ttin0 = tin0 ^ dd[0];
646 ttin1 = tin1 ^ dd[1];
647 tin0 ^= d[0];
648 tin1 ^= d[1];
649
650 p = c->h;
651 l2c(tin0, p);
652 l2c(ttin1, p);
653 p = c->hh;
654 l2c(ttin0, p);
655 l2c(tin1, p);
656 }
657 }
658
659 int MDC2_Final(unsigned char *md, MDC2_CTX *c)
660 {
661 unsigned int i;
662 int j;
663
664 i = c->num;
665 j = c->pad_type;
666 if ((i > 0) || (j == 2))
667 {
668 if (j == 2)
669 c->data[i++] = 0x80;
670 memset(&(c->data[i]), 0, MDC2_BLOCK - i);
671 mdc2_body(c, c->data, MDC2_BLOCK);
672 }
673 memcpy(md, (char *)c->h, MDC2_BLOCK);
674 memcpy(&(md[MDC2_BLOCK]), (char *)c->hh, MDC2_BLOCK);
675 return 1;
676 }
Open Source Conditional Access Modul