Anope IRC Services  Version 1.8
enc_old.c
Go to the documentation of this file.
1 /* Include file for high-level encryption routines.
2  *
3  * (C) 2003-2014 Anope Team
4  * Contact us at team@anope.org
5  *
6  * Please read COPYING and README for further details.
7  *
8  * Based on the original code of Epona by Lara.
9  * Based on the original code of Services by Andy Church.
10  *
11  *
12  */
13 
14 #include "module.h"
15 
16 static void my_binary_to_hex(unsigned char *bin, char *hex, int length)
17 {
18  static const char trans[] = "0123456789ABCDEF";
19  int i;
20 
21  for(i = 0; i < length; i++)
22  {
23  hex[i << 1] = trans[bin[i] >> 4];
24  hex[(i << 1) + 1] = trans[bin[i] & 0xf];
25  }
26 
27  hex[i << 1] = '\0';
28 }
29 
30 
31 /*************************************************************************/
32 
33 /******** Code specific to the type of encryption. ********/
34 
35 
36 /* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
37 rights reserved.
38 
39 License to copy and use this software is granted provided that it
40 is identified as the "RSA Data Security, Inc. MD5 Message-Digest
41 Algorithm" in all material mentioning or referencing this software
42 or this function.
43 
44 License is also granted to make and use derivative works provided
45 that such works are identified as "derived from the RSA Data
46 Security, Inc. MD5 Message-Digest Algorithm" in all material
47 mentioning or referencing the derived work.
48 
49 RSA Data Security, Inc. makes no representations concerning either
50 the merchantability of this software or the suitability of this
51 software for any particular purpose. It is provided "as is"
52 without express or implied warranty of any kind.
53 
54 These notices must be retained in any copies of any part of this
55 documentation and/or software.
56  */
57 
58 #include <string.h>
59 
60 typedef unsigned int UINT4;
61 
62 /* MD5 context. */
63 typedef struct {
64  UINT4 state[4]; /* state (ABCD) */
65  UINT4 count[2]; /* number of bits, modulo 2^64 (lsb first) */
66  unsigned char buffer[64]; /* input buffer */
67 } MD5_CTX;
68 
69 /* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
70  */
71 
72 typedef void *POINTER;
73 
74 /* Constants for MD5Transform routine.
75  */
76 #define S11 7
77 #define S12 12
78 #define S13 17
79 #define S14 22
80 #define S21 5
81 #define S22 9
82 #define S23 14
83 #define S24 20
84 #define S31 4
85 #define S32 11
86 #define S33 16
87 #define S34 23
88 #define S41 6
89 #define S42 10
90 #define S43 15
91 #define S44 21
92 
93 static void MD5Transform(UINT4[4], unsigned char[64]);
94 static void Encode(unsigned char *, UINT4 *, unsigned int);
95 static void Decode(UINT4 *, unsigned char *, unsigned int);
96 
97 static unsigned char PADDING[64] = {
98  0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
99  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
100  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
101 };
102 
103 /* F, G, H and I are basic MD5 functions.
104  */
105 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
106 #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
107 #define H(x, y, z) ((x) ^ (y) ^ (z))
108 #define MD5_I(x, y, z) ((y) ^ ((x) | (~z)))
109 
110 /* ROTATE_LEFT rotates x left n bits.
111  */
112 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
113 
114 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
115 Rotation is separate from addition to prevent recomputation.
116  */
117 #define FF(a, b, c, d, x, s, ac) { \
118  (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
119  (a) = ROTATE_LEFT ((a), (s)); \
120  (a) += (b); \
121  }
122 #define GG(a, b, c, d, x, s, ac) { \
123  (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
124  (a) = ROTATE_LEFT ((a), (s)); \
125  (a) += (b); \
126  }
127 #define HH(a, b, c, d, x, s, ac) { \
128  (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
129  (a) = ROTATE_LEFT ((a), (s)); \
130  (a) += (b); \
131  }
132 #define II(a, b, c, d, x, s, ac) { \
133  (a) += MD5_I ((b), (c), (d)) + (x) + (UINT4)(ac); \
134  (a) = ROTATE_LEFT ((a), (s)); \
135  (a) += (b); \
136  }
137 
138 /* MD5 initialization. Begins an MD5 operation, writing a new context.
139  */
140 static void MD5Init(context)
141 MD5_CTX *context; /* context */
142 {
143  context->count[0] = context->count[1] = 0;
144  /* Load magic initialization constants.
145  */
146  context->state[0] = 0x67452301;
147  context->state[1] = 0xefcdab89;
148  context->state[2] = 0x98badcfe;
149  context->state[3] = 0x10325476;
150 }
151 
152 /* MD5 block update operation. Continues an MD5 message-digest
153  operation, processing another message block, and updating the
154  context.
155  */
156 static void MD5Update(context, input, inputLen)
157 MD5_CTX *context; /* context */
158 unsigned char *input; /* input block */
159 unsigned int inputLen; /* length of input block */
160 {
161  unsigned int i, index, partLen;
162 
163  /* Compute number of bytes mod 64 */
164  index = (unsigned int) ((context->count[0] >> 3) & 0x3F);
165 
166  /* Update number of bits */
167  if ((context->count[0] += ((UINT4) inputLen << 3))
168  < ((UINT4) inputLen << 3))
169  context->count[1]++;
170  context->count[1] += ((UINT4) inputLen >> 29);
171 
172  partLen = 64 - index;
173 
174  /* Transform as many times as possible.
175  */
176  if (inputLen >= partLen) {
177  memcpy
178  ((POINTER) & context->buffer[index], (POINTER) input, partLen);
179  MD5Transform(context->state, context->buffer);
180 
181  for (i = partLen; i + 63 < inputLen; i += 64)
182  MD5Transform(context->state, &input[i]);
183 
184  index = 0;
185  } else
186  i = 0;
187 
188  /* Buffer remaining input */
189  memcpy
190  ((POINTER) & context->buffer[index], (POINTER) & input[i],
191  inputLen - i);
192 }
193 
194 /* MD5 finalization. Ends an MD5 message-digest operation, writing the
195  the message digest and zeroizing the context.
196  */
197 static void MD5Final(digest, context)
198 unsigned char digest[16]; /* message digest */
199 MD5_CTX *context; /* context */
200 {
201  unsigned char bits[8];
202  unsigned int index, padLen;
203 
204  /* Save number of bits */
205  Encode(bits, context->count, 8);
206 
207  /* Pad out to 56 mod 64.
208  */
209  index = (unsigned int) ((context->count[0] >> 3) & 0x3f);
210  padLen = (index < 56) ? (56 - index) : (120 - index);
211  MD5Update(context, PADDING, padLen);
212 
213  /* Append length (before padding) */
214  MD5Update(context, bits, 8);
215  /* Store state in digest */
216  Encode(digest, context->state, 16);
217 
218  /* Zeroize sensitive information.
219  */
220  memset((POINTER) context, 0, sizeof(*context));
221 }
222 
223 /* MD5 basic transformation. Transforms state based on block.
224  */
225 static void MD5Transform(state, block)
226 UINT4 state[4];
227 unsigned char block[64];
228 {
229  UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
230 
231  Decode(x, block, 64);
232 
233  /* Round 1 */
234  FF(a, b, c, d, x[0], S11, 0xd76aa478); /* 1 */
235  FF(d, a, b, c, x[1], S12, 0xe8c7b756); /* 2 */
236  FF(c, d, a, b, x[2], S13, 0x242070db); /* 3 */
237  FF(b, c, d, a, x[3], S14, 0xc1bdceee); /* 4 */
238  FF(a, b, c, d, x[4], S11, 0xf57c0faf); /* 5 */
239  FF(d, a, b, c, x[5], S12, 0x4787c62a); /* 6 */
240  FF(c, d, a, b, x[6], S13, 0xa8304613); /* 7 */
241  FF(b, c, d, a, x[7], S14, 0xfd469501); /* 8 */
242  FF(a, b, c, d, x[8], S11, 0x698098d8); /* 9 */
243  FF(d, a, b, c, x[9], S12, 0x8b44f7af); /* 10 */
244  FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
245  FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
246  FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
247  FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
248  FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
249  FF(b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
250 
251  /* Round 2 */
252  GG(a, b, c, d, x[1], S21, 0xf61e2562); /* 17 */
253  GG(d, a, b, c, x[6], S22, 0xc040b340); /* 18 */
254  GG(c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
255  GG(b, c, d, a, x[0], S24, 0xe9b6c7aa); /* 20 */
256  GG(a, b, c, d, x[5], S21, 0xd62f105d); /* 21 */
257  GG(d, a, b, c, x[10], S22, 0x2441453); /* 22 */
258  GG(c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
259  GG(b, c, d, a, x[4], S24, 0xe7d3fbc8); /* 24 */
260  GG(a, b, c, d, x[9], S21, 0x21e1cde6); /* 25 */
261  GG(d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
262  GG(c, d, a, b, x[3], S23, 0xf4d50d87); /* 27 */
263  GG(b, c, d, a, x[8], S24, 0x455a14ed); /* 28 */
264  GG(a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
265  GG(d, a, b, c, x[2], S22, 0xfcefa3f8); /* 30 */
266  GG(c, d, a, b, x[7], S23, 0x676f02d9); /* 31 */
267  GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
268 
269  /* Round 3 */
270  HH(a, b, c, d, x[5], S31, 0xfffa3942); /* 33 */
271  HH(d, a, b, c, x[8], S32, 0x8771f681); /* 34 */
272  HH(c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
273  HH(b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
274  HH(a, b, c, d, x[1], S31, 0xa4beea44); /* 37 */
275  HH(d, a, b, c, x[4], S32, 0x4bdecfa9); /* 38 */
276  HH(c, d, a, b, x[7], S33, 0xf6bb4b60); /* 39 */
277  HH(b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
278  HH(a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
279  HH(d, a, b, c, x[0], S32, 0xeaa127fa); /* 42 */
280  HH(c, d, a, b, x[3], S33, 0xd4ef3085); /* 43 */
281  HH(b, c, d, a, x[6], S34, 0x4881d05); /* 44 */
282  HH(a, b, c, d, x[9], S31, 0xd9d4d039); /* 45 */
283  HH(d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
284  HH(c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
285  HH(b, c, d, a, x[2], S34, 0xc4ac5665); /* 48 */
286 
287  /* Round 4 */
288  II(a, b, c, d, x[0], S41, 0xf4292244); /* 49 */
289  II(d, a, b, c, x[7], S42, 0x432aff97); /* 50 */
290  II(c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
291  II(b, c, d, a, x[5], S44, 0xfc93a039); /* 52 */
292  II(a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
293  II(d, a, b, c, x[3], S42, 0x8f0ccc92); /* 54 */
294  II(c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
295  II(b, c, d, a, x[1], S44, 0x85845dd1); /* 56 */
296  II(a, b, c, d, x[8], S41, 0x6fa87e4f); /* 57 */
297  II(d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
298  II(c, d, a, b, x[6], S43, 0xa3014314); /* 59 */
299  II(b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
300  II(a, b, c, d, x[4], S41, 0xf7537e82); /* 61 */
301  II(d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
302  II(c, d, a, b, x[2], S43, 0x2ad7d2bb); /* 63 */
303  II(b, c, d, a, x[9], S44, 0xeb86d391); /* 64 */
304 
305  state[0] += a;
306  state[1] += b;
307  state[2] += c;
308  state[3] += d;
309 
310  /* Zeroize sensitive information.
311  */
312  memset((POINTER) x, 0, sizeof(x));
313 }
314 
315 /* Encodes input (UINT4) into output (unsigned char). Assumes len is
316  a multiple of 4.
317  */
318 static void Encode(output, input, len)
319 unsigned char *output;
320 UINT4 *input;
321 unsigned int len;
322 {
323  unsigned int i, j;
324 
325  for (i = 0, j = 0; j < len; i++, j += 4) {
326  output[j] = (unsigned char) (input[i] & 0xff);
327  output[j + 1] = (unsigned char) ((input[i] >> 8) & 0xff);
328  output[j + 2] = (unsigned char) ((input[i] >> 16) & 0xff);
329  output[j + 3] = (unsigned char) ((input[i] >> 24) & 0xff);
330  }
331 }
332 
333 /* Decodes input (unsigned char) into output (UINT4). Assumes len is
334  a multiple of 4.
335  */
336 static void Decode(output, input, len)
337 UINT4 *output;
338 unsigned char *input;
339 unsigned int len;
340 {
341  unsigned int i, j;
342 
343  for (i = 0, j = 0; j < len; i++, j += 4)
344  output[i] = ((UINT4) input[j]) | (((UINT4) input[j + 1]) << 8) |
345  (((UINT4) input[j + 2]) << 16) | (((UINT4) input[j + 3]) <<
346  24);
347 }
348 
349 /*************************************************************************/
350 
351 /******** Our own high-level routines. ********/
352 
353 
354 #define XTOI(c) ((c)>9 ? (c)-'A'+10 : (c)-'0')
355 
356 
357 /* Encrypt `src' of length `len' and store the result in `dest'. If the
358  * resulting string would be longer than `size', return -1 and leave `dest'
359  * unchanged; else return 0.
360  */
361 static int old_encrypt(const char *src, int len, char *dest, int size)
362 {
363 
364  MD5_CTX context;
365  char digest[33];
366  char tmp[33];
367  int i;
368 
369  if (size < 16)
370  return -1;
371 
372  memset(&context, 0, sizeof(context));
373  memset(&digest, 0, sizeof(digest));
374 
375  MD5Init(&context);
376  MD5Update(&context, src, len);
377  MD5Final(digest, &context);
378  for (i = 0; i < 32; i += 2)
379  dest[i / 2] = XTOI(digest[i]) << 4 | XTOI(digest[i + 1]);
380 
381  if(debug) {
382  memset(tmp,0,33);
383  my_binary_to_hex((unsigned char *) dest,tmp,16);
384  alog("enc_old: Converted [%s] to [%s]",src,tmp);
385  }
386 
387  return 0;
388 
389 }
390 
391 static int old_encrypt_check_len(int passlen, int bufsize)
392 {
393  if (bufsize < 16)
394  fatal("enc_old: old_check_len(): buffer too small (%d)", bufsize);
395  return 0;
396 }
397 
398 
399 /* Compare a plaintext string against an encrypted password. Return 1 if
400  * they match, 0 if not, and -1 if something went wrong. */
401 
402 static int old_check_password(const char *plaintext, const char *password)
403 {
404  char buf[BUFSIZE];
405 
406  if (old_encrypt(plaintext, strlen(plaintext), buf, sizeof(buf)) < 0)
407  return -1;
408  if (memcmp(buf, password, 16) == 0)
409  return 1;
410  else
411  return 0;
412 }
413 
414 static int old_decrypt(const char *src, char *dest, int size)
415 {
416  return 0;
417 }
418 
419 int AnopeInit(int argc, char **argv) {
420 
421  moduleAddAuthor("Anope");
422  moduleAddVersion(VERSION_STRING);
424 
429 
430  return MOD_CONT;
431 }
432 
433 void AnopeFini(void) {
434  encmodule_encrypt(NULL);
436  encmodule_decrypt(NULL);
438 }
439 
440 /*************************************************************************/
441 
E void encmodule_encrypt_check_len(int(*func)(int passlen, int bufsize))
Definition: encrypt.c:26
#define S42
Definition: enc_old.c:89
void AnopeFini(void)
Definition: enc_old.c:433
#define II(a, b, c, d, x, s, ac)
Definition: enc_old.c:132
static unsigned char PADDING[64]
Definition: enc_old.c:97
E void encmodule_encrypt(int(*func)(const char *src, int len, char *dest, int size))
Definition: encrypt.c:20
#define S43
Definition: enc_old.c:90
#define S33
Definition: enc_old.c:86
static int old_encrypt_check_len(int passlen, int bufsize)
Definition: enc_old.c:391
static void MD5Init(MD5_CTX *context)
Definition: enc_old.c:140
static void MD5Update(MD5_CTX *context, unsigned char *input, unsigned int inputLen)
Definition: enc_old.c:156
void * POINTER
Definition: enc_md5.c:55
UINT4 state[4]
Definition: enc_md5.c:47
E void encmodule_decrypt(int(*func)(const char *src, char *dest, int size))
Definition: encrypt.c:31
E void encmodule_check_password(int(*func)(const char *plaintext, const char *password))
Definition: encrypt.c:36
static void Encode(unsigned char *, UINT4 *, unsigned int)
Definition: enc_old.c:318
MDE void moduleAddAuthor(const char *author)
Definition: modules.c:1772
#define S32
Definition: enc_old.c:85
MDE void moduleSetType(MODType type)
Definition: modules.c:818
#define S11
Definition: enc_old.c:76
unsigned int UINT4
Definition: enc_md5.c:43
#define S22
Definition: enc_old.c:81
#define S41
Definition: enc_old.c:88
E void E void E void fatal(const char *fmt,...) FORMAT(printf
static int old_decrypt(const char *src, char *dest, int size)
Definition: enc_old.c:414
int AnopeInit(int argc, char **argv)
Definition: enc_old.c:419
MDE void moduleAddVersion(const char *version)
Definition: modules.c:1760
static void MD5Transform(UINT4[4], unsigned char[64])
static void my_binary_to_hex(unsigned char *bin, char *hex, int length)
Definition: enc_old.c:16
Command * c
Definition: ns_recover.c:17
E void alog(const char *fmt,...) FORMAT(printf
#define MOD_CONT
Definition: modules.h:54
E int debug
Definition: extern.h:775
#define S24
Definition: enc_old.c:83
UINT4 count[2]
Definition: enc_md5.c:48
#define S31
Definition: enc_old.c:84
unsigned int UINT4
Definition: enc_old.c:60
#define S12
Definition: enc_old.c:77
#define S14
Definition: enc_old.c:79
#define FF(a, b, c, d, x, s, ac)
Definition: enc_old.c:117
#define GG(a, b, c, d, x, s, ac)
Definition: enc_old.c:122
void * POINTER
Definition: enc_old.c:72
static int old_encrypt(const char *src, int len, char *dest, int size)
Definition: enc_old.c:361
#define S13
Definition: enc_old.c:78
#define HH(a, b, c, d, x, s, ac)
Definition: enc_old.c:127
#define S34
Definition: enc_old.c:87
static int old_check_password(const char *plaintext, const char *password)
Definition: enc_old.c:402
static void MD5Final(digest, MD5_CTX *context)
Definition: enc_old.c:197
#define S23
Definition: enc_old.c:82
#define BUFSIZE
Definition: config.h:47
#define S44
Definition: enc_old.c:91
static void Decode(UINT4 *, unsigned char *, unsigned int)
Definition: enc_old.c:336
#define S21
Definition: enc_old.c:80
#define XTOI(c)
Definition: enc_old.c:354