locks: add lock cancel command
[linux-2.6] / fs / cifs / smbdes.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 1.9.
4
5    a partial implementation of DES designed for use in the 
6    SMB authentication protocol
7
8    Copyright (C) Andrew Tridgell 1998
9    Modified by Steve French (sfrench@us.ibm.com) 2002,2004
10    
11    This program is free software; you can redistribute it and/or modify
12    it under the terms of the GNU General Public License as published by
13    the Free Software Foundation; either version 2 of the License, or
14    (at your option) any later version.
15    
16    This program is distributed in the hope that it will be useful,
17    but WITHOUT ANY WARRANTY; without even the implied warranty of
18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19    GNU General Public License for more details.
20    
21    You should have received a copy of the GNU General Public License
22    along with this program; if not, write to the Free Software
23    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 */
25
26 /* NOTES: 
27
28    This code makes no attempt to be fast! In fact, it is a very
29    slow implementation 
30
31    This code is NOT a complete DES implementation. It implements only
32    the minimum necessary for SMB authentication, as used by all SMB
33    products (including every copy of Microsoft Windows95 ever sold)
34
35    In particular, it can only do a unchained forward DES pass. This
36    means it is not possible to use this code for encryption/decryption
37    of data, instead it is only useful as a "hash" algorithm.
38
39    There is no entry point into this code that allows normal DES operation.
40
41    I believe this means that this code does not come under ITAR
42    regulations but this is NOT a legal opinion. If you are concerned
43    about the applicability of ITAR regulations to this code then you
44    should confirm it for yourself (and maybe let me know if you come
45    up with a different answer to the one above)
46 */
47 #include <linux/slab.h>
48 #include "cifsencrypt.h"
49 #define uchar unsigned char
50
51 static uchar perm1[56] = { 57, 49, 41, 33, 25, 17, 9,
52         1, 58, 50, 42, 34, 26, 18,
53         10, 2, 59, 51, 43, 35, 27,
54         19, 11, 3, 60, 52, 44, 36,
55         63, 55, 47, 39, 31, 23, 15,
56         7, 62, 54, 46, 38, 30, 22,
57         14, 6, 61, 53, 45, 37, 29,
58         21, 13, 5, 28, 20, 12, 4
59 };
60
61 static uchar perm2[48] = { 14, 17, 11, 24, 1, 5,
62         3, 28, 15, 6, 21, 10,
63         23, 19, 12, 4, 26, 8,
64         16, 7, 27, 20, 13, 2,
65         41, 52, 31, 37, 47, 55,
66         30, 40, 51, 45, 33, 48,
67         44, 49, 39, 56, 34, 53,
68         46, 42, 50, 36, 29, 32
69 };
70
71 static uchar perm3[64] = { 58, 50, 42, 34, 26, 18, 10, 2,
72         60, 52, 44, 36, 28, 20, 12, 4,
73         62, 54, 46, 38, 30, 22, 14, 6,
74         64, 56, 48, 40, 32, 24, 16, 8,
75         57, 49, 41, 33, 25, 17, 9, 1,
76         59, 51, 43, 35, 27, 19, 11, 3,
77         61, 53, 45, 37, 29, 21, 13, 5,
78         63, 55, 47, 39, 31, 23, 15, 7
79 };
80
81 static uchar perm4[48] = { 32, 1, 2, 3, 4, 5,
82         4, 5, 6, 7, 8, 9,
83         8, 9, 10, 11, 12, 13,
84         12, 13, 14, 15, 16, 17,
85         16, 17, 18, 19, 20, 21,
86         20, 21, 22, 23, 24, 25,
87         24, 25, 26, 27, 28, 29,
88         28, 29, 30, 31, 32, 1
89 };
90
91 static uchar perm5[32] = { 16, 7, 20, 21,
92         29, 12, 28, 17,
93         1, 15, 23, 26,
94         5, 18, 31, 10,
95         2, 8, 24, 14,
96         32, 27, 3, 9,
97         19, 13, 30, 6,
98         22, 11, 4, 25
99 };
100
101 static uchar perm6[64] = { 40, 8, 48, 16, 56, 24, 64, 32,
102         39, 7, 47, 15, 55, 23, 63, 31,
103         38, 6, 46, 14, 54, 22, 62, 30,
104         37, 5, 45, 13, 53, 21, 61, 29,
105         36, 4, 44, 12, 52, 20, 60, 28,
106         35, 3, 43, 11, 51, 19, 59, 27,
107         34, 2, 42, 10, 50, 18, 58, 26,
108         33, 1, 41, 9, 49, 17, 57, 25
109 };
110
111 static uchar sc[16] = { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };
112
113 static uchar sbox[8][4][16] = {
114         {{14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7},
115          {0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8},
116          {4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0},
117          {15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13}},
118
119         {{15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10},
120          {3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5},
121          {0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15},
122          {13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9}},
123
124         {{10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8},
125          {13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1},
126          {13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7},
127          {1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12}},
128
129         {{7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15},
130          {13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9},
131          {10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4},
132          {3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14}},
133
134         {{2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9},
135          {14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6},
136          {4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14},
137          {11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3}},
138
139         {{12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11},
140          {10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8},
141          {9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6},
142          {4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13}},
143
144         {{4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1},
145          {13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6},
146          {1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2},
147          {6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12}},
148
149         {{13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7},
150          {1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2},
151          {7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8},
152          {2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11}}
153 };
154
155 static void
156 permute(char *out, char *in, uchar * p, int n)
157 {
158         int i;
159         for (i = 0; i < n; i++)
160                 out[i] = in[p[i] - 1];
161 }
162
163 static void
164 lshift(char *d, int count, int n)
165 {
166         char out[64];
167         int i;
168         for (i = 0; i < n; i++)
169                 out[i] = d[(i + count) % n];
170         for (i = 0; i < n; i++)
171                 d[i] = out[i];
172 }
173
174 static void
175 concat(char *out, char *in1, char *in2, int l1, int l2)
176 {
177         while (l1--)
178                 *out++ = *in1++;
179         while (l2--)
180                 *out++ = *in2++;
181 }
182
183 static void
184 xor(char *out, char *in1, char *in2, int n)
185 {
186         int i;
187         for (i = 0; i < n; i++)
188                 out[i] = in1[i] ^ in2[i];
189 }
190
191 static void
192 dohash(char *out, char *in, char *key, int forw)
193 {
194         int i, j, k;
195         char *pk1;
196         char c[28];
197         char d[28];
198         char *cd;
199         char (*ki)[48];
200         char *pd1;
201         char l[32], r[32];
202         char *rl;
203
204         /* Have to reduce stack usage */
205         pk1 = kmalloc(56+56+64+64,GFP_KERNEL);
206         if(pk1 == NULL)
207                 return;
208
209         ki = kmalloc(16*48, GFP_KERNEL);
210         if(ki == NULL) {
211                 kfree(pk1);
212                 return;
213         }
214
215         cd = pk1 + 56;
216         pd1= cd  + 56;
217         rl = pd1 + 64;
218
219         permute(pk1, key, perm1, 56);
220
221         for (i = 0; i < 28; i++)
222                 c[i] = pk1[i];
223         for (i = 0; i < 28; i++)
224                 d[i] = pk1[i + 28];
225
226         for (i = 0; i < 16; i++) {
227                 lshift(c, sc[i], 28);
228                 lshift(d, sc[i], 28);
229
230                 concat(cd, c, d, 28, 28);
231                 permute(ki[i], cd, perm2, 48);
232         }
233
234         permute(pd1, in, perm3, 64);
235
236         for (j = 0; j < 32; j++) {
237                 l[j] = pd1[j];
238                 r[j] = pd1[j + 32];
239         }
240
241         for (i = 0; i < 16; i++) {
242                 char *er;  /* er[48]  */
243                 char *erk; /* erk[48] */
244                 char b[8][6];
245                 char *cb;  /* cb[32]  */
246                 char *pcb; /* pcb[32] */
247                 char *r2;  /* r2[32]  */
248
249                 er = kmalloc(48+48+32+32+32, GFP_KERNEL);
250                 if(er == NULL) {
251                         kfree(pk1);
252                         kfree(ki);
253                         return;
254                 }
255                 erk = er+48;
256                 cb  = erk+48;
257                 pcb = cb+32;
258                 r2  = pcb+32;
259
260                 permute(er, r, perm4, 48);
261
262                 xor(erk, er, ki[forw ? i : 15 - i], 48);
263
264                 for (j = 0; j < 8; j++)
265                         for (k = 0; k < 6; k++)
266                                 b[j][k] = erk[j * 6 + k];
267
268                 for (j = 0; j < 8; j++) {
269                         int m, n;
270                         m = (b[j][0] << 1) | b[j][5];
271
272                         n = (b[j][1] << 3) | (b[j][2] << 2) | (b[j][3] <<
273                                                                1) | b[j][4];
274
275                         for (k = 0; k < 4; k++)
276                                 b[j][k] =
277                                     (sbox[j][m][n] & (1 << (3 - k))) ? 1 : 0;
278                 }
279
280                 for (j = 0; j < 8; j++)
281                         for (k = 0; k < 4; k++)
282                                 cb[j * 4 + k] = b[j][k];
283                 permute(pcb, cb, perm5, 32);
284
285                 xor(r2, l, pcb, 32);
286
287                 for (j = 0; j < 32; j++)
288                         l[j] = r[j];
289
290                 for (j = 0; j < 32; j++)
291                         r[j] = r2[j];
292
293                 kfree(er);
294         }
295
296         concat(rl, r, l, 32, 32);
297
298         permute(out, rl, perm6, 64);
299         kfree(pk1);
300         kfree(ki);
301 }
302
303 static void
304 str_to_key(unsigned char *str, unsigned char *key)
305 {
306         int i;
307
308         key[0] = str[0] >> 1;
309         key[1] = ((str[0] & 0x01) << 6) | (str[1] >> 2);
310         key[2] = ((str[1] & 0x03) << 5) | (str[2] >> 3);
311         key[3] = ((str[2] & 0x07) << 4) | (str[3] >> 4);
312         key[4] = ((str[3] & 0x0F) << 3) | (str[4] >> 5);
313         key[5] = ((str[4] & 0x1F) << 2) | (str[5] >> 6);
314         key[6] = ((str[5] & 0x3F) << 1) | (str[6] >> 7);
315         key[7] = str[6] & 0x7F;
316         for (i = 0; i < 8; i++) {
317                 key[i] = (key[i] << 1);
318         }
319 }
320
321 static void
322 smbhash(unsigned char *out, unsigned char *in, unsigned char *key, int forw)
323 {
324         int i;
325         char *outb; /* outb[64] */
326         char *inb;  /* inb[64]  */
327         char *keyb; /* keyb[64] */
328         unsigned char key2[8];
329
330         outb = kmalloc(64 * 3,GFP_KERNEL);
331         if(outb == NULL)
332                 return;
333
334         inb  = outb + 64;
335         keyb = inb +  64;
336
337         str_to_key(key, key2);
338
339         for (i = 0; i < 64; i++) {
340                 inb[i] = (in[i / 8] & (1 << (7 - (i % 8)))) ? 1 : 0;
341                 keyb[i] = (key2[i / 8] & (1 << (7 - (i % 8)))) ? 1 : 0;
342                 outb[i] = 0;
343         }
344
345         dohash(outb, inb, keyb, forw);
346
347         for (i = 0; i < 8; i++) {
348                 out[i] = 0;
349         }
350
351         for (i = 0; i < 64; i++) {
352                 if (outb[i])
353                         out[i / 8] |= (1 << (7 - (i % 8)));
354         }
355         kfree(outb);
356 }
357
358 void
359 E_P16(unsigned char *p14, unsigned char *p16)
360 {
361         unsigned char sp8[8] =
362             { 0x4b, 0x47, 0x53, 0x21, 0x40, 0x23, 0x24, 0x25 };
363         smbhash(p16, sp8, p14, 1);
364         smbhash(p16 + 8, sp8, p14 + 7, 1);
365 }
366
367 void
368 E_P24(unsigned char *p21, unsigned char *c8, unsigned char *p24)
369 {
370         smbhash(p24, c8, p21, 1);
371         smbhash(p24 + 8, c8, p21 + 7, 1);
372         smbhash(p24 + 16, c8, p21 + 14, 1);
373 }
374
375 #if 0 /* currently unsued */
376 static void
377 D_P16(unsigned char *p14, unsigned char *in, unsigned char *out)
378 {
379         smbhash(out, in, p14, 0);
380         smbhash(out + 8, in + 8, p14 + 7, 0);
381 }
382
383 static void
384 E_old_pw_hash(unsigned char *p14, unsigned char *in, unsigned char *out)
385 {
386         smbhash(out, in, p14, 1);
387         smbhash(out + 8, in + 8, p14 + 7, 1);
388 }
389 /* these routines are currently unneeded, but may be
390         needed later */
391 void
392 cred_hash1(unsigned char *out, unsigned char *in, unsigned char *key)
393 {
394         unsigned char buf[8];
395
396         smbhash(buf, in, key, 1);
397         smbhash(out, buf, key + 9, 1);
398 }
399
400 void
401 cred_hash2(unsigned char *out, unsigned char *in, unsigned char *key)
402 {
403         unsigned char buf[8];
404         static unsigned char key2[8];
405
406         smbhash(buf, in, key, 1);
407         key2[0] = key[7];
408         smbhash(out, buf, key2, 1);
409 }
410
411 void
412 cred_hash3(unsigned char *out, unsigned char *in, unsigned char *key, int forw)
413 {
414         static unsigned char key2[8];
415
416         smbhash(out, in, key, forw);
417         key2[0] = key[7];
418         smbhash(out + 8, in + 8, key2, forw);
419 }
420 #endif /* unneeded routines */