5817be7c93667239d18f28112687e0a57e78d25a
[exim.git] / src / src / auths / cram_md5.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) The Exim Maintainers 2020 - 2023 */
6 /* Copyright (c) University of Cambridge 1995 - 2018 */
7 /* See the file NOTICE for conditions of use and distribution. */
8 /* SPDX-License-Identifier: GPL-2.0-or-later */
9
10
11 /* The stand-alone version just tests the algorithm. We have to drag
12 in the MD5 computation functions, without their own stand-alone main
13 program. */
14
15 #ifdef STAND_ALONE
16 # define CRAM_STAND_ALONE
17 # include "md5.c"
18
19
20 /* This is the normal, non-stand-alone case */
21
22 #else
23 # include "../exim.h"
24
25 # ifdef AUTH_CRAM_MD5
26 #  include "cram_md5.h"
27
28 /* Options specific to the cram_md5 authentication mechanism. */
29
30 optionlist auth_cram_md5_options[] = {
31   { "client_name",        opt_stringptr,
32       OPT_OFF(auth_cram_md5_options_block, client_name) },
33   { "client_secret",      opt_stringptr,
34       OPT_OFF(auth_cram_md5_options_block, client_secret) },
35   { "server_secret",      opt_stringptr,
36       OPT_OFF(auth_cram_md5_options_block, server_secret) }
37 };
38
39 /* Size of the options list. An extern variable has to be used so that its
40 address can appear in the tables drtables.c. */
41
42 int auth_cram_md5_options_count =
43   sizeof(auth_cram_md5_options)/sizeof(optionlist);
44
45 /* Default private options block for the condition authentication method. */
46
47 auth_cram_md5_options_block auth_cram_md5_option_defaults = {
48   NULL,             /* server_secret */
49   NULL,             /* client_secret */
50   NULL              /* client_name */
51 };
52
53
54 #  ifdef MACRO_PREDEF
55
56 /* Dummy values */
57 void auth_cram_md5_init(auth_instance *ablock) {}
58 int auth_cram_md5_server(auth_instance *ablock, uschar *data) {return 0;}
59 int auth_cram_md5_client(auth_instance *ablock, void *sx, int timeout,
60     uschar *buffer, int buffsize) {return 0;}
61
62 #  else /*!MACRO_PREDEF*/
63
64
65 /*************************************************
66 *          Initialization entry point            *
67 *************************************************/
68
69 /* Called for each instance, after its options have been read, to
70 enable consistency checks to be done, or anything else that needs
71 to be set up. */
72
73 void
74 auth_cram_md5_init(auth_instance *ablock)
75 {
76 auth_cram_md5_options_block *ob =
77   (auth_cram_md5_options_block *)(ablock->options_block);
78 if (ob->server_secret != NULL) ablock->server = TRUE;
79 if (ob->client_secret != NULL)
80   {
81   ablock->client = TRUE;
82   if (ob->client_name == NULL) ob->client_name = primary_hostname;
83   }
84 }
85
86 #  endif        /*!MACRO_PREDEF*/
87 # endif         /*AUTH_CRAM_MD5*/
88 #endif          /*!STAND_ALONE*/
89
90
91
92 #ifndef MACRO_PREDEF
93 /*************************************************
94 *      Perform the CRAM-MD5 algorithm            *
95 *************************************************/
96
97 /* The CRAM-MD5 algorithm is described in RFC 2195. It computes
98
99   MD5((secret XOR opad), MD5((secret XOR ipad), challenge))
100
101 where secret is padded out to 64 characters (after being reduced to an MD5
102 digest if longer than 64) and ipad and opad are 64-byte strings of 0x36 and
103 0x5c respectively, and comma means concatenation.
104
105 Arguments:
106   secret         the shared secret
107   challenge      the challenge text
108   digest         16-byte slot to put the answer in
109
110 Returns:         nothing
111 */
112
113 static void
114 compute_cram_md5(uschar *secret, uschar *challenge, uschar *digestptr)
115 {
116 md5 base;
117 int len = Ustrlen(secret);
118 uschar isecret[64];
119 uschar osecret[64];
120 uschar md5secret[16];
121
122 /* If the secret is longer than 64 characters, we compute its MD5 digest
123 and use that. */
124
125 if (len > 64)
126   {
127   md5_start(&base);
128   md5_end(&base, US secret, len, md5secret);
129   secret = US md5secret;
130   len = 16;
131   }
132
133 /* The key length is now known to be <= 64. Set up the padded and xor'ed
134 versions. */
135
136 memcpy(isecret, secret, len);
137 memset(isecret+len, 0, 64-len);
138 memcpy(osecret, isecret, 64);
139
140 for (int i = 0; i < 64; i++)
141   {
142   isecret[i] ^= 0x36;
143   osecret[i] ^= 0x5c;
144   }
145
146 /* Compute the inner MD5 digest */
147
148 md5_start(&base);
149 md5_mid(&base, isecret);
150 md5_end(&base, US challenge, Ustrlen(challenge), md5secret);
151
152 /* Compute the outer MD5 digest */
153
154 md5_start(&base);
155 md5_mid(&base, osecret);
156 md5_end(&base, md5secret, 16, digestptr);
157 }
158
159
160 # ifndef STAND_ALONE
161 #  ifdef AUTH_CRAM_MD5
162
163 /*************************************************
164 *             Server entry point                 *
165 *************************************************/
166
167 /* For interface, see auths/README */
168
169 int
170 auth_cram_md5_server(auth_instance * ablock, uschar * data)
171 {
172 auth_cram_md5_options_block * ob =
173   (auth_cram_md5_options_block *)(ablock->options_block);
174 uschar * challenge = string_sprintf("<%d.%ld@%s>", getpid(),
175     (long int) time(NULL), primary_hostname);
176 uschar * clear, * secret;
177 uschar digest[16];
178 int i, rc, len;
179
180 /* If we are running in the test harness, always send the same challenge,
181 an example string taken from the RFC. */
182
183 if (f.running_in_test_harness)
184   challenge = US"<1896.697170952@postoffice.reston.mci.net>";
185
186 /* No data should have been sent with the AUTH command */
187
188 if (*data) return UNEXPECTED;
189
190 /* Send the challenge, read the return */
191
192 if ((rc = auth_get_data(&data, challenge, Ustrlen(challenge))) != OK) return rc;
193 if ((len = b64decode(data, &clear, GET_TAINTED)) < 0) return BAD64;
194
195 /* The return consists of a user name, space-separated from the CRAM-MD5
196 digest, expressed in hex. Extract the user name and put it in $auth1 and $1.
197 The former is now the preferred variable; the latter is the original one. Then
198 check that the remaining length is 32. */
199
200 auth_vars[0] = expand_nstring[1] = clear;
201 Uskip_nonwhite(&clear);
202 if (!isspace(*clear)) return FAIL;
203 *clear++ = 0;
204
205 expand_nlength[1] = clear - expand_nstring[1] - 1;
206 if (len - expand_nlength[1] - 1 != 32) return FAIL;
207 expand_nmax = 1;
208
209 /* Expand the server_secret string so that it can compute a value dependent on
210 the user name if necessary. */
211
212 debug_print_string(ablock->server_debug_string);    /* customized debugging */
213 secret = expand_string(ob->server_secret);
214
215 /* A forced fail implies failure of authentication - i.e. we have no secret for
216 the given name. */
217
218 if (secret == NULL)
219   {
220   if (f.expand_string_forcedfail) return FAIL;
221   auth_defer_msg = expand_string_message;
222   return DEFER;
223   }
224
225 /* Compute the CRAM-MD5 digest that we should have received from the client. */
226
227 compute_cram_md5(secret, challenge, digest);
228
229 HDEBUG(D_auth)
230   {
231   uschar buff[64];
232   debug_printf("CRAM-MD5: user name = %s\n", auth_vars[0]);
233   debug_printf("          challenge = %s\n", challenge);
234   debug_printf("          received  = %s\n", clear);
235   Ustrcpy(buff, US"          digest    = ");
236   for (i = 0; i < 16; i++) sprintf(CS buff+22+2*i, "%02x", digest[i]);
237   debug_printf("%.54s\n", buff);
238   }
239
240 /* We now have to compare the digest, which is 16 bytes in binary, with the
241 data received, which is expressed in lower case hex. We checked above that
242 there were 32 characters of data left. */
243
244 for (i = 0; i < 16; i++)
245   {
246   int a = *clear++;
247   int b = *clear++;
248   if (((((a >= 'a')? a - 'a' + 10 : a - '0') << 4) +
249         ((b >= 'a')? b - 'a' + 10 : b - '0')) != digest[i]) return FAIL;
250   }
251
252 /* Expand server_condition as an authorization check */
253 return auth_check_serv_cond(ablock);
254 }
255
256
257
258 /*************************************************
259 *              Client entry point                *
260 *************************************************/
261
262 /* For interface, see auths/README */
263
264 int
265 auth_cram_md5_client(
266   auth_instance *ablock,                 /* authenticator block */
267   void * sx,                             /* smtp connextion */
268   int timeout,                           /* command timeout */
269   uschar *buffer,                        /* for reading response */
270   int buffsize)                          /* size of buffer */
271 {
272 auth_cram_md5_options_block *ob =
273   (auth_cram_md5_options_block *)(ablock->options_block);
274 uschar *secret = expand_string(ob->client_secret);
275 uschar *name = expand_string(ob->client_name);
276 uschar *challenge, *p;
277 int i;
278 uschar digest[16];
279
280 /* If expansion of either the secret or the user name failed, return CANCELLED
281 or ERROR, as appropriate. */
282
283 if (!secret || !name)
284   {
285   if (f.expand_string_forcedfail)
286     {
287     *buffer = 0;           /* No message */
288     return CANCELLED;
289     }
290   string_format(buffer, buffsize, "expansion of \"%s\" failed in "
291     "%s authenticator: %s",
292     !secret ? ob->client_secret : ob->client_name,
293     ablock->name, expand_string_message);
294   return ERROR;
295   }
296
297 /* Initiate the authentication exchange and read the challenge, which arrives
298 in base 64. */
299
300 if (smtp_write_command(sx, SCMD_FLUSH, "AUTH %s\r\n", ablock->public_name) < 0)
301   return FAIL_SEND;
302 if (!smtp_read_response(sx, buffer, buffsize, '3', timeout))
303   return FAIL;
304
305 if (b64decode(buffer + 4, &challenge, buffer + 4) < 0)
306   {
307   string_format(buffer, buffsize, "bad base 64 string in challenge: %s",
308     big_buffer + 4);
309   return ERROR;
310   }
311
312 /* Run the CRAM-MD5 algorithm on the secret and the challenge */
313
314 compute_cram_md5(secret, challenge, digest);
315
316 /* Create the response from the user name plus the CRAM-MD5 digest */
317
318 string_format(big_buffer, big_buffer_size - 36, "%s", name);
319 for (p = big_buffer; *p; ) p++;
320 *p++ = ' ';
321
322 for (i = 0; i < 16; i++)
323   p += sprintf(CS p, "%02x", digest[i]);
324
325 /* Send the response, in base 64, and check the result. The response is
326 in big_buffer, but b64encode() returns its result in working store,
327 so calling smtp_write_command(), which uses big_buffer, is OK. */
328
329 buffer[0] = 0;
330 if (smtp_write_command(sx, SCMD_FLUSH, "%s\r\n", b64encode(CUS big_buffer,
331   p - big_buffer)) < 0) return FAIL_SEND;
332
333 return smtp_read_response(sx, US buffer, buffsize, '2', timeout)
334   ? OK : FAIL;
335 }
336 #  endif  /*AUTH_CRAM_MD5*/
337 # endif  /*!STAND_ALONE*/
338
339
340 /*************************************************
341 **************************************************
342 *             Stand-alone test program           *
343 **************************************************
344 *************************************************/
345
346 # ifdef STAND_ALONE
347
348 int main(int argc, char **argv)
349 {
350 int i;
351 uschar *secret = US argv[1];
352 uschar *challenge = US argv[2];
353 uschar digest[16];
354
355 compute_cram_md5(secret, challenge, digest);
356
357 for (i = 0; i < 16; i++) printf("%02x", digest[i]);
358 printf("\n");
359
360 return 0;
361 }
362
363 # endif /*STAND_ALONE*/
364
365 #endif  /*!MACRO_PREDEF*/
366 /* End of cram_md5.c */