NetSim Source Code Help v14.4
All 13 Components
 
Loading...
Searching...
No Matches
des.c
1/******************************************
2** DES-Implementation
3** Author: B-Con (b-con@b-con.us)
4** Copyright/Restrictions: GNU GPL
5** Disclaimer: This code is presented "as is" without any garuentees; said author holds
6 liability for no problems rendered by the use of this code.
7** Details: This code is the implementation of the AES algorithm, as specified by the
8 NIST in in publication FIPS PUB 197, available on the NIST website at
9 http://csrc.nist.gov/publications/fips/fips46-3/fips46-3.pdf .
10******************************************/
11
12#define uchar unsigned char
13#define uint unsigned int
14#define ENCRYPT 1
15#define DECRYPT 0
16
17// Obtain bit "b" from the left and shift it "c" places from the right
18#define BITNUM(a,b,c) (((a[(b)/8] >> (7 - (b%8))) & 0x01) << (c))
19#define BITNUMINTR(a,b,c) ((((a) >> (31 - (b))) & 0x00000001) << (c))
20#define BITNUMINTL(a,b,c) ((((a) << (b)) & 0x80000000) >> (c))
21// This macro converts a 6 bit block with the S-Box row defined as the first and last
22// bits to a 6 bit block with the row defined by the first two bits.
23#define SBOXBIT(a) (((a) & 0x20) | (((a) & 0x1f) >> 1) | (((a) & 0x01) << 4))
24
25uchar sbox1[64] = {
26 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,
27 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
28 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0,
29 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13
30};
31uchar sbox2[64] = {
32 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10,
33 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5,
34 0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15,
35 13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9
36};
37uchar sbox3[64] = {
38 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8,
39 13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1,
40 13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7,
41 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12
42};
43uchar sbox4[64] = {
44 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15,
45 13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9,
46 10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4,
47 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14
48};
49uchar sbox5[64] = {
50 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9,
51 14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6,
52 4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14,
53 11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3
54};
55uchar sbox6[64] = {
56 12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11,
57 10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8,
58 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6,
59 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13
60};
61uchar sbox7[64] = {
62 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1,
63 13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6,
64 1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2,
65 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12
66};
67uchar sbox8[64] = {
68 13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7,
69 1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2,
70 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8,
71 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11
72};
73
74
75void key_schedule(uchar key[], uchar schedule[][6], uint mode)
76{
77 uint i,j,to_gen,C,D,
78 key_rnd_shift[16]={1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1},
79 key_perm_c[28]={56,48,40,32,24,16,8,0,57,49,41,33,25,17,
80 9,1,58,50,42,34,26,18,10,2,59,51,43,35},
81 key_perm_d[28]={62,54,46,38,30,22,14,6,61,53,45,37,29,21,
82 13,5,60,52,44,36,28,20,12,4,27,19,11,3},
83 key_compression[48]={13,16,10,23,0,4,2,27,14,5,20,9,
84 22,18,11,3,25,7,15,6,26,19,12,1,
85 40,51,30,36,46,54,29,39,50,44,32,47,
86 43,48,38,55,33,52,45,41,49,35,28,31};
87
88 // Permutated Choice #1 (copy the key in, ignoring parity bits).
89 for (i = 0, j = 31, C = 0; i < 28; ++i, --j)
90 C |= BITNUM(key,key_perm_c[i],j);
91 for (i = 0, j = 31, D = 0; i < 28; ++i, --j)
92 D |= BITNUM(key,key_perm_d[i],j);
93
94 // Generate the 16 subkeys.
95 for (i = 0; i < 16; ++i) {
96 C = ((C << key_rnd_shift[i]) | (C >> (28-key_rnd_shift[i]))) & 0xfffffff0;
97 D = ((D << key_rnd_shift[i]) | (D >> (28-key_rnd_shift[i]))) & 0xfffffff0;
98
99 // Decryption subkeys are reverse order of encryption subkeys so
100 // generate them in reverse if the key schedule is for decryption useage.
101 if (mode == DECRYPT)
102 to_gen = 15 - i;
103 else
104 to_gen = i;
105 // Initialize the array
106 for (j = 0; j < 6; ++j)
107 schedule[to_gen][j] = 0;
108 for (j = 0; j < 24; ++j)
109 schedule[to_gen][j/8] |= BITNUMINTR(C,key_compression[j],7 - (j%8));
110 for ( ; j < 48; ++j)
111 schedule[to_gen][j/8] |= BITNUMINTR(D,key_compression[j] - 28,7 - (j%8));
112 }
113}
114
115// Initial (Inv)Permutation step
116void IP(uint state[], uchar in[])
117{
118 state[0] = BITNUM(in,57,31) | BITNUM(in,49,30) | BITNUM(in,41,29) | BITNUM(in,33,28) |
119 BITNUM(in,25,27) | BITNUM(in,17,26) | BITNUM(in,9,25) | BITNUM(in,1,24) |
120 BITNUM(in,59,23) | BITNUM(in,51,22) | BITNUM(in,43,21) | BITNUM(in,35,20) |
121 BITNUM(in,27,19) | BITNUM(in,19,18) | BITNUM(in,11,17) | BITNUM(in,3,16) |
122 BITNUM(in,61,15) | BITNUM(in,53,14) | BITNUM(in,45,13) | BITNUM(in,37,12) |
123 BITNUM(in,29,11) | BITNUM(in,21,10) | BITNUM(in,13,9) | BITNUM(in,5,8) |
124 BITNUM(in,63,7) | BITNUM(in,55,6) | BITNUM(in,47,5) | BITNUM(in,39,4) |
125 BITNUM(in,31,3) | BITNUM(in,23,2) | BITNUM(in,15,1) | BITNUM(in,7,0);
126
127 state[1] = BITNUM(in,56,31) | BITNUM(in,48,30) | BITNUM(in,40,29) | BITNUM(in,32,28) |
128 BITNUM(in,24,27) | BITNUM(in,16,26) | BITNUM(in,8,25) | BITNUM(in,0,24) |
129 BITNUM(in,58,23) | BITNUM(in,50,22) | BITNUM(in,42,21) | BITNUM(in,34,20) |
130 BITNUM(in,26,19) | BITNUM(in,18,18) | BITNUM(in,10,17) | BITNUM(in,2,16) |
131 BITNUM(in,60,15) | BITNUM(in,52,14) | BITNUM(in,44,13) | BITNUM(in,36,12) |
132 BITNUM(in,28,11) | BITNUM(in,20,10) | BITNUM(in,12,9) | BITNUM(in,4,8) |
133 BITNUM(in,62,7) | BITNUM(in,54,6) | BITNUM(in,46,5) | BITNUM(in,38,4) |
134 BITNUM(in,30,3) | BITNUM(in,22,2) | BITNUM(in,14,1) | BITNUM(in,6,0);
135}
136
137void InvIP(uint state[], uchar in[])
138{
139 in[0] = BITNUMINTR(state[1],7,7) | BITNUMINTR(state[0],7,6) | BITNUMINTR(state[1],15,5) |
140 BITNUMINTR(state[0],15,4) | BITNUMINTR(state[1],23,3) | BITNUMINTR(state[0],23,2) |
141 BITNUMINTR(state[1],31,1) | BITNUMINTR(state[0],31,0);
142
143 in[1] = BITNUMINTR(state[1],6,7) | BITNUMINTR(state[0],6,6) | BITNUMINTR(state[1],14,5) |
144 BITNUMINTR(state[0],14,4) | BITNUMINTR(state[1],22,3) | BITNUMINTR(state[0],22,2) |
145 BITNUMINTR(state[1],30,1) | BITNUMINTR(state[0],30,0);
146
147 in[2] = BITNUMINTR(state[1],5,7) | BITNUMINTR(state[0],5,6) | BITNUMINTR(state[1],13,5) |
148 BITNUMINTR(state[0],13,4) | BITNUMINTR(state[1],21,3) | BITNUMINTR(state[0],21,2) |
149 BITNUMINTR(state[1],29,1) | BITNUMINTR(state[0],29,0);
150
151 in[3] = BITNUMINTR(state[1],4,7) | BITNUMINTR(state[0],4,6) | BITNUMINTR(state[1],12,5) |
152 BITNUMINTR(state[0],12,4) | BITNUMINTR(state[1],20,3) | BITNUMINTR(state[0],20,2) |
153 BITNUMINTR(state[1],28,1) | BITNUMINTR(state[0],28,0);
154
155 in[4] = BITNUMINTR(state[1],3,7) | BITNUMINTR(state[0],3,6) | BITNUMINTR(state[1],11,5) |
156 BITNUMINTR(state[0],11,4) | BITNUMINTR(state[1],19,3) | BITNUMINTR(state[0],19,2) |
157 BITNUMINTR(state[1],27,1) | BITNUMINTR(state[0],27,0);
158
159 in[5] = BITNUMINTR(state[1],2,7) | BITNUMINTR(state[0],2,6) | BITNUMINTR(state[1],10,5) |
160 BITNUMINTR(state[0],10,4) | BITNUMINTR(state[1],18,3) | BITNUMINTR(state[0],18,2) |
161 BITNUMINTR(state[1],26,1) | BITNUMINTR(state[0],26,0);
162
163 in[6] = BITNUMINTR(state[1],1,7) | BITNUMINTR(state[0],1,6) | BITNUMINTR(state[1],9,5) |
164 BITNUMINTR(state[0],9,4) | BITNUMINTR(state[1],17,3) | BITNUMINTR(state[0],17,2) |
165 BITNUMINTR(state[1],25,1) | BITNUMINTR(state[0],25,0);
166
167 in[7] = BITNUMINTR(state[1],0,7) | BITNUMINTR(state[0],0,6) | BITNUMINTR(state[1],8,5) |
168 BITNUMINTR(state[0],8,4) | BITNUMINTR(state[1],16,3) | BITNUMINTR(state[0],16,2) |
169 BITNUMINTR(state[1],24,1) | BITNUMINTR(state[0],24,0);
170}
171
172uint f(uint state, uchar key[])
173{
174 uchar lrgstate[6];
175 uint t1,t2;
176
177 // Expantion Permutation
178 t1 = BITNUMINTL(state,31,0) | ((state & 0xf0000000) >> 1) | BITNUMINTL(state,4,5) |
179 BITNUMINTL(state,3,6) | ((state & 0x0f000000) >> 3) | BITNUMINTL(state,8,11) |
180 BITNUMINTL(state,7,12) | ((state & 0x00f00000) >> 5) | BITNUMINTL(state,12,17) |
181 BITNUMINTL(state,11,18) | ((state & 0x000f0000) >> 7) | BITNUMINTL(state,16,23);
182
183 t2 = BITNUMINTL(state,15,0) | ((state & 0x0000f000) << 15) | BITNUMINTL(state,20,5) |
184 BITNUMINTL(state,19,6) | ((state & 0x00000f00) << 13) | BITNUMINTL(state,24,11) |
185 BITNUMINTL(state,23,12) | ((state & 0x000000f0) << 11) | BITNUMINTL(state,28,17) |
186 BITNUMINTL(state,27,18) | ((state & 0x0000000f) << 9) | BITNUMINTL(state,0,23);
187
188 lrgstate[0] = (t1 >> 24) & 0x000000ff;
189 lrgstate[1] = (t1 >> 16) & 0x000000ff;
190 lrgstate[2] = (t1 >> 8) & 0x000000ff;
191 lrgstate[3] = (t2 >> 24) & 0x000000ff;
192 lrgstate[4] = (t2 >> 16) & 0x000000ff;
193 lrgstate[5] = (t2 >> 8) & 0x000000ff;
194
195 // Key XOR
196 lrgstate[0] ^= key[0];
197 lrgstate[1] ^= key[1];
198 lrgstate[2] ^= key[2];
199 lrgstate[3] ^= key[3];
200 lrgstate[4] ^= key[4];
201 lrgstate[5] ^= key[5];
202
203 // S-Box Permutation
204 state = (sbox1[SBOXBIT(lrgstate[0] >> 2)] << 28) |
205 (sbox2[SBOXBIT(((lrgstate[0] & 0x03) << 4) | (lrgstate[1] >> 4))] << 24) |
206 (sbox3[SBOXBIT(((lrgstate[1] & 0x0f) << 2) | (lrgstate[2] >> 6))] << 20) |
207 (sbox4[SBOXBIT(lrgstate[2] & 0x3f)] << 16) |
208 (sbox5[SBOXBIT(lrgstate[3] >> 2)] << 12) |
209 (sbox6[SBOXBIT(((lrgstate[3] & 0x03) << 4) | (lrgstate[4] >> 4))] << 8) |
210 (sbox7[SBOXBIT(((lrgstate[4] & 0x0f) << 2) | (lrgstate[5] >> 6))] << 4) |
211 sbox8[SBOXBIT(lrgstate[5] & 0x3f)];
212
213 // P-Box Permutation
214 state = BITNUMINTL(state,15,0) | BITNUMINTL(state,6,1) | BITNUMINTL(state,19,2) |
215 BITNUMINTL(state,20,3) | BITNUMINTL(state,28,4) | BITNUMINTL(state,11,5) |
216 BITNUMINTL(state,27,6) | BITNUMINTL(state,16,7) | BITNUMINTL(state,0,8) |
217 BITNUMINTL(state,14,9) | BITNUMINTL(state,22,10) | BITNUMINTL(state,25,11) |
218 BITNUMINTL(state,4,12) | BITNUMINTL(state,17,13) | BITNUMINTL(state,30,14) |
219 BITNUMINTL(state,9,15) | BITNUMINTL(state,1,16) | BITNUMINTL(state,7,17) |
220 BITNUMINTL(state,23,18) | BITNUMINTL(state,13,19) | BITNUMINTL(state,31,20) |
221 BITNUMINTL(state,26,21) | BITNUMINTL(state,2,22) | BITNUMINTL(state,8,23) |
222 BITNUMINTL(state,18,24) | BITNUMINTL(state,12,25) | BITNUMINTL(state,29,26) |
223 BITNUMINTL(state,5,27) | BITNUMINTL(state,21,28) | BITNUMINTL(state,10,29) |
224 BITNUMINTL(state,3,30) | BITNUMINTL(state,24,31);
225
226 // Return the final state value
227 return(state);
228}
229
230void des_crypt(uchar in[], uchar out[], uchar key[][6])
231{
232 uint state[2],idx,t;
233
234 IP(state,in);
235
236 // Loop 16 times, perform the final loop manually as it doesn't switch sides
237 for (idx=0; idx < 15; ++idx) {
238 t = state[1];
239 state[1] = f(state[1],key[idx]) ^ state[0];
240 state[0] = t;
241 }
242 state[0] = f(state[1],key[15]) ^ state[0];
243
244 // Inverse IP
245 InvIP(state,out);
246}
247
248/**************************************
249 3DES functions
250**************************************/
251
252void three_des_key_schedule(uchar key[], uchar schedule[][16][6], uint mode)
253{
254 if (mode == ENCRYPT) {
255 key_schedule(&key[0],schedule[0],mode);
256 key_schedule(&key[8],schedule[1],!mode);
257 key_schedule(&key[16],schedule[2],mode);
258 }
259 else {
260 key_schedule(&key[16],schedule[0],mode);
261 key_schedule(&key[8],schedule[1],!mode);
262 key_schedule(&key[0],schedule[2],mode);
263 }
264}
265
266void three_des_crypt(uchar in[], uchar out[], uchar key[][16][6])
267{
268 des_crypt(in,out,key[0]);
269 des_crypt(out,out,key[1]);
270 des_crypt(out,out,key[2]);
271}
272
273/************************************/