![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to crypt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / lib / libc / gen|
Return to crypt.c CVS log | Up to [MW Coherent from dump] / coherent / b / lib / libc / gen |
1.1 root 1: /*
2: * Crypt subroutines - which use the
3: * DES (Data Encryption Standard)
4: * as published in National Bureau of Standards,
5: * "Encryption Algorithm for Computer Data Encryption",
6: * Vol. 40, No. 52, March 17, p.. 12134-12139.
7: * (Reprinted in Cryptologia, Vol. I, No. 3, July 1977).
8: */
9:
10: #include <stdio.h>
11: #include <string.h>
12:
13: #define NBPC 8 /* Bits in a char */
14: #define NIB 64 /* Input bits in a unit */
15: #define NKB 64 /* Number of key bits */
16: #define NUKB 56 /* Number of used key bits */
17: #define NOKB 48 /* Number out from each key iteration */
18: #define NITER 16 /* Number of iterations of S-functions */
19: #define NSBOX 8 /* Number of S-boxes */
20: #define NSCSET 64 /* Number in small character set */
21:
22: /*
23: * Table of Initial permutation of each 64 bit entity.
24: */
25: static char IP[NIB] = {
26: 57, 49, 41, 33, 25, 17, 9, 1,
27: 59, 51, 43, 35, 27, 19, 11, 3,
28: 61, 53, 45, 37, 29, 21, 13, 5,
29: 63, 55, 47, 39, 31, 23, 15, 7,
30: 56, 48, 40, 32, 24, 16, 8, 0,
31: 58, 50, 42, 34, 26, 18, 10, 2,
32: 60, 52, 44, 36, 28, 20, 12, 4,
33: 62, 54, 46, 38, 30, 22, 14, 6
34: };
35:
36: /*
37: * Inverted intial permutation ( IP -1)
38: */
39: static char IP1[NIB] = {
40: 39, 7, 47, 15, 55, 23, 63, 31,
41: 38, 6, 46, 14, 54, 22, 62, 30,
42: 37, 5, 45, 13, 53, 21, 61, 29,
43: 36, 4, 44, 12, 52, 20, 60, 28,
44: 35, 3, 43, 11, 51, 19, 59, 27,
45: 34, 2, 42, 10, 50, 18, 58, 26,
46: 33, 1, 41, 9, 49, 17, 57, 25,
47: 32, 0, 40, 8, 48, 16, 56, 24
48: };
49:
50: /*
51: * E bit-selection table
52: */
53: static char E[NOKB] = {
54: 31, 0, 1, 2, 3, 4,
55: 3, 4, 5, 6, 7, 8,
56: 7, 8, 9, 10, 11, 12,
57: 11, 12, 13, 14, 15, 16,
58: 15, 16, 17, 18, 19, 20,
59: 19, 20, 21, 22, 23, 24,
60: 23, 24, 25, 26, 27, 28,
61: 27, 28, 29, 30, 31, 0
62: };
63:
64: /*
65: * A saved copy of the E-table for
66: * crypt to perturb.
67: */
68: static char saveE[NOKB] = {
69: 31, 0, 1, 2, 3, 4,
70: 3, 4, 5, 6, 7, 8,
71: 7, 8, 9, 10, 11, 12,
72: 11, 12, 13, 14, 15, 16,
73: 15, 16, 17, 18, 19, 20,
74: 19, 20, 21, 22, 23, 24,
75: 23, 24, 25, 26, 27, 28,
76: 27, 28, 29, 30, 31, 0
77: };
78:
79: /*
80: * Permutation of 32-bits onto 32 bits
81: * known as "P"
82: */
83: static char P[NIB/2] = {
84: 15, 6, 19, 20,
85: 28, 11, 27, 16,
86: 0, 14, 22, 25,
87: 4, 17, 30, 9,
88: 1, 7, 23, 13,
89: 31, 26, 2, 8,
90: 18, 12, 29, 5,
91: 21, 10, 3, 24
92: };
93:
94: /*
95: * The following are the 8 S-box functions
96: * (S1, S2, S3, S4, ..., S8)
97: * Each turns a 6-bit quantity into a four bit number.
98: */
99: static char Sboxes[NSBOX][4][16] = {
100: /* S1 */
101: 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,
102: 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
103: 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
104: 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13,
105: /* S2 */
106: 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
107: 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
108: 0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
109: 13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9,
110: /* S3 */
111: 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
112: 13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
113: 13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
114: 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12,
115: /* S4 */
116: 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
117: 13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
118: 10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
119: 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14,
120: /* S5 */
121: 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
122: 14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
123: 4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
124: 11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3,
125: /* S6 */
126: 12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
127: 10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,
128: 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,
129: 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13,
130: /* S7 */
131: 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
132: 13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
133: 1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
134: 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12,
135: /* S8 */
136: 13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
137: 1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
138: 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
139: 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11
140: };
141:
142: /*
143: * Permuted choice tables
144: * PC-1 is used for first iteration of KS
145: * and PC-2 is used therafter.
146: */
147: static char PC1[NUKB] = {
148: 56, 48, 40, 32, 24, 16, 8,
149: 0, 57, 49, 41, 33, 25, 17,
150: 9, 1, 58, 50, 42, 34, 26,
151: 18, 10, 2, 59, 51, 43, 35,
152: /* Division between Co and Do */
153: 62, 54, 46, 38, 30, 22, 14,
154: 6, 61, 53, 45, 37, 29, 21,
155: 13, 5, 60, 52, 44, 36, 28,
156: 20, 12, 4, 27, 19, 11, 3
157: };
158:
159: static char PC2[NOKB] = {
160: 13, 16, 10, 23, 0, 4,
161: 2, 27, 14, 5, 20, 9,
162: 22, 18, 11, 3, 25, 7,
163: 15, 6, 26, 19, 12, 1,
164: 40, 51, 30, 36, 46, 54,
165: 29, 39, 50, 44, 32, 47,
166: 43, 48, 38, 55, 33, 52,
167: 45, 41, 49, 35, 28, 31
168: };
169:
170: /*
171: * Left shift table
172: */
173: static char shifts[NITER] = {
174: 1, 1, 2, 2, 2, 2, 2, 2,
175: 1, 2, 2, 2, 2, 2, 2, 1
176: };
177:
178: /*
179: * Table to map a 6-bit integer onto the
180: * smaller than ascii character set
181: * ([a-zA-Z0-9./]).
182: */
183: static char maptab[NSCSET] = {
184: 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
185: 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',
186: 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
187: 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F',
188: 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N',
189: 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
190: 'W', 'X', 'Y', 'Z', '0', '1', '2', '3',
191: '4', '5', '6', '7', '8', '9', '.', '/'
192: };
193:
194: static char Ki[NITER][NOKB];
195:
196: /*
197: * Encrypt the block (one bit per byte)
198: * using the (broken) DES algorithm.
199: * The `edflag' is zero for encrypt,
200: * non-zero for decrypt.
201: */
202: encrypt(block, edflag)
203: char block[NIB];
204: {
205: char block1[NIB], block2[NIB];
206:
207: permute(block, block1, IP, NIB);
208: cypher(block1, block2, edflag);
209: permute(block2, block, IP1, NIB);
210: }
211:
212: /*
213: * Setkey takes an array of NIB (64)
214: * bytes called `key', each of which
215: * contains one bit of the desired key.
216: * This uses the DES Key Schedule (KS) function
217: * to iteratively produce each of the NITER (16)
218: * Ki's from the original key.
219: */
220: setkey(key)
221: char key[NKB];
222: {
223: char cd[NUKB];
224: register ni;
225:
226: permute(key, cd, PC1, NUKB);
227: for (ni=0; ni<NITER; ni++) {
228: lrot(cd, shifts[ni], NUKB/2);
229: lrot(&cd[NUKB/2], shifts[ni], NUKB/2);
230: permute(cd, &Ki[ni][0], PC2, NOKB);
231: }
232: }
233:
234: /*
235: * Crypt - the password encryption routine.
236: * The key here, is the user's typed password
237: * and the second is a 2-character salt in
238: * the set "[a-zA-Z0-9./]". The salt
239: * changes the E-table in one of 4096 ways
240: * to frustrate the use of hardware to crack
241: * the DES code.
242: */
243: char *
244: crypt(key, salt)
245: char *key, *salt;
246: {
247: int sixbit;
248: char stuff[NIB];
249: char bkey[NKB];
250: static char passwd[16];
251: register char *cp, *bp;
252: register i;
253:
254: perturb(salt);
255: cp = key;
256: bp = bkey;
257: while (*cp!='\0' && bp<&bkey[NKB/NBPC])
258: *bp++ = *cp++;
259: while (bp < &bkey[NKB/NBPC])
260: *bp++ = '\0';
261: unpack(bkey, NKB);
262: setkey(bkey);
263: memcpy(stuff, "Password", NIB/NBPC);
264: unpack(stuff, NIB);
265: encrypt(stuff, 0);
266: cp = passwd;
267: *cp++ = salt[0];
268: *cp++ = salt[1];
269: bp = stuff;
270: i = sixbit = 0;
271: while (i < NIB) {
272: sixbit = (sixbit<<1) + *bp++;
273: if ((i++%6) == 6-1) {
274: *cp++ = maptab[sixbit];
275: sixbit = 0;
276: }
277: }
278: *cp++ = maptab[sixbit];
279: *cp = '\0';
280: return (passwd);
281: }
282:
283: /*
284: * Perturb the E-table based on 2 6-bit characters
285: * in the salt. It produces a random permutation for
286: * the E-table.
287: */
288: static
289: perturb(salt)
290: char salt[2];
291: {
292: register char *cp;
293: register i1, i2;
294: int salti;
295:
296: salti = 01<<8 | 01;
297: i1 = salt[0];
298: i2 = salt[1];
299: for (cp = maptab; cp < &maptab[NSCSET]; cp++) {
300: if (i1 == *cp)
301: salti |= (cp-maptab)<<1;
302: if (i2 == *cp)
303: salti |= (cp-maptab)<<9;
304: }
305: srand(salti);
306: /*
307: * Make new E-table, from the saved E-table
308: * with random junk added to it (mod NOKB).
309: */
310: for (i1 = 0; i1 < NOKB; i1++)
311: E[i1] = (saveE[i1] + (rand()>>6)) % (NIB/2);
312: }
313:
314: /*
315: * Permute incoming bits into outgoing
316: * chunk with permutation table (`ptab').
317: * `nbites' is the number of bits to
318: * produce from the transformation.
319: */
320: static
321: permute(ibits, obits, ptab, nbits)
322: register char *ibits;
323: register char *obits;
324: char *ptab;
325: {
326: register bitno;
327:
328: for (bitno = 0; bitno<nbits; bitno++)
329: *obits++ = ibits[ptab[bitno]];
330: }
331:
332: /*
333: * The intermediate cypher function
334: * It does a chunk of NIB (64) bits
335: * through the NITER (16) iterations
336: * of the cypher function `f'.
337: */
338: static
339: cypher(ibits, obits, edflag)
340: int edflag;
341: char ibits[NIB];
342: char obits[NIB];
343: {
344: char t1bits[NOKB];
345: char t2bits[NIB/2];
346: char left[NIB/2], right[NIB/2];
347: register int n;
348: register int i;
349:
350: memcpy(left, ibits, NIB/2);
351: memcpy(right, &ibits[NIB/2], NIB/2);
352: for (n=0; n<NITER; n++) {
353: /*
354: * L' = R
355: * R' = L + f(R,K)
356: */
357: permute(right, t1bits, E, NOKB);
358: i = edflag ? NITER-1-n : n;
359: m2add(t1bits, &Ki[i][0], t1bits, NOKB);
360: dosboxes(t1bits, t2bits);
361: permute(t2bits, t1bits, P, NIB/2);
362: m2add(t1bits, left, t2bits, NIB/2);
363: memcpy(left, right, NIB/2);
364: memcpy(right, t2bits, NIB/2);
365: }
366: memcpy(obits, right, NIB/2);
367: memcpy(&obits[NIB/2], left, NIB/2);
368: }
369:
370: /*
371: * Rotate (what DES calls shift) left
372: * `nbits' `bits' by `ns' places.
373: * The shift count is assumed less than
374: * NBPC (8).
375: */
376: static
377: lrot(bits, ns, nbits)
378: char *bits;
379: {
380: register i, nb;
381: register char *bp;
382: int byte;
383:
384: for (i=0; i<ns; i++) {
385: bp = bits;
386: byte = *bp;
387: nb = nbits-1;
388: do {
389: bp[0] = bp[1];
390: bp++;
391: } while (--nb);
392: *bp = byte;
393: }
394: }
395:
396: /*
397: * Modulo 2 addition of bit vectors
398: * `i1' and `i2' into `o'.
399: * `nbits' is the number of bits in
400: * each vector
401: */
402: static
403: m2add(i1, i2, o, nbits)
404: register char *i1, *i2;
405: register nbits;
406: register char *o;
407: {
408: do {
409: *o++ = *i1++ ^ *i2++;
410: } while (--nbits);
411: }
412:
413: /*
414: * Implement the "S-boxes"
415: * Transforming from ibits (NOKB or 48 bits)
416: * to obits (NIB/2 or 32 bits).
417: * For each of these boxes, there is a
418: * 6-bit chunk of the input with the row being
419: * the first and last of these and the column
420: * being the middle 4 bits.
421: */
422: static
423: dosboxes(ibits, obits)
424: char ibits[NOKB];
425: char obits[NIB/2];
426: {
427: register row, col;
428: register boxno;
429: int tempout;
430:
431: tempout = 0;
432: for (boxno=0; boxno < NSBOX; boxno++) {
433: row = col = 0;
434: row = row<<1 | *ibits++;
435: col = col<<1 | *ibits++;
436: col = col<<1 | *ibits++;
437: col = col<<1 | *ibits++;
438: col = col<<1 | *ibits++;
439: row = row<<1 | *ibits++;
440: tempout = (tempout<<4) | Sboxes[boxno][row][col];
441: for (col=0; col<4; col++) {
442: *obits++ = (tempout>>3) & 01;
443: tempout <<= 1;
444: }
445: }
446: }
447:
448: /*
449: * Unpack byte vector into bit vector
450: */
451: static
452: unpack(bytes, nbits)
453: char *bytes;
454: unsigned nbits;
455: {
456: register char *bitp;
457: register char *bp;
458: register i;
459: int byte;
460:
461: bitp = &bytes[nbits];
462: bp = &bytes[(nbits+NBPC-1)/NBPC];
463: for (i=nbits; i>0; i--) {
464: if ((i % NBPC) == 0)
465: byte = *--bp;
466: *--bitp = byte&01;
467: byte >>= 1;
468: }
469: }
470:
471: /*
472: * Pack bit vector into byte data.
473: */
474: static
475: pack(bp, nbits)
476: register char *bp;
477: unsigned nbits;
478: {
479: register i;
480: register char *bitp;
481: int byte;
482:
483: byte = 0;
484: bitp = bp;
485: for (i=0; i<nbits; i++) {
486: byte = byte<<1 | *bitp++;
487: if ((i%NBPC) == NBPC-1) {
488: *bp++ = byte;
489: byte = 0;
490: }
491: }
492: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.