begone-with-AFS-HIDE-20010327
[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 #include <stdio.h>
25 #include <des.h>
26 #include <afs/param.h>
27 #include "des_internal.h"
28
29 #define XPRT_PCBC_ENCRYPT
30 #include "../permit_xprt.h"
31
32 extern int des_debug;
33 extern int des_debug_print();
34
35 /*
36  * pcbc_encrypt is an "error propagation chaining" encrypt operation
37  * for DES, similar to CBC, but that, on encryption, "xor"s the
38  * plaintext of block N with the ciphertext resulting from block N,
39  * then "xor"s that result with the plaintext of block N+1 prior to
40  * encrypting block N+1. (decryption the appropriate inverse.  This
41  * "pcbc" mode propagates a single bit error anywhere in either the
42  * cleartext or ciphertext chain all the way through to the end. In
43  * contrast, CBC mode limits a single bit error in the ciphertext to
44  * affect only the current (8byte) block and the subsequent block.
45  *
46  * performs pcbc error-propagation chaining operation by xor-ing block
47  * N+1 with both the plaintext (block N) and the ciphertext from block
48  * N.  Either encrypts from cleartext to ciphertext, if encrypt != 0
49  * or decrypts from ciphertext to cleartext, if encrypt == 0
50  *
51  * NOTE-- the output is ALWAYS an multiple of 8 bytes long.  If not
52  * enough space was provided, your program will get trashed.
53  *
54  * For encryption, the cleartext string is null padded, at the end, to
55  * an integral multiple of eight bytes.
56  *
57  * For decryption, the ciphertext will be used in integral multiples
58  * of 8 bytes, but only the first "length" bytes returned into the
59  * cleartext.
60  *
61  * This is NOT a standard mode of operation.
62  *
63  */
64
65 afs_int32
66 des_pcbc_encrypt(in,out,length,key,iv,encrypt)
67     des_cblock *in;             /* >= length bytes of inputtext */
68     des_cblock *out;            /* >= length bytes of outputtext */
69     register afs_int32 length;  /* in bytes */
70     int encrypt;                /* 0 ==> decrypt, else encrypt */
71     des_key_schedule key;               /* precomputed key schedule */
72     des_cblock *iv;             /* 8 bytes of ivec */
73 {
74     register afs_uint32 *input = (afs_uint32 *) in;
75     register afs_uint32 *output = (afs_uint32 *) out;
76     register afs_uint32 *ivec = (afs_uint32 *) iv;
77
78     afs_uint32 i,j;
79     afs_uint32 t_input[2];
80     afs_uint32 t_output[2];
81     unsigned char *t_in_p = (unsigned char *) t_input;
82     afs_uint32 xor_0, xor_1;
83
84     if (encrypt) {
85 #ifdef MUSTALIGN
86         if ((afs_int32) ivec & 3) {
87             bcopy((char *)ivec++,(char *)&xor_0,sizeof(xor_0));
88             bcopy((char *)ivec,(char *)&xor_1,sizeof(xor_1));
89         }
90         else
91 #endif
92         {
93             xor_0 = *ivec++;
94             xor_1 = *ivec;
95         }
96
97         for (i = 0; length > 0; i++, length -= 8) {
98             /* get input */
99 #ifdef MUSTALIGN
100             if ((afs_int32) input & 3) {
101                 bcopy((char *)input,(char *)&t_input[0],sizeof(t_input[0]));
102                 bcopy((char *)(input+1),(char *)&t_input[1],sizeof(t_input[1]));
103             }
104             else
105 #endif
106             {
107                 t_input[0] = *input;
108                 t_input[1] = *(input+1);
109             }
110
111             /* zero pad */
112             if (length < 8) {
113                 for (j = length; j <= 7; j++)
114                     *(t_in_p+j)= 0;
115             }
116
117 #ifdef DEBUG
118             if (des_debug)
119                 des_debug_print("clear",length,t_input[0],t_input[1]);
120 #endif
121             /* do the xor for cbc into the temp */
122             t_input[0] ^= xor_0 ;
123             t_input[1] ^= xor_1 ;
124             /* encrypt */
125             (void) des_ecb_encrypt(t_input,t_output,key,encrypt);
126
127             /*
128              * We want to XOR with both the plaintext and ciphertext
129              * of the previous block, before we write the output, in
130              * case both input and output are the same space.
131              */
132 #ifdef MUSTALIGN
133             if ((afs_int32) input & 3) {
134                 bcopy((char *)input++,(char *)&xor_0,sizeof(xor_0));
135                 xor_0 ^= t_output[0];
136                 bcopy((char *)input++,(char *)&xor_1,sizeof(xor_1));
137                 xor_1 ^= t_output[1];
138             }
139             else
140 #endif
141             {
142                 xor_0 = *input++ ^ t_output[0];
143                 xor_1 = *input++ ^ t_output[1];
144             }
145
146
147             /* copy temp output and save it for cbc */
148 #ifdef MUSTALIGN
149             if ((afs_int32) output & 3) {
150                 bcopy((char *)&t_output[0],(char *)output++,
151                       sizeof(t_output[0]));
152                 bcopy((char *)&t_output[1],(char *)output++,
153                       sizeof(t_output[1]));
154             }
155             else
156 #endif
157             {
158                 *output++ = t_output[0];
159                 *output++ = t_output[1];
160             }
161
162 #ifdef DEBUG
163             if (des_debug) {
164                 des_debug_print("xor'ed",i,t_input[0],t_input[1]);
165                 des_debug_print("cipher",i,t_output[0],t_output[1]);
166             }
167 #endif
168         }
169         t_output[0] = 0;
170         t_output[1] = 0;
171         xor_0 = 0;
172         xor_1 = 0;
173         return 0;
174     }
175
176     else {
177         /* decrypt */
178 #ifdef MUSTALIGN
179         if ((afs_int32) ivec & 3) {
180             bcopy((char *)ivec++,(char *)&xor_0,sizeof(xor_0));
181             bcopy((char *)ivec,(char *)&xor_1,sizeof(xor_1));
182         }
183         else
184 #endif
185         {
186             xor_0 = *ivec++;
187             xor_1 = *ivec;
188         }
189
190         for (i = 0; length > 0; i++, length -= 8) {
191             /* get input */
192 #ifdef MUSTALIGN
193             if ((afs_int32) input & 3) {
194                 bcopy((char *)input++,(char *)&t_input[0],sizeof(t_input[0]));
195                 bcopy((char *)input++,(char *)&t_input[1],sizeof(t_input[1]));
196             }
197             else
198 #endif
199             {
200                 t_input[0] = *input++;
201                 t_input[1] = *input++;
202             }
203
204             /* no padding for decrypt */
205 #ifdef DEBUG
206             if (des_debug)
207                 des_debug_print("cipher",i,t_input[0],t_input[1]);
208 #else
209 #ifdef lint
210             i = i;
211 #endif
212 #endif
213             /* encrypt */
214             (void) des_ecb_encrypt(t_input,t_output,key,encrypt);
215 #ifdef DEBUG
216             if (des_debug)
217                 des_debug_print("out pre xor",i,t_output[0],t_output[1]);
218 #endif
219             /* do the xor for cbc into the output */
220             t_output[0] ^= xor_0 ;
221             t_output[1] ^= xor_1 ;
222             /* copy temp output */
223 #ifdef MUSTALIGN
224             if ((afs_int32) output & 3) {
225                 bcopy((char *)&t_output[0],(char *)output++,
226                       sizeof(t_output[0]));
227                 bcopy((char *)&t_output[1],(char *)output++,
228                       sizeof(t_output[1]));
229             }
230             else
231 #endif
232             {
233                 *output++ = t_output[0];
234                 *output++ = t_output[1];
235             }
236
237             /* save xor value for next round */
238             xor_0 = t_output[0] ^ t_input[0];
239             xor_1 = t_output[1] ^ t_input[1];
240
241 #ifdef DEBUG
242             if (des_debug)
243                 des_debug_print("clear",i,t_output[0],t_output[1]);
244 #endif
245         }
246         return 0;
247     }
248 }