1c8719c4b2896c7d33b29c0f31bcac919e408a1c
[openafs.git] / src / rxkad / domestic / fcrypt.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /* NOTE: fc_cbc_encrypt now modifies its 5th argument, to permit chaining over
11  * scatter/gather vectors.
12  */
13
14
15 #include <afsconfig.h>
16 #ifdef KERNEL
17 #include "afs/param.h"
18 #else
19 #include <afs/param.h>
20 #endif
21
22 RCSID
23     ("$Header$");
24
25 #define DEBUG 0
26 #ifdef KERNEL
27 #ifndef UKERNEL
28 #include "afs/stds.h"
29 #if defined(AFS_AIX_ENV) || defined(AFS_AUX_ENV) || defined(AFS_SUN5_ENV) 
30 #include "h/systm.h"
31 #endif
32 #include "h/types.h"
33 #if !defined(AFS_LINUX20_ENV) && !defined(AFS_OBSD_ENV)
34 #include "netinet/in.h"
35 #endif
36 #else /* UKERNEL */
37 #include "afs/sysincludes.h"
38 #include "afs/stds.h"
39 #endif /* UKERNEL */
40 #ifdef AFS_LINUX22_ENV
41 #include <asm/byteorder.h>
42 #endif
43
44 #include "afs/longc_procs.h"
45
46 #else /* KERNEL */
47
48 #include <afs/stds.h>
49 #include <sys/types.h>
50 #include <string.h>
51 #ifdef AFS_NT40_ENV
52 #include <winsock2.h>
53 #else
54 #include <netinet/in.h>
55 #endif
56 #include <rx/rx.h>
57 #endif /* KERNEL */
58
59 #include "sboxes.h"
60 #include "fcrypt.h"
61 #include "rxkad.h"
62 #include <des/stats.h>
63
64 #ifdef TCRYPT
65 int ROUNDS = 16;
66 #else
67 #define ROUNDS 16
68 #endif
69
70 #define XPRT_FCRYPT
71
72 int
73 fc_keysched(struct ktc_encryptionKey *key, fc_KeySchedule schedule)
74 {
75     unsigned char *keychar = (unsigned char *)key;
76     afs_uint32 kword[2];
77
78     unsigned int temp;
79     int i;
80
81     /* first, flush the losing key parity bits. */
82     kword[0] = (*keychar++) >> 1;
83     kword[0] <<= 7;
84     kword[0] += (*keychar++) >> 1;
85     kword[0] <<= 7;
86     kword[0] += (*keychar++) >> 1;
87     kword[0] <<= 7;
88     kword[0] += (*keychar++) >> 1;
89     kword[1] = kword[0] >> 4;   /* get top 24 bits for hi word */
90     kword[0] &= 0xf;
91     kword[0] <<= 7;
92     kword[0] += (*keychar++) >> 1;
93     kword[0] <<= 7;
94     kword[0] += (*keychar++) >> 1;
95     kword[0] <<= 7;
96     kword[0] += (*keychar++) >> 1;
97     kword[0] <<= 7;
98     kword[0] += (*keychar) >> 1;
99
100     schedule[0] = kword[0];
101     for (i = 1; i < ROUNDS; i++) {
102         /* rotate right 3 */
103         temp = kword[0] & ((1 << 11) - 1);      /* get 11 lsb */
104         kword[0] =
105             (kword[0] >> 11) | ((kword[1] & ((1 << 11) - 1)) << (32 - 11));
106         kword[1] = (kword[1] >> 11) | (temp << (56 - 32 - 11));
107         schedule[i] = kword[0];
108     }
109     INC_RXKAD_STATS(fc_key_scheds);
110     return 0;
111 }
112
113 /* IN int encrypt; * 0 ==> decrypt, else encrypt */
114 afs_int32
115 fc_ecb_encrypt(void * clear, void * cipher,
116                const fc_KeySchedule schedule, int encrypt)
117 {
118     afs_uint32 L, R;
119     volatile afs_uint32 S, P;
120     volatile unsigned char *Pchar = (unsigned char *)&P;
121     volatile unsigned char *Schar = (unsigned char *)&S;
122     int i;
123
124 #ifndef WORDS_BIGENDIAN
125 #define Byte0 3
126 #define Byte1 2
127 #define Byte2 1
128 #define Byte3 0
129 #else
130 #define Byte0 0
131 #define Byte1 1
132 #define Byte2 2
133 #define Byte3 3
134 #endif
135
136 #if 0
137     memcpy(&L, clear, sizeof(afs_int32));
138     memcpy(&R, clear + 1, sizeof(afs_int32));
139 #else
140     L = ntohl(*((afs_uint32 *)clear));
141     R = ntohl(*((afs_uint32 *)clear + 1));
142 #endif
143
144     if (encrypt) {
145         INC_RXKAD_STATS(fc_encrypts[ENCRYPT]);
146         for (i = 0; i < (ROUNDS / 2); i++) {
147             S = *schedule++ ^ R;        /* xor R with key bits from schedule */
148             Pchar[Byte2] = sbox0[Schar[Byte0]]; /* do 8-bit S Box subst. */
149             Pchar[Byte3] = sbox1[Schar[Byte1]]; /* and permute the result */
150             Pchar[Byte1] = sbox2[Schar[Byte2]];
151             Pchar[Byte0] = sbox3[Schar[Byte3]];
152             P = (P >> 5) | ((P & ((1 << 5) - 1)) << (32 - 5));  /* right rot 5 bits */
153             L ^= P;             /* we're done with L, so save there */
154             S = *schedule++ ^ L;        /* this time xor with L */
155             Pchar[Byte2] = sbox0[Schar[Byte0]];
156             Pchar[Byte3] = sbox1[Schar[Byte1]];
157             Pchar[Byte1] = sbox2[Schar[Byte2]];
158             Pchar[Byte0] = sbox3[Schar[Byte3]];
159             P = (P >> 5) | ((P & ((1 << 5) - 1)) << (32 - 5));  /* right rot 5 bits */
160             R ^= P;
161         }
162     } else {
163         INC_RXKAD_STATS(fc_encrypts[DECRYPT]);
164         schedule = &schedule[ROUNDS - 1];       /* start at end of key schedule */
165         for (i = 0; i < (ROUNDS / 2); i++) {
166             S = *schedule-- ^ L;        /* xor R with key bits from schedule */
167             Pchar[Byte2] = sbox0[Schar[Byte0]]; /* do 8-bit S Box subst. and */
168             Pchar[Byte3] = sbox1[Schar[Byte1]]; /* permute the result */
169             Pchar[Byte1] = sbox2[Schar[Byte2]];
170             Pchar[Byte0] = sbox3[Schar[Byte3]];
171             P = (P >> 5) | ((P & ((1 << 5) - 1)) << (32 - 5));  /* right rot 5 bits */
172             R ^= P;             /* we're done with L, so save there */
173             S = *schedule-- ^ R;        /* this time xor with L */
174             Pchar[Byte2] = sbox0[Schar[Byte0]];
175             Pchar[Byte3] = sbox1[Schar[Byte1]];
176             Pchar[Byte1] = sbox2[Schar[Byte2]];
177             Pchar[Byte0] = sbox3[Schar[Byte3]];
178             P = (P >> 5) | ((P & ((1 << 5) - 1)) << (32 - 5));  /* right rot 5 bits */
179             L ^= P;
180         }
181     }
182 #if 0
183     memcpy(cipher, &L, sizeof(afs_int32));
184     memcpy(cipher + 1, &R, sizeof(afs_int32));
185 #else
186     *((afs_int32 *)cipher) = htonl(L);
187     *((afs_int32 *)cipher + 1) = htonl(R);
188 #endif
189     return 0;
190 }
191
192 /* Crypting can be done in segments by recycling xor.  All but the final segment must
193  * be multiples of 8 bytes.
194  * NOTE: fc_cbc_encrypt now modifies its 5th argument, to permit chaining over
195  * scatter/gather vectors.
196  */
197 /*
198   afs_int32 length; * in bytes *
199   int encrypt; * 0 ==> decrypt, else encrypt *
200   fc_KeySchedule key; * precomputed key schedule *
201   afs_uint32 *xor; * 8 bytes of initialization vector *
202 */
203 afs_int32
204 fc_cbc_encrypt(void *input, void *output, afs_int32 length,
205                const fc_KeySchedule key, afs_uint32 * xor, int encrypt)
206 {
207     afs_uint32 i, j;
208     afs_uint32 t_input[2];
209     afs_uint32 t_output[2];
210     unsigned char *t_in_p = (unsigned char *)t_input;
211
212     if (encrypt) {
213         for (i = 0; length > 0; i++, length -= 8) {
214             /* get input */
215             memcpy(t_input, input, sizeof(t_input));
216             input=((char *)input) + sizeof(t_input);
217
218             /* zero pad */
219             for (j = length; j <= 7; j++)
220                 *(t_in_p + j) = 0;
221
222             /* do the xor for cbc into the temp */
223             xor[0] ^= t_input[0];
224             xor[1] ^= t_input[1];
225             /* encrypt */
226             fc_ecb_encrypt(xor, t_output, key, encrypt);
227
228             /* copy temp output and save it for cbc */
229             memcpy(output, t_output, sizeof(t_output));
230             output=(char *)output + sizeof(t_output);
231
232             /* calculate xor value for next round from plain & cipher text */
233             xor[0] = t_input[0] ^ t_output[0];
234             xor[1] = t_input[1] ^ t_output[1];
235
236
237         }
238         t_output[0] = 0;
239         t_output[1] = 0;
240     } else {
241         /* decrypt */
242         for (i = 0; length > 0; i++, length -= 8) {
243             /* get input */
244             memcpy(t_input, input, sizeof(t_input));
245             input=((char *)input) + sizeof(t_input);
246
247             /* no padding for decrypt */
248             fc_ecb_encrypt(t_input, t_output, key, encrypt);
249
250             /* do the xor for cbc into the output */
251             t_output[0] ^= xor[0];
252             t_output[1] ^= xor[1];
253
254             /* copy temp output */
255             memcpy(output, t_output, sizeof(t_output));
256             output=((char *)output) + sizeof(t_output);
257
258             /* calculate xor value for next round from plain & cipher text */
259             xor[0] = t_input[0] ^ t_output[0];
260             xor[1] = t_input[1] ^ t_output[1];
261         }
262     }
263     return 0;
264 }