pull-prototypes-to-head-20020821
[openafs.git] / src / des / pcbc_encrypt.c
1 /*
2  * Copyright 1985, 1986, 1987, 1988 by the Massachusetts Institute
3  * of Technology.
4  *
5  * For copying and distribution information, please see the file
6  * <mit-cpyright.h>.
7  *
8  * These routines perform encryption and decryption using the DES
9  * private key algorithm, or else a subset of it-- fewer inner loops.
10  * ( AUTH_DES_ITER defaults to 16, may be less)
11  *
12  * Under U.S. law, this software may not be exported outside the US
13  * without license from the U.S. Commerce department.
14  *
15  * The key schedule is passed as an arg, as well as the cleartext or
16  * ciphertext.   The cleartext and ciphertext should be in host order.
17  *
18  * These routines form the library interface to the des facilities.
19  *
20  * spm 8/85     MIT project athena
21  */
22
23 #include <mit-cpyright.h>
24 #ifndef KERNEL
25 #include <stdio.h>
26 #endif
27 #include <des.h>
28 #include <afsconfig.h>
29 #include <afs/param.h>
30 #include "des_prototypes.h"
31
32 RCSID("$Header$");
33
34 #include "des_internal.h"
35
36 #define XPRT_PCBC_ENCRYPT
37
38 /*
39  * pcbc_encrypt is an "error propagation chaining" encrypt operation
40  * for DES, similar to CBC, but that, on encryption, "xor"s the
41  * plaintext of block N with the ciphertext resulting from block N,
42  * then "xor"s that result with the plaintext of block N+1 prior to
43  * encrypting block N+1. (decryption the appropriate inverse.  This
44  * "pcbc" mode propagates a single bit error anywhere in either the
45  * cleartext or ciphertext chain all the way through to the end. In
46  * contrast, CBC mode limits a single bit error in the ciphertext to
47  * affect only the current (8byte) block and the subsequent block.
48  *
49  * performs pcbc error-propagation chaining operation by xor-ing block
50  * N+1 with both the plaintext (block N) and the ciphertext from block
51  * N.  Either encrypts from cleartext to ciphertext, if encrypt != 0
52  * or decrypts from ciphertext to cleartext, if encrypt == 0
53  *
54  * NOTE-- the output is ALWAYS an multiple of 8 bytes long.  If not
55  * enough space was provided, your program will get trashed.
56  *
57  * For encryption, the cleartext string is null padded, at the end, to
58  * an integral multiple of eight bytes.
59  *
60  * For decryption, the ciphertext will be used in integral multiples
61  * of 8 bytes, but only the first "length" bytes returned into the
62  * cleartext.
63  *
64  * This is NOT a standard mode of operation.
65  *
66  */
67 /*
68     des_cblock *in;             * >= length bytes of input text *
69     des_cblock *out;            * >= length bytes of output text *
70     register afs_int32 length;  * in bytes *
71     int encrypt;                * 0 ==> decrypt, else encrypt *
72     des_key_schedule key;       * precomputed key schedule *
73     des_cblock *iv;             * 8 bytes of ivec *
74 */
75 afs_int32 des_pcbc_encrypt(des_cblock *in, des_cblock *out,
76         register afs_int32 length, des_key_schedule key,
77         des_cblock *iv, int encrypt)
78 {
79     register afs_uint32 *input = (afs_uint32 *) in;
80     register afs_uint32 *output = (afs_uint32 *) out;
81     register afs_uint32 *ivec = (afs_uint32 *) iv;
82
83     afs_uint32 i,j;
84     afs_uint32 t_input[2];
85     afs_uint32 t_output[2];
86     unsigned char *t_in_p = (unsigned char *) t_input;
87     afs_uint32 xor_0, xor_1;
88
89     if (encrypt) {
90 #ifdef MUSTALIGN
91         if ((afs_int32) ivec & 3) {
92             memcpy((char *)&xor_0, (char *)ivec++, sizeof(xor_0));
93             memcpy((char *)&xor_1, (char *)ivec, sizeof(xor_1));
94         }
95         else
96 #endif
97         {
98             xor_0 = *ivec++;
99             xor_1 = *ivec;
100         }
101
102         for (i = 0; length > 0; i++, length -= 8) {
103             /* get input */
104 #ifdef MUSTALIGN
105             if ((afs_int32) input & 3) {
106                 memcpy((char *)&t_input[0], (char *)input, sizeof(t_input[0]));
107                 memcpy((char *)&t_input[1], (char *)(input+1), sizeof(t_input[1]));
108             }
109             else
110 #endif
111             {
112                 t_input[0] = *input;
113                 t_input[1] = *(input+1);
114             }
115
116             /* zero pad */
117             if (length < 8) {
118                 for (j = length; j <= 7; j++)
119                     *(t_in_p+j)= 0;
120             }
121
122 #ifdef DEBUG
123             if (des_debug)
124                 des_debug_print("clear",length,t_input[0],t_input[1]);
125 #endif
126             /* do the xor for cbc into the temp */
127             t_input[0] ^= xor_0 ;
128             t_input[1] ^= xor_1 ;
129             /* encrypt */
130             (void) des_ecb_encrypt(t_input,t_output,key,encrypt);
131
132             /*
133              * We want to XOR with both the plaintext and ciphertext
134              * of the previous block, before we write the output, in
135              * case both input and output are the same space.
136              */
137 #ifdef MUSTALIGN
138             if ((afs_int32) input & 3) {
139                 memcpy((char *)&xor_0, (char *)input++, sizeof(xor_0));
140                 xor_0 ^= t_output[0];
141                 memcpy((char *)&xor_1, (char *)input++, sizeof(xor_1));
142                 xor_1 ^= t_output[1];
143             }
144             else
145 #endif
146             {
147                 xor_0 = *input++ ^ t_output[0];
148                 xor_1 = *input++ ^ t_output[1];
149             }
150
151
152             /* copy temp output and save it for cbc */
153 #ifdef MUSTALIGN
154             if ((afs_int32) output & 3) {
155                 memcpy((char *)output++, (char *)&t_output[0], sizeof(t_output[0]));
156                 memcpy((char *)output++, (char *)&t_output[1], sizeof(t_output[1]));
157             }
158             else
159 #endif
160             {
161                 *output++ = t_output[0];
162                 *output++ = t_output[1];
163             }
164
165 #ifdef DEBUG
166             if (des_debug) {
167                 des_debug_print("xor'ed",i,t_input[0],t_input[1]);
168                 des_debug_print("cipher",i,t_output[0],t_output[1]);
169             }
170 #endif
171         }
172         t_output[0] = 0;
173         t_output[1] = 0;
174         xor_0 = 0;
175         xor_1 = 0;
176         return 0;
177     }
178
179     else {
180         /* decrypt */
181 #ifdef MUSTALIGN
182         if ((afs_int32) ivec & 3) {
183             memcpy((char *)&xor_0, (char *)ivec++, sizeof(xor_0));
184             memcpy((char *)&xor_1, (char *)ivec, sizeof(xor_1));
185         }
186         else
187 #endif
188         {
189             xor_0 = *ivec++;
190             xor_1 = *ivec;
191         }
192
193         for (i = 0; length > 0; i++, length -= 8) {
194             /* get input */
195 #ifdef MUSTALIGN
196             if ((afs_int32) input & 3) {
197                 memcpy((char *)&t_input[0], (char *)input++, sizeof(t_input[0]));
198                 memcpy((char *)&t_input[1], (char *)input++, sizeof(t_input[1]));
199             }
200             else
201 #endif
202             {
203                 t_input[0] = *input++;
204                 t_input[1] = *input++;
205             }
206
207             /* no padding for decrypt */
208 #ifdef DEBUG
209             if (des_debug)
210                 des_debug_print("cipher",i,t_input[0],t_input[1]);
211 #else
212 #ifdef lint
213             i = i;
214 #endif
215 #endif
216             /* encrypt */
217             (void) des_ecb_encrypt(t_input,t_output,key,encrypt);
218 #ifdef DEBUG
219             if (des_debug)
220                 des_debug_print("out pre xor",i,t_output[0],t_output[1]);
221 #endif
222             /* do the xor for cbc into the output */
223             t_output[0] ^= xor_0 ;
224             t_output[1] ^= xor_1 ;
225             /* copy temp output */
226 #ifdef MUSTALIGN
227             if ((afs_int32) output & 3) {
228                 memcpy((char *)output++, (char *)&t_output[0], sizeof(t_output[0]));
229                 memcpy((char *)output++, (char *)&t_output[1], sizeof(t_output[1]));
230             }
231             else
232 #endif
233             {
234                 *output++ = t_output[0];
235                 *output++ = t_output[1];
236             }
237
238             /* save xor value for next round */
239             xor_0 = t_output[0] ^ t_input[0];
240             xor_1 = t_output[1] ^ t_input[1];
241
242 #ifdef DEBUG
243             if (des_debug)
244                 des_debug_print("clear",i,t_output[0],t_output[1]);
245 #endif
246         }
247         return 0;
248     }
249 }