1 | #include "globals.h"
|
---|
2 | #include "module-newcamd-des.h"
|
---|
3 | #include "oscam-string.h"
|
---|
4 |
|
---|
5 | #define DES_ECS2_DECRYPT (DES_IP | DES_IP_1 | DES_RIGHT)
|
---|
6 | #define DES_ECS2_CRYPT (DES_IP | DES_IP_1)
|
---|
7 |
|
---|
8 | #define CRYPT 0
|
---|
9 | #define HASH 1
|
---|
10 | #define F_EURO_S2 0
|
---|
11 | #define F_TRIPLE_DES 1
|
---|
12 |
|
---|
13 | #define TestBit(addr, bit) ((addr) & (1 << bit))
|
---|
14 |
|
---|
15 | extern const int32_t CWS_NETMSGSIZE;
|
---|
16 |
|
---|
17 | static const uint8_t PC2[8][6] =
|
---|
18 | {
|
---|
19 | { 14, 17, 11, 24, 1, 5 },
|
---|
20 | { 3, 28, 15, 6, 21, 10 },
|
---|
21 | { 23, 19, 12, 4, 26, 8 },
|
---|
22 | { 16, 7, 27, 20, 13, 2 },
|
---|
23 | { 41, 52, 31, 37, 47, 55 },
|
---|
24 | { 30, 40, 51, 45, 33, 48 },
|
---|
25 | { 44, 49, 39, 56, 34, 53 },
|
---|
26 | { 46, 42, 50, 36, 29, 32 }
|
---|
27 | };
|
---|
28 |
|
---|
29 |
|
---|
30 | static const uint8_t E[8][6] =
|
---|
31 | {
|
---|
32 | { 32, 1, 2, 3, 4, 5 },
|
---|
33 | { 4, 5, 6, 7, 8, 9 },
|
---|
34 | { 8, 9, 10, 11, 12, 13 },
|
---|
35 | { 12, 13, 14, 15, 16, 17 },
|
---|
36 | { 16, 17, 18, 19, 20, 21 },
|
---|
37 | { 20, 21, 22, 23, 24, 25 },
|
---|
38 | { 24, 25, 26, 27, 28, 29 },
|
---|
39 | { 28, 29, 30, 31, 32, 1 }
|
---|
40 | };
|
---|
41 |
|
---|
42 | static const uint8_t P[32] =
|
---|
43 | {
|
---|
44 | 16, 7, 20, 21, 29, 12, 28, 17, 1, 15, 23, 26, 5, 18, 31, 10,
|
---|
45 | 2, 8, 24, 14, 32, 27, 3, 9, 19, 13, 30, 6, 22, 11, 4, 25
|
---|
46 | };
|
---|
47 |
|
---|
48 | static const uint8_t SBOXES[4][64] =
|
---|
49 | {
|
---|
50 | {
|
---|
51 | 0x2e, 0xe0, 0xc4, 0xbf, 0x4d, 0x27, 0x11, 0xc4,
|
---|
52 | 0x72, 0x4e, 0xaf, 0x72, 0xbb, 0xdd, 0x68, 0x11,
|
---|
53 | 0x83, 0x5a, 0x5a, 0x06, 0x36, 0xfc, 0xfc, 0xab,
|
---|
54 | 0xd5, 0x39, 0x09, 0x95, 0xe0, 0x83, 0x97, 0x68,
|
---|
55 | 0x44, 0xbf, 0x21, 0x8c, 0x1e, 0xc8, 0xb8, 0x72,
|
---|
56 | 0xad, 0x14, 0xd6, 0xe9, 0x72, 0x21, 0x8b, 0xd7,
|
---|
57 | 0xff, 0x65, 0x9c, 0xfb, 0xc9, 0x03, 0x57, 0x9e,
|
---|
58 | 0x63, 0xaa, 0x3a, 0x40, 0x05, 0x56, 0xe0, 0x3d
|
---|
59 | },
|
---|
60 | {
|
---|
61 | 0xcf, 0xa3, 0x11, 0xfd, 0xa8, 0x44, 0xfe, 0x27,
|
---|
62 | 0x96, 0x7f, 0x2b, 0xc2, 0x63, 0x98, 0x84, 0x5e,
|
---|
63 | 0x09, 0x6c, 0xd7, 0x10, 0x32, 0xd1, 0x4d, 0xea,
|
---|
64 | 0xec, 0x06, 0x70, 0xb9, 0x55, 0x3b, 0xba, 0x85,
|
---|
65 | 0x90, 0x4d, 0xee, 0x38, 0xf7, 0x2a, 0x5b, 0xc1,
|
---|
66 | 0x2a, 0x93, 0x84, 0x5f, 0xcd, 0xf4, 0x31, 0xa2,
|
---|
67 | 0x75, 0xbb, 0x08, 0xe6, 0x4c, 0x17, 0xa6, 0x7c,
|
---|
68 | 0x19, 0x60, 0xd3, 0x05, 0xb2, 0x8e, 0x6f, 0xd9
|
---|
69 | },
|
---|
70 | {
|
---|
71 | 0x4a, 0xdd, 0xb0, 0x07, 0x29, 0xb0, 0xee, 0x79,
|
---|
72 | 0xf6, 0x43, 0x03, 0x94, 0x8f, 0x16, 0xd5, 0xaa,
|
---|
73 | 0x31, 0xe2, 0xcd, 0x38, 0x9c, 0x55, 0x77, 0xce,
|
---|
74 | 0x5b, 0x2c, 0xa4, 0xfb, 0x62, 0x8f, 0x18, 0x61,
|
---|
75 | 0x1d, 0x61, 0x46, 0xba, 0xb4, 0xdd, 0xd9, 0x80,
|
---|
76 | 0xc8, 0x16, 0x3f, 0x49, 0x73, 0xa8, 0xe0, 0x77,
|
---|
77 | 0xab, 0x94, 0xf1, 0x5f, 0x62, 0x0e, 0x8c, 0xf3,
|
---|
78 | 0x05, 0xeb, 0x5a, 0x25, 0x9e, 0x32, 0x27, 0xcc
|
---|
79 | },
|
---|
80 | {
|
---|
81 | 0xd7, 0x1d, 0x2d, 0xf8, 0x8e, 0xdb, 0x43, 0x85,
|
---|
82 | 0x60, 0xa6, 0xf6, 0x3f, 0xb9, 0x70, 0x1a, 0x43,
|
---|
83 | 0xa1, 0xc4, 0x92, 0x57, 0x38, 0x62, 0xe5, 0xbc,
|
---|
84 | 0x5b, 0x01, 0x0c, 0xea, 0xc4, 0x9e, 0x7f, 0x29,
|
---|
85 | 0x7a, 0x23, 0xb6, 0x1f, 0x49, 0xe0, 0x10, 0x76,
|
---|
86 | 0x9c, 0x4a, 0xcb, 0xa1, 0xe7, 0x8d, 0x2d, 0xd8,
|
---|
87 | 0x0f, 0xf9, 0x61, 0xc4, 0xa3, 0x95, 0xde, 0x0b,
|
---|
88 | 0xf5, 0x3c, 0x32, 0x57, 0x58, 0x62, 0x84, 0xbe
|
---|
89 | }
|
---|
90 | };
|
---|
91 |
|
---|
92 | static const uint8_t PC1[][8] =
|
---|
93 | {
|
---|
94 | {57, 49, 41, 33, 25, 17, 9, 1},
|
---|
95 | {58, 50, 42, 34, 26, 18, 10, 2},
|
---|
96 | {59, 51, 43, 35, 27, 19, 11, 3},
|
---|
97 | {60, 52, 44, 36, 63, 55, 47, 39},
|
---|
98 | {31, 23, 15, 7, 62, 54, 46, 38},
|
---|
99 | {30, 22, 14, 6, 61, 53, 45, 37},
|
---|
100 | {29, 21, 13, 5, 28, 20, 12, 4}
|
---|
101 | };
|
---|
102 |
|
---|
103 | void doPC1(uint8_t data[])
|
---|
104 | {
|
---|
105 | uint8_t buf[8];
|
---|
106 | uint8_t i, j;
|
---|
107 |
|
---|
108 | memset(buf, 0, 8);
|
---|
109 |
|
---|
110 | for(j = 0; j < 7; j++)
|
---|
111 | {
|
---|
112 | for(i = 0; i < 8; i++)
|
---|
113 | {
|
---|
114 | uint8_t lookup = PC1[j][i];
|
---|
115 | buf[j] |= ((data[(lookup >> 3)] >> (8 - (lookup & 7))) & 1) << (7 - i);
|
---|
116 | }
|
---|
117 | }
|
---|
118 |
|
---|
119 | memcpy(data, buf, 8);
|
---|
120 | }
|
---|
121 |
|
---|
122 | static void doIp(uint8_t data[])
|
---|
123 | {
|
---|
124 | uint8_t j, k;
|
---|
125 | uint8_t val;
|
---|
126 | uint8_t buf[8];
|
---|
127 | uint8_t *p;
|
---|
128 | uint8_t i = 8;
|
---|
129 | memset(buf, 0, sizeof(buf));
|
---|
130 |
|
---|
131 | for(i = 0; i < 8; i++)
|
---|
132 | {
|
---|
133 | val = data[i];
|
---|
134 | p = &buf[3];
|
---|
135 | j = 4;
|
---|
136 |
|
---|
137 | do
|
---|
138 | {
|
---|
139 | for(k = 0; k <= 4; k += 4)
|
---|
140 | {
|
---|
141 | p[k] >>= 1;
|
---|
142 | if(val & 1) { p[k] |= 0x80; }
|
---|
143 | val >>= 1;
|
---|
144 | }
|
---|
145 | p--;
|
---|
146 | }
|
---|
147 | while(--j);
|
---|
148 | }
|
---|
149 |
|
---|
150 | memcpy(data, buf, 8);
|
---|
151 | }
|
---|
152 |
|
---|
153 | static void doIp_1(uint8_t data[])
|
---|
154 | {
|
---|
155 | uint8_t j, k;
|
---|
156 | uint8_t r = 0;
|
---|
157 | uint8_t buf[8];
|
---|
158 | uint8_t *p;
|
---|
159 | uint8_t i = 8;
|
---|
160 |
|
---|
161 | for(i = 0; i < 8; i++)
|
---|
162 | {
|
---|
163 | p = &data[3];
|
---|
164 | j = 4;
|
---|
165 |
|
---|
166 | do
|
---|
167 | {
|
---|
168 | for(k = 0; k <= 4; k += 4)
|
---|
169 | {
|
---|
170 | r >>= 1;
|
---|
171 | if(p[k] & 1) { r |= 0x80; }
|
---|
172 | p[k] >>= 1;
|
---|
173 | }
|
---|
174 | p--;
|
---|
175 | }
|
---|
176 | while(--j);
|
---|
177 | buf[i] = r;
|
---|
178 | }
|
---|
179 |
|
---|
180 | memcpy(data, buf, 8);
|
---|
181 | }
|
---|
182 |
|
---|
183 | static void makeK(uint8_t *left, uint8_t *right, uint8_t *K)
|
---|
184 | {
|
---|
185 | uint8_t i, j;
|
---|
186 | uint8_t bit, val;
|
---|
187 | uint8_t *p;
|
---|
188 |
|
---|
189 | for(i = 0; i < 8; i++)
|
---|
190 | {
|
---|
191 | val = 0;
|
---|
192 | for(j = 0; j < 6; j++)
|
---|
193 | {
|
---|
194 | bit = PC2[i][j];
|
---|
195 | if(bit < 29)
|
---|
196 | {
|
---|
197 | bit = 28 - bit;
|
---|
198 | p = left;
|
---|
199 | }
|
---|
200 | else
|
---|
201 | {
|
---|
202 | bit = 56 - bit;
|
---|
203 | p = right;
|
---|
204 | }
|
---|
205 | val <<= 1;
|
---|
206 | if(p[bit >> 3] & (1 << (bit & 7))) { val |= 1; }
|
---|
207 | }
|
---|
208 | *K = val;
|
---|
209 | K++;
|
---|
210 | }
|
---|
211 | }
|
---|
212 |
|
---|
213 | static void rightRot(uint8_t key[])
|
---|
214 | {
|
---|
215 | uint8_t *p = key;
|
---|
216 | uint8_t i = 3;
|
---|
217 | uint8_t carry = 0;
|
---|
218 |
|
---|
219 | carry = 0;
|
---|
220 |
|
---|
221 | if(*p & 1) { carry = 0x08; }
|
---|
222 |
|
---|
223 | do
|
---|
224 | {
|
---|
225 | *p = (*p >> 1) | ((p[1] & 1) ? 0x80 : 0);
|
---|
226 | p++;
|
---|
227 | }
|
---|
228 | while(--i);
|
---|
229 |
|
---|
230 | *p = (*p >> 1) | carry;
|
---|
231 | }
|
---|
232 |
|
---|
233 | static void rightRotKeys(uint8_t left[], uint8_t right[])
|
---|
234 | {
|
---|
235 | rightRot(left);
|
---|
236 | rightRot(right);
|
---|
237 | }
|
---|
238 |
|
---|
239 | static void leftRot(uint8_t key[])
|
---|
240 | {
|
---|
241 | uint8_t i = 27;
|
---|
242 |
|
---|
243 | do
|
---|
244 | {
|
---|
245 | rightRot(key);
|
---|
246 | }
|
---|
247 | while(--i);
|
---|
248 | }
|
---|
249 |
|
---|
250 | static void leftRotKeys(uint8_t left[], uint8_t right[])
|
---|
251 | {
|
---|
252 | leftRot(left);
|
---|
253 | leftRot(right);
|
---|
254 | }
|
---|
255 |
|
---|
256 | static void desCore(uint8_t data[], uint8_t K[], uint8_t result[])
|
---|
257 | {
|
---|
258 | uint8_t i, j;
|
---|
259 | uint8_t bit, val;
|
---|
260 |
|
---|
261 | memset(result, 0, 4);
|
---|
262 |
|
---|
263 | for(i = 0; i < 8; i++)
|
---|
264 | {
|
---|
265 | val = 0;
|
---|
266 | for(j = 0; j < 6; j++)
|
---|
267 | {
|
---|
268 | bit = 32 - E[i][j];
|
---|
269 | val <<= 1;
|
---|
270 | if(data[3 - (bit >> 3)] & (1 << (bit & 7))) { val |= 1; }
|
---|
271 | }
|
---|
272 | val ^= K[i];
|
---|
273 | val = SBOXES[i & 3][val];
|
---|
274 | if(i > 3)
|
---|
275 | {
|
---|
276 | val >>= 4;
|
---|
277 | }
|
---|
278 | val &= 0x0f;
|
---|
279 | result[i >> 1] |= (i & 1) ? val : (val << 4);
|
---|
280 | }
|
---|
281 | }
|
---|
282 |
|
---|
283 | static void permut32(uint8_t data[])
|
---|
284 | {
|
---|
285 | uint8_t i, j;
|
---|
286 | uint8_t bit;
|
---|
287 | uint8_t r[4] = {0}; // init to keep Valgrind happy
|
---|
288 | uint8_t *p;
|
---|
289 |
|
---|
290 | for(i = 0; i < 32; i++)
|
---|
291 | {
|
---|
292 | bit = 32 - P[i];
|
---|
293 | p = r;
|
---|
294 | for(j = 0; j < 3; j++)
|
---|
295 | {
|
---|
296 | *p = (*p << 1) | ((p[1] & 0x80) ? 1 : 0);
|
---|
297 | p++;
|
---|
298 | }
|
---|
299 | *p <<= 1;
|
---|
300 | if(data[3 - (bit >> 3)] & (1 << (bit & 7))) { *p |= 1; }
|
---|
301 | }
|
---|
302 |
|
---|
303 | memcpy(data, r, 4);
|
---|
304 | }
|
---|
305 |
|
---|
306 | static void swap(uint8_t left[], uint8_t right[])
|
---|
307 | {
|
---|
308 | uint8_t x[4];
|
---|
309 |
|
---|
310 | memcpy(x, right, 4);
|
---|
311 | memcpy(right, left, 4);
|
---|
312 | memcpy(left, x, 4);
|
---|
313 | }
|
---|
314 |
|
---|
315 | static void desRound(uint8_t left[], uint8_t right[], uint8_t data[], uint8_t mode, uint8_t k8)
|
---|
316 | {
|
---|
317 | uint8_t i;
|
---|
318 | uint8_t K[8];
|
---|
319 | uint8_t r[4];
|
---|
320 | uint8_t tempr[4];
|
---|
321 | unsigned short temp;
|
---|
322 |
|
---|
323 | memcpy(tempr, data + 4, 4);
|
---|
324 |
|
---|
325 | /* Viaccess */
|
---|
326 | temp = (short)k8 * (short)tempr[0] + (short)k8 + (short)tempr[0];
|
---|
327 | tempr[0] = (temp & 0xff) - ((temp >> 8) & 0xff);
|
---|
328 | if((temp & 0xff) - (temp >> 8) < 0)
|
---|
329 | { tempr[0]++; }
|
---|
330 |
|
---|
331 | makeK(left, right, K);
|
---|
332 | desCore(tempr, K, r);
|
---|
333 | permut32(r);
|
---|
334 |
|
---|
335 | if(mode & DES_HASH)
|
---|
336 | {
|
---|
337 | i = r[0];
|
---|
338 | r[0] = r[1];
|
---|
339 | r[1] = i;
|
---|
340 | }
|
---|
341 |
|
---|
342 | for(i = 0; i < 4; i++)
|
---|
343 | {
|
---|
344 | *data ^= r[i];
|
---|
345 | data++;
|
---|
346 | }
|
---|
347 |
|
---|
348 | swap(data - 4, data);
|
---|
349 | }
|
---|
350 |
|
---|
351 | void nc_des(uint8_t key[], uint8_t mode, uint8_t data[])
|
---|
352 | {
|
---|
353 | uint8_t i;
|
---|
354 | uint8_t left[8];
|
---|
355 | uint8_t right[8];
|
---|
356 | uint8_t *p = left;
|
---|
357 |
|
---|
358 | short DESShift = (mode & DES_RIGHT) ? 0x8103 : 0xc081;
|
---|
359 |
|
---|
360 | for(i = 3; i > 0; i--)
|
---|
361 | {
|
---|
362 | *p = (key[i - 1] << 4) | (key[i] >> 4);
|
---|
363 | p++;
|
---|
364 | }
|
---|
365 | left[3] = key[0] >> 4;
|
---|
366 | right[0] = key[6];
|
---|
367 | right[1] = key[5];
|
---|
368 | right[2] = key[4];
|
---|
369 | right[3] = key[3] & 0x0f;
|
---|
370 |
|
---|
371 | if(mode & DES_IP) { doIp(data); }
|
---|
372 |
|
---|
373 | do
|
---|
374 | {
|
---|
375 | if(!(mode & DES_RIGHT))
|
---|
376 | {
|
---|
377 | leftRotKeys(left, right);
|
---|
378 | if(!(DESShift & 0x8000)) { leftRotKeys(left, right); }
|
---|
379 | }
|
---|
380 | desRound(left, right, data, mode, key[7]);
|
---|
381 |
|
---|
382 | if(mode & DES_RIGHT)
|
---|
383 | {
|
---|
384 | rightRotKeys(left, right);
|
---|
385 | if(!(DESShift & 0x8000)) { rightRotKeys(left, right); }
|
---|
386 | }
|
---|
387 | DESShift <<= 1;
|
---|
388 | }
|
---|
389 | while(DESShift);
|
---|
390 |
|
---|
391 | swap(data, data + 4);
|
---|
392 | if(mode & DES_IP_1) { doIp_1(data); }
|
---|
393 |
|
---|
394 | }
|
---|
395 |
|
---|
396 | /*------------------------------------------------------------------------*/
|
---|
397 | static void des_key_parity_adjust(uint8_t *key, uint8_t len)
|
---|
398 | {
|
---|
399 | uint8_t i, j, parity;
|
---|
400 |
|
---|
401 | for(i = 0; i < len; i++)
|
---|
402 | {
|
---|
403 | parity = 1;
|
---|
404 | for(j = 1; j < 8; j++) if((key[i] >> j) & 0x1) { parity = ~parity & 0x01; }
|
---|
405 | key[i] |= parity;
|
---|
406 | }
|
---|
407 | }
|
---|
408 |
|
---|
409 | static uint8_t *des_key_spread(uint8_t *normal, uint8_t *spread)
|
---|
410 | {
|
---|
411 | spread[ 0] = normal[ 0] & 0xfe;
|
---|
412 | spread[ 1] = ((normal[ 0] << 7) | (normal[ 1] >> 1)) & 0xfe;
|
---|
413 | spread[ 2] = ((normal[ 1] << 6) | (normal[ 2] >> 2)) & 0xfe;
|
---|
414 | spread[ 3] = ((normal[ 2] << 5) | (normal[ 3] >> 3)) & 0xfe;
|
---|
415 | spread[ 4] = ((normal[ 3] << 4) | (normal[ 4] >> 4)) & 0xfe;
|
---|
416 | spread[ 5] = ((normal[ 4] << 3) | (normal[ 5] >> 5)) & 0xfe;
|
---|
417 | spread[ 6] = ((normal[ 5] << 2) | (normal[ 6] >> 6)) & 0xfe;
|
---|
418 | spread[ 7] = normal[ 6] << 1;
|
---|
419 | spread[ 8] = normal[ 7] & 0xfe;
|
---|
420 | spread[ 9] = ((normal[ 7] << 7) | (normal[ 8] >> 1)) & 0xfe;
|
---|
421 | spread[10] = ((normal[ 8] << 6) | (normal[ 9] >> 2)) & 0xfe;
|
---|
422 | spread[11] = ((normal[ 9] << 5) | (normal[10] >> 3)) & 0xfe;
|
---|
423 | spread[12] = ((normal[10] << 4) | (normal[11] >> 4)) & 0xfe;
|
---|
424 | spread[13] = ((normal[11] << 3) | (normal[12] >> 5)) & 0xfe;
|
---|
425 | spread[14] = ((normal[12] << 2) | (normal[13] >> 6)) & 0xfe;
|
---|
426 | spread[15] = normal[13] << 1;
|
---|
427 |
|
---|
428 | des_key_parity_adjust(spread, 16);
|
---|
429 | return spread;
|
---|
430 | }
|
---|
431 |
|
---|
432 | static void des_random_get(uint8_t *buffer, uint8_t len)
|
---|
433 | {
|
---|
434 | uint8_t idx = 0;
|
---|
435 | int randomNo = 0;
|
---|
436 |
|
---|
437 | for(idx = 0; idx < len; idx++)
|
---|
438 | {
|
---|
439 | if(!(idx % 3)) { randomNo = rand(); }
|
---|
440 | buffer[idx] = (randomNo >> ((idx % 3) << 3)) & 0xff;
|
---|
441 | }
|
---|
442 | }
|
---|
443 |
|
---|
444 | static uint8_t getmask(uint8_t *OutData, uint8_t *Mask, uint8_t I, uint8_t J)
|
---|
445 | {
|
---|
446 | uint8_t K, B, M, M1 , D, DI, MI;
|
---|
447 |
|
---|
448 | K = I ^ J;
|
---|
449 | DI = 7;
|
---|
450 | if((K & 4) == 4)
|
---|
451 | {
|
---|
452 | K ^= 7;
|
---|
453 | DI ^= 7;
|
---|
454 | }
|
---|
455 | MI = 3;
|
---|
456 | MI &= J;
|
---|
457 | K ^= MI;
|
---|
458 | K += MI;
|
---|
459 | if((K & 4) == 4)
|
---|
460 | {
|
---|
461 | return 0;
|
---|
462 | }
|
---|
463 | DI ^= J;
|
---|
464 | D = OutData[DI];
|
---|
465 | MI = 0;
|
---|
466 | MI += J;
|
---|
467 | M1 = Mask[MI];
|
---|
468 | MI ^= 4;
|
---|
469 | M = Mask[MI];
|
---|
470 | B = 0;
|
---|
471 | for(K = 0; K <= 7; K++)
|
---|
472 | {
|
---|
473 | if((D & 1) == 1) { B += M; }
|
---|
474 | D = (D >> 1) + ((B & 1) << 7);
|
---|
475 | B = B >> 1;
|
---|
476 | }
|
---|
477 | return D ^ M1;
|
---|
478 | }
|
---|
479 |
|
---|
480 | static void v2mask(uint8_t *cw, uint8_t *mask)
|
---|
481 | {
|
---|
482 | int i, j;
|
---|
483 |
|
---|
484 | for(i = 7; i >= 0; i--)
|
---|
485 | for(j = 7; j >= 4; j--)
|
---|
486 | { cw[i] ^= getmask(cw, mask, i, j); }
|
---|
487 | for(i = 0; i <= 7; i++)
|
---|
488 | for(j = 0; j <= 3; j++)
|
---|
489 | { cw[i] ^= getmask(cw, mask, i, j); }
|
---|
490 | }
|
---|
491 |
|
---|
492 | static void EuroDes(uint8_t key1[], uint8_t key2[], uint8_t desMode, uint8_t operatingMode, uint8_t data[])
|
---|
493 | {
|
---|
494 | uint8_t mode;
|
---|
495 |
|
---|
496 | if(key1[7]) /* Viaccess */
|
---|
497 | {
|
---|
498 | mode = (operatingMode == HASH) ? DES_ECM_HASH : DES_ECM_CRYPT;
|
---|
499 |
|
---|
500 | if(key2 != NULL)
|
---|
501 | { v2mask(data, key2); }
|
---|
502 | nc_des(key1, mode, data);
|
---|
503 | if(key2 != NULL)
|
---|
504 | { v2mask(data, key2); }
|
---|
505 | }
|
---|
506 | else if(TestBit(desMode, F_TRIPLE_DES))
|
---|
507 | {
|
---|
508 | /* Eurocrypt 3-DES */
|
---|
509 | mode = (operatingMode == HASH) ? 0 : DES_RIGHT;
|
---|
510 | nc_des(key1, (uint8_t)(DES_IP | mode), data);
|
---|
511 |
|
---|
512 | mode ^= DES_RIGHT;
|
---|
513 | nc_des(key2, mode, data);
|
---|
514 |
|
---|
515 | mode ^= DES_RIGHT;
|
---|
516 | nc_des(key1, (uint8_t)(mode | DES_IP_1), data);
|
---|
517 | }
|
---|
518 | else
|
---|
519 | {
|
---|
520 | if(TestBit(desMode, F_EURO_S2))
|
---|
521 | {
|
---|
522 | /* Eurocrypt S2 */
|
---|
523 | mode = (operatingMode == HASH) ? DES_ECS2_CRYPT : DES_ECS2_DECRYPT;
|
---|
524 | }
|
---|
525 | else
|
---|
526 | {
|
---|
527 | /* Eurocrypt M */
|
---|
528 | mode = (operatingMode == HASH) ? DES_ECM_HASH : DES_ECM_CRYPT;
|
---|
529 | }
|
---|
530 | nc_des(key1, mode, data);
|
---|
531 | }
|
---|
532 | }
|
---|
533 |
|
---|
534 | int nc_des_encrypt(uint8_t *buffer, int len, uint8_t *deskey)
|
---|
535 | {
|
---|
536 | uint8_t checksum = 0;
|
---|
537 | uint8_t noPadBytes;
|
---|
538 | uint8_t padBytes[7];
|
---|
539 | char ivec[8];
|
---|
540 | short i;
|
---|
541 |
|
---|
542 | if(!deskey) { return len; }
|
---|
543 | noPadBytes = (8 - ((len - 1) % 8)) % 8;
|
---|
544 | if(len + noPadBytes + 1 >= CWS_NETMSGSIZE - 8) { return -1; }
|
---|
545 | des_random_get(padBytes, noPadBytes);
|
---|
546 | for(i = 0; i < noPadBytes; i++) { buffer[len++] = padBytes[i]; }
|
---|
547 | for(i = 2; i < len; i++) { checksum ^= buffer[i]; }
|
---|
548 | buffer[len++] = checksum;
|
---|
549 | des_random_get((uint8_t *)ivec, 8);
|
---|
550 | memcpy(buffer + len, ivec, 8);
|
---|
551 | for(i = 2; i < len; i += 8)
|
---|
552 | {
|
---|
553 | uint8_t j;
|
---|
554 | const uint8_t flags = (1 << F_EURO_S2) | (1 << F_TRIPLE_DES);
|
---|
555 | for(j = 0; j < 8; j++) { buffer[i + j] ^= ivec[j]; }
|
---|
556 | EuroDes(deskey, deskey + 8, flags, HASH, buffer + i);
|
---|
557 | memcpy(ivec, buffer + i, 8);
|
---|
558 | }
|
---|
559 | len += 8;
|
---|
560 | return len;
|
---|
561 | }
|
---|
562 |
|
---|
563 | int nc_des_decrypt(uint8_t *buffer, int len, uint8_t *deskey)
|
---|
564 | {
|
---|
565 | char ivec[8];
|
---|
566 | char nextIvec[8];
|
---|
567 | int i;
|
---|
568 | uint8_t checksum = 0;
|
---|
569 |
|
---|
570 | if(!deskey) { return len; }
|
---|
571 | if((len - 2) % 8 || (len - 2) < 16) { return -1; }
|
---|
572 | len -= 8;
|
---|
573 | memcpy(nextIvec, buffer + len, 8);
|
---|
574 | for(i = 2; i < len; i += 8)
|
---|
575 | {
|
---|
576 | uint8_t j;
|
---|
577 | const uint8_t flags = (1 << F_EURO_S2) | (1 << F_TRIPLE_DES);
|
---|
578 |
|
---|
579 | memcpy(ivec, nextIvec, 8);
|
---|
580 | memcpy(nextIvec, buffer + i, 8);
|
---|
581 | EuroDes(deskey, deskey + 8, flags, CRYPT, buffer + i);
|
---|
582 | for(j = 0; j < 8; j++)
|
---|
583 | { buffer[i + j] ^= ivec[j]; }
|
---|
584 | }
|
---|
585 | for(i = 2; i < len; i++) { checksum ^= buffer[i]; }
|
---|
586 | if(checksum) { return -1; }
|
---|
587 | return len;
|
---|
588 | }
|
---|
589 |
|
---|
590 | uint8_t *nc_des_login_key_get(uint8_t *key1, uint8_t *key2, int len, uint8_t *des16)
|
---|
591 | {
|
---|
592 | uint8_t des14[14];
|
---|
593 | int i;
|
---|
594 |
|
---|
595 | memcpy(des14, key1, sizeof(des14));
|
---|
596 | for(i = 0; i < len; i++) { des14[i % 14] ^= key2[i]; }
|
---|
597 | des16 = des_key_spread(des14, des16);
|
---|
598 | doPC1(des16);
|
---|
599 | doPC1(des16 + 8);
|
---|
600 | return des16;
|
---|
601 | }
|
---|