← Back to branch summary

~clint-fewbar/ubuntu/precise/squid3/ignore-sighup-early

« back to all changes in this revision

Viewing changes to helpers/ntlm_auth/smb_lm/smbval/md4.c

  • Committer: Bazaar Package Importer
  • Author(s): Luigi Gangitano
  • Date: 2009-09-24 14:51:06 UTC
  • mfrom: (1.1.12 upstream)
  • mto: (20.2.1 sid)
  • mto: This revision was merged to the branch mainline in revision 21.
  • Revision ID: james.westby@ubuntu.com-20090924145106-38jgrzmj0d73pha5
Tags: 3.1.0.13-1
http://bugs.debian.org/523943
http://bugs.debian.org/432351
* Upload to experimental

* New upstream release
  - Fixes Follow-X-Forwarded-For support (Closes: #523943)
  - Adds IPv6 support (Closes: #432351)

* debian/rules
  - Removed obsolete configuration options
  - Enable db and radius basic authentication modules

* debian/patches/01-cf.data.debian
  - Adapted to new upstream version

* debian/patches/02-makefile-defaults
  - Adapted to new upstream version

* debian/{squid.postinst,squid.rc,README.Debian,watch}
  - Updated references to squid 3.1

* debian/squid3.install
  - Install CSS file for error pages
  - Install manual pages for new authentication modules

* debian/squid3-common.install
  - Install documented version of configuration file in /usr/share/doc/squid3

Show diffs side-by-side

added added

removed removed

Lines of Context:
helpers/ntlm_auth/smb_lm/smbval/md4.c
 
1
/*
 
2
 * Unix SMB/Netbios implementation.
 
3
 * Version 1.9.
 
4
 * a implementation of MD4 designed for use in the SMB authentication protocol
 
5
 * Copyright (C) Andrew Tridgell 1997
 
6
 *
 
7
 * This program is free software; you can redistribute it and/or modify
 
8
 * it under the terms of the GNU General Public License as published by
 
9
 * the Free Software Foundation; either version 2 of the License, or
 
10
 * (at your option) any later version.
 
11
 *
 
12
 * This program is distributed in the hope that it will be useful,
 
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
 * GNU General Public License for more details.
 
16
 *
 
17
 * You should have received a copy of the GNU General Public License
 
18
 * along with this program; if not, write to the Free Software
 
19
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
20
 */
 
21
 
 
22
 
 
23
/* NOTE: This code makes no attempt to be fast!
 
24
 *
 
25
 * It assumes that a int is at least 32 bits long
 
26
 */
 
27
#include <string.h>
 
28
#include "std-defines.h"        /* for the types */
 
29
#include "md4.h"
 
30
 
 
31
static uint32 A, B, C, D;
 
32
 
 
33
static uint32
 
34
F(uint32 X, uint32 Y, uint32 Z)
 
35
{
 
36
    return (X & Y) | ((~X) & Z);
 
37
}
 
38
 
 
39
static uint32
 
40
G(uint32 X, uint32 Y, uint32 Z)
 
41
{
 
42
    return (X & Y) | (X & Z) | (Y & Z);
 
43
}
 
44
 
 
45
static uint32
 
46
H(uint32 X, uint32 Y, uint32 Z)
 
47
{
 
48
    return X ^ Y ^ Z;
 
49
}
 
50
 
 
51
static uint32
 
52
lshift(uint32 x, int s)
 
53
{
 
54
    x &= 0xFFFFFFFF;
 
55
    return ((x << s) & 0xFFFFFFFF) | (x >> (32 - s));
 
56
}
 
57
 
 
58
#define ROUND1(a,b,c,d,k,s) a = lshift(a + F(b,c,d) + X[k], s)
 
59
#define ROUND2(a,b,c,d,k,s) a = lshift(a + G(b,c,d) + X[k] + (uint32)0x5A827999,s)
 
60
#define ROUND3(a,b,c,d,k,s) a = lshift(a + H(b,c,d) + X[k] + (uint32)0x6ED9EBA1,s)
 
61
 
 
62
/* this applies md4 to 64 byte chunks */
 
63
static void
 
64
mdfour64(uint32 * M)
 
65
{
 
66
    int j;
 
67
    uint32 AA, BB, CC, DD;
 
68
    uint32 X[16];
 
69
 
 
70
    for (j = 0; j < 16; j++)
 
71
        X[j] = M[j];
 
72
 
 
73
    AA = A;
 
74
    BB = B;
 
75
    CC = C;
 
76
    DD = D;
 
77
 
 
78
    ROUND1(A, B, C, D, 0, 3);
 
79
    ROUND1(D, A, B, C, 1, 7);
 
80
    ROUND1(C, D, A, B, 2, 11);
 
81
    ROUND1(B, C, D, A, 3, 19);
 
82
    ROUND1(A, B, C, D, 4, 3);
 
83
    ROUND1(D, A, B, C, 5, 7);
 
84
    ROUND1(C, D, A, B, 6, 11);
 
85
    ROUND1(B, C, D, A, 7, 19);
 
86
    ROUND1(A, B, C, D, 8, 3);
 
87
    ROUND1(D, A, B, C, 9, 7);
 
88
    ROUND1(C, D, A, B, 10, 11);
 
89
    ROUND1(B, C, D, A, 11, 19);
 
90
    ROUND1(A, B, C, D, 12, 3);
 
91
    ROUND1(D, A, B, C, 13, 7);
 
92
    ROUND1(C, D, A, B, 14, 11);
 
93
    ROUND1(B, C, D, A, 15, 19);
 
94
 
 
95
    ROUND2(A, B, C, D, 0, 3);
 
96
    ROUND2(D, A, B, C, 4, 5);
 
97
    ROUND2(C, D, A, B, 8, 9);
 
98
    ROUND2(B, C, D, A, 12, 13);
 
99
    ROUND2(A, B, C, D, 1, 3);
 
100
    ROUND2(D, A, B, C, 5, 5);
 
101
    ROUND2(C, D, A, B, 9, 9);
 
102
    ROUND2(B, C, D, A, 13, 13);
 
103
    ROUND2(A, B, C, D, 2, 3);
 
104
    ROUND2(D, A, B, C, 6, 5);
 
105
    ROUND2(C, D, A, B, 10, 9);
 
106
    ROUND2(B, C, D, A, 14, 13);
 
107
    ROUND2(A, B, C, D, 3, 3);
 
108
    ROUND2(D, A, B, C, 7, 5);
 
109
    ROUND2(C, D, A, B, 11, 9);
 
110
    ROUND2(B, C, D, A, 15, 13);
 
111
 
 
112
    ROUND3(A, B, C, D, 0, 3);
 
113
    ROUND3(D, A, B, C, 8, 9);
 
114
    ROUND3(C, D, A, B, 4, 11);
 
115
    ROUND3(B, C, D, A, 12, 15);
 
116
    ROUND3(A, B, C, D, 2, 3);
 
117
    ROUND3(D, A, B, C, 10, 9);
 
118
    ROUND3(C, D, A, B, 6, 11);
 
119
    ROUND3(B, C, D, A, 14, 15);
 
120
    ROUND3(A, B, C, D, 1, 3);
 
121
    ROUND3(D, A, B, C, 9, 9);
 
122
    ROUND3(C, D, A, B, 5, 11);
 
123
    ROUND3(B, C, D, A, 13, 15);
 
124
    ROUND3(A, B, C, D, 3, 3);
 
125
    ROUND3(D, A, B, C, 11, 9);
 
126
    ROUND3(C, D, A, B, 7, 11);
 
127
    ROUND3(B, C, D, A, 15, 15);
 
128
 
 
129
    A += AA;
 
130
    B += BB;
 
131
    C += CC;
 
132
    D += DD;
 
133
 
 
134
    A &= 0xFFFFFFFF;
 
135
    B &= 0xFFFFFFFF;
 
136
    C &= 0xFFFFFFFF;
 
137
    D &= 0xFFFFFFFF;
 
138
 
 
139
    for (j = 0; j < 16; j++)
 
140
        X[j] = 0;
 
141
}
 
142
 
 
143
static void
 
144
copy64(uint32 * M, unsigned char *in)
 
145
{
 
146
    int i;
 
147
 
 
148
    for (i = 0; i < 16; i++)
 
149
        M[i] = (in[i * 4 + 3] << 24) | (in[i * 4 + 2] << 16) |
 
150
               (in[i * 4 + 1] << 8) | (in[i * 4 + 0] << 0);
 
151
}
 
152
 
 
153
static void
 
154
copy4(unsigned char *out, uint32 x)
 
155
{
 
156
    out[0] = x & 0xFF;
 
157
    out[1] = (x >> 8) & 0xFF;
 
158
    out[2] = (x >> 16) & 0xFF;
 
159
    out[3] = (x >> 24) & 0xFF;
 
160
}
 
161
 
 
162
/* produce a md4 message digest from data of length n bytes */
 
163
void
 
164
mdfour(unsigned char *out, unsigned char *in, int n)
 
165
{
 
166
    unsigned char buf[128];
 
167
    uint32 M[16];
 
168
    uint32 b = n * 8;
 
169
    int i;
 
170
 
 
171
    A = 0x67452301;
 
172
    B = 0xefcdab89;
 
173
    C = 0x98badcfe;
 
174
    D = 0x10325476;
 
175
 
 
176
    while (n > 64) {
 
177
        copy64(M, in);
 
178
        mdfour64(M);
 
179
        in += 64;
 
180
        n -= 64;
 
181
    }
 
182
 
 
183
    for (i = 0; i < 128; i++)
 
184
        buf[i] = 0;
 
185
    memcpy(buf, in, n);
 
186
    buf[n] = 0x80;
 
187
 
 
188
    if (n <= 55) {
 
189
        copy4(buf + 56, b);
 
190
        copy64(M, buf);
 
191
        mdfour64(M);
 
192
    } else {
 
193
        copy4(buf + 120, b);
 
194
        copy64(M, buf);
 
195
        mdfour64(M);
 
196
        copy64(M, buf + 64);
 
197
        mdfour64(M);
 
198
    }
 
199
 
 
200
    for (i = 0; i < 128; i++)
 
201
        buf[i] = 0;
 
202
    copy64(M, buf);
 
203
 
 
204
    copy4(out, A);
 
205
    copy4(out + 4, B);
 
206
    copy4(out + 8, C);
 
207
    copy4(out + 12, D);
 
208
 
 
209
    A = B = C = D = 0;
 
210
}