← Back to branch summary

~ubuntu-branches/ubuntu/hardy/openswan/hardy-updates

« back to all changes in this revision

Viewing changes to debian/openswan-modules-source-build/modules/openswan/linux/net/ipsec/ipsec_sha1.c

  • Committer: Bazaar Package Importer
  • Author(s): Rene Mayrhofer
  • Date: 2005-01-27 16:10:11 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20050127161011-idgybmyz3vwhpfiq
Tags: 2.3.0-2
http://bugs.debian.org/292458
http://bugs.debian.org/291143
Urgency HIGH due to security issue and problems with build-deps in sarge.
* Fix the security issue. Please see
  http://www.idefense.com/application/poi/display?id=190&
      type=vulnerabilities&flashstatus=false
  for more details. Thanks to Martin Schulze for informing me about
  this issue.
  Closes: #292458: Openswan XAUTH/PAM Buffer Overflow Vulnerability
* Added a Build-Dependency to lynx.
  Closes: #291143: openswan: FTBFS: Missing build dependency.

Show diffs side-by-side

added added

removed removed

Lines of Context:
debian/openswan-modules-source-build/modules/openswan/linux/net/ipsec/ipsec_sha1.c
1
 
/*
2
 
 * RCSID $Id: ipsec_sha1.c,v 1.8 2002/09/10 01:45:14 mcr Exp $
3
 
 */
4
 
 
5
 
/*
6
 
 * The rest of the code is derived from sha1.c by Steve Reid, which is
7
 
 * public domain.
8
 
 * Minor cosmetic changes to accomodate it in the Linux kernel by ji.
9
 
 */
10
 
 
11
 
#include <asm/byteorder.h>
12
 
#include <linux/string.h>
13
 
 
14
 
#include "freeswan/ipsec_sha1.h"
15
 
 
16
 
#if defined(rol)
17
 
#undef rol
18
 
#endif
19
 
 
20
 
#define SHA1HANDSOFF
21
 
 
22
 
#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
23
 
 
24
 
/* blk0() and blk() perform the initial expand. */
25
 
/* I got the idea of expanding during the round function from SSLeay */
26
 
#ifdef __LITTLE_ENDIAN
27
 
#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
28
 
    |(rol(block->l[i],8)&0x00FF00FF))
29
 
#else
30
 
#define blk0(i) block->l[i]
31
 
#endif
32
 
#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
33
 
    ^block->l[(i+2)&15]^block->l[i&15],1))
34
 
 
35
 
/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
36
 
#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
37
 
#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
38
 
#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
39
 
#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
40
 
#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
41
 
 
42
 
 
43
 
/* Hash a single 512-bit block. This is the core of the algorithm. */
44
 
 
45
 
void SHA1Transform(__u32 state[5], __u8 buffer[64])
46
 
{
47
 
__u32 a, b, c, d, e;
48
 
typedef union {
49
 
    unsigned char c[64];
50
 
    __u32 l[16];
51
 
} CHAR64LONG16;
52
 
CHAR64LONG16* block;
53
 
#ifdef SHA1HANDSOFF
54
 
static unsigned char workspace[64];
55
 
    block = (CHAR64LONG16*)workspace;
56
 
    memcpy(block, buffer, 64);
57
 
#else
58
 
    block = (CHAR64LONG16*)buffer;
59
 
#endif
60
 
    /* Copy context->state[] to working vars */
61
 
    a = state[0];
62
 
    b = state[1];
63
 
    c = state[2];
64
 
    d = state[3];
65
 
    e = state[4];
66
 
    /* 4 rounds of 20 operations each. Loop unrolled. */
67
 
    R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
68
 
    R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
69
 
    R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
70
 
    R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
71
 
    R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
72
 
    R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
73
 
    R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
74
 
    R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
75
 
    R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
76
 
    R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
77
 
    R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
78
 
    R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
79
 
    R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
80
 
    R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
81
 
    R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
82
 
    R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
83
 
    R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
84
 
    R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
85
 
    R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
86
 
    R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
87
 
    /* Add the working vars back into context.state[] */
88
 
    state[0] += a;
89
 
    state[1] += b;
90
 
    state[2] += c;
91
 
    state[3] += d;
92
 
    state[4] += e;
93
 
    /* Wipe variables */
94
 
    a = b = c = d = e = 0;
95
 
}
96
 
 
97
 
 
98
 
/* SHA1Init - Initialize new context */
99
 
 
100
 
void SHA1Init(void *vcontext)
101
 
{
102
 
    SHA1_CTX* context = vcontext;
103
 
 
104
 
    /* SHA1 initialization constants */
105
 
    context->state[0] = 0x67452301;
106
 
    context->state[1] = 0xEFCDAB89;
107
 
    context->state[2] = 0x98BADCFE;
108
 
    context->state[3] = 0x10325476;
109
 
    context->state[4] = 0xC3D2E1F0;
110
 
    context->count[0] = context->count[1] = 0;
111
 
}
112
 
 
113
 
 
114
 
/* Run your data through this. */
115
 
 
116
 
void SHA1Update(void *vcontext, unsigned char* data, __u32 len)
117
 
{
118
 
    SHA1_CTX* context = vcontext;
119
 
    __u32 i, j;
120
 
 
121
 
    j = context->count[0];
122
 
    if ((context->count[0] += len << 3) < j)
123
 
        context->count[1]++;
124
 
    context->count[1] += (len>>29);
125
 
    j = (j >> 3) & 63;
126
 
    if ((j + len) > 63) {
127
 
        memcpy(&context->buffer[j], data, (i = 64-j));
128
 
        SHA1Transform(context->state, context->buffer);
129
 
        for ( ; i + 63 < len; i += 64) {
130
 
            SHA1Transform(context->state, &data[i]);
131
 
        }
132
 
        j = 0;
133
 
    }
134
 
    else i = 0;
135
 
    memcpy(&context->buffer[j], &data[i], len - i);
136
 
}
137
 
 
138
 
 
139
 
/* Add padding and return the message digest. */
140
 
 
141
 
void SHA1Final(unsigned char digest[20], void *vcontext)
142
 
{
143
 
  __u32 i, j;
144
 
  unsigned char finalcount[8];
145
 
  SHA1_CTX* context = vcontext;
146
 
    
147
 
    for (i = 0; i < 8; i++) {
148
 
        finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)]
149
 
         >> ((3-(i & 3)) * 8) ) & 255);  /* Endian independent */
150
 
    }
151
 
    SHA1Update(context, (unsigned char *)"\200", 1);
152
 
    while ((context->count[0] & 504) != 448) {
153
 
        SHA1Update(context, (unsigned char *)"\0", 1);
154
 
    }
155
 
    SHA1Update(context, finalcount, 8);  /* Should cause a SHA1Transform() */
156
 
    for (i = 0; i < 20; i++) {
157
 
        digest[i] = (unsigned char)
158
 
         ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
159
 
    }
160
 
    /* Wipe variables */
161
 
    i = j = 0;
162
 
    memset(context->buffer, 0, 64);
163
 
    memset(context->state, 0, 20);
164
 
    memset(context->count, 0, 8);
165
 
    memset(&finalcount, 0, 8);
166
 
#ifdef SHA1HANDSOFF  /* make SHA1Transform overwrite its own static vars */
167
 
    SHA1Transform(context->state, context->buffer);
168
 
#endif
169
 
}
170
 
 
171
 
 
172
 
/*
173
 
 * $Log: ipsec_sha1.c,v $
174
 
 * Revision 1.8  2002/09/10 01:45:14  mcr
175
 
 *      changed type of MD5_CTX and SHA1_CTX to void * so that
176
 
 *      the function prototypes would match, and could be placed
177
 
 *      into a pointer to a function.
178
 
 *
179
 
 * Revision 1.7  2002/04/24 07:55:32  mcr
180
 
 *      #include patches and Makefiles for post-reorg compilation.
181
 
 *
182
 
 * Revision 1.6  2002/04/24 07:36:30  mcr
183
 
 * Moved from ./klips/net/ipsec/ipsec_sha1.c,v
184
 
 *
185
 
 * Revision 1.5  1999/12/13 13:59:13  rgb
186
 
 * Quick fix to argument size to Update bugs.
187
 
 *
188
 
 * Revision 1.4  1999/04/11 00:29:00  henry
189
 
 * GPL boilerplate
190
 
 *
191
 
 * Revision 1.3  1999/04/06 04:54:27  rgb
192
 
 * Fix/Add RCSID Id: and Log: bits to make PHMDs happy.  This includes
193
 
 * patch shell fixes.
194
 
 *
195
 
 * Revision 1.2  1999/01/22 06:55:50  rgb
196
 
 * 64-bit clean-up.
197
 
 *
198
 
 * Revision 1.1  1998/06/18 21:27:50  henry
199
 
 * move sources from klips/src to klips/net/ipsec, to keep stupid
200
 
 * kernel-build scripts happier in the presence of symlinks
201
 
 *
202
 
 * Revision 1.2  1998/04/23 20:54:04  rgb
203
 
 * Fixed md5 and sha1 include file nesting issues, to be cleaned up when
204
 
 * verified.
205
 
 *
206
 
 * Revision 1.1  1998/04/09 03:06:11  henry
207
 
 * sources moved up from linux/net/ipsec
208
 
 *
209
 
 * Revision 1.1.1.1  1998/04/08 05:35:05  henry
210
 
 * RGB's ipsec-0.8pre2.tar.gz ipsec-0.8
211
 
 *
212
 
 * Revision 0.4  1997/01/15 01:28:15  ji
213
 
 * New transform
214
 
 *
215
 
 *
216
 
 */