#if defined(LIBC_SCCS) && !defined(lint)
static char sccsid
[] = "@(#)crypt.c 5.3.1.1 (Berkeley) %G%";
#endif LIBC_SCCS and not lint
* This program implements the
* Proposed Federal Information Processing
* Data Encryption Standard.
* See Federal Register, March 17, 1975 (40FR12134)
* Final permutation, FP = IP^(-1)
* Permuted-choice 1 from the key bits
* Note that bits 8,16... are left out:
* They are intended for a parity check.
* Sequence of shifts used for the key schedule.
1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1,
* Permuted-choice 2, to pick out the bits from
* the CD array that generate the key schedule.
* The C and D arrays used to calculate the key schedule.
* Generated from the key.
* The E bit-selection table.
* Set up the key schedule from the key.
* First, generate C and D by permuting
* the key. The low order bit of each
* 8-bit char is not used, so C and D are only 28
* To generate Ki, rotate C and D according
* to schedule and pick up a permutation
for (k
=0; k
<shifts
[i
]; k
++) {
* get Ki. Note C and D are concatenated.
KS
[i
][j
] = C
[PC2_C
[j
]-1];
KS
[i
][j
+24] = D
[PC2_D
[j
]-28-1];
* The 8 selection functions.
* For some reason, they give a 0-origin
* index, unlike everything else.
14, 4,13, 1, 2,15,11, 8, 3,10, 6,12, 5, 9, 0, 7,
0,15, 7, 4,14, 2,13, 1,10, 6,12,11, 9, 5, 3, 8,
4, 1,14, 8,13, 6, 2,11,15,12, 9, 7, 3,10, 5, 0,
15,12, 8, 2, 4, 9, 1, 7, 5,11, 3,14,10, 0, 6,13,
15, 1, 8,14, 6,11, 3, 4, 9, 7, 2,13,12, 0, 5,10,
3,13, 4, 7,15, 2, 8,14,12, 0, 1,10, 6, 9,11, 5,
0,14, 7,11,10, 4,13, 1, 5, 8,12, 6, 9, 3, 2,15,
13, 8,10, 1, 3,15, 4, 2,11, 6, 7,12, 0, 5,14, 9,
10, 0, 9,14, 6, 3,15, 5, 1,13,12, 7,11, 4, 2, 8,
13, 7, 0, 9, 3, 4, 6,10, 2, 8, 5,14,12,11,15, 1,
13, 6, 4, 9, 8,15, 3, 0,11, 1, 2,12, 5,10,14, 7,
1,10,13, 0, 6, 9, 8, 7, 4,15,14, 3,11, 5, 2,12,
7,13,14, 3, 0, 6, 9,10, 1, 2, 8, 5,11,12, 4,15,
13, 8,11, 5, 6,15, 0, 3, 4, 7, 2,12, 1,10,14, 9,
10, 6, 9, 0,12,11, 7,13,15, 1, 3,14, 5, 2, 8, 4,
3,15, 0, 6,10, 1,13, 8, 9, 4, 5,11,12, 7, 2,14,
2,12, 4, 1, 7,10,11, 6, 8, 5, 3,15,13, 0,14, 9,
14,11, 2,12, 4, 7,13, 1, 5, 0,15,10, 3, 9, 8, 6,
4, 2, 1,11,10,13, 7, 8,15, 9,12, 5, 6, 3, 0,14,
11, 8,12, 7, 1,14, 2,13, 6,15, 0, 9,10, 4, 5, 3,
12, 1,10,15, 9, 2, 6, 8, 0,13, 3, 4,14, 7, 5,11,
10,15, 4, 2, 7,12, 9, 5, 6, 1,13,14, 0,11, 3, 8,
9,14,15, 5, 2, 8,12, 3, 7, 0, 4,10, 1,13,11, 6,
4, 3, 2,12, 9, 5,15,10,11,14, 1, 7, 6, 0, 8,13,
4,11, 2,14,15, 0, 8,13, 3,12, 9, 7, 5,10, 6, 1,
13, 0,11, 7, 4, 9, 1,10,14, 3, 5,12, 2,15, 8, 6,
1, 4,11,13,12, 3, 7,14,10,15, 6, 8, 0, 5, 9, 2,
6,11,13, 8, 1, 4,10, 7, 9, 5, 0,15,14, 2, 3,12,
13, 2, 8, 4, 6,15,11, 1,10, 9, 3,14, 5, 0,12, 7,
1,15,13, 8,10, 3, 7, 4,12, 5, 6,11, 0,14, 9, 2,
7,11, 4, 1, 9,12,14, 2, 0, 6,10,13,15, 3, 5, 8,
2, 1,14, 7, 4,10, 8,13,15,12, 9, 0, 3, 5, 6,11,
* P is a permutation on the selected combination
* of the current L and key.
* The current block, divided into 2 halves.
static char L
[64], *R
= L
+32;
* The combination of the key and the input, before selection.
* The payoff: encrypt a block.
* First, permute the bits in the input
* Perform an encryption operation 16 times.
for (ii
=0; ii
<16; ii
++) {
* which will be the new L.
* Expand R to 48 bits using the E selector;
* exclusive-or with the current key bits.
preS
[j
] = R
[E
[j
]-1] ^ KS
[i
][j
];
* The pre-select bits are now considered
* in 8 groups of 6 bits each.
* The 8 selection functions map these
* 6-bit quantities into 4-bit quantities
* and the results permuted
* The indexing into the selection functions
* is peculiar; it could be simplified by
* The new R is L ^ f(R, K).
* The f here has to be permuted first, though.
* Finally, the new L (the original R)
* The output L and R are reversed.
* gets the inverse permutation of the very original.
static char block
[66], iobuf
[16];
for(i
=0; (c
= *pw
) && i
<64; pw
++){
block
[i
] = (c
>>(6-j
)) & 01;