bb6c02c500662f35e11f23d9b53748147a8a5693
[users/jgh/exim.git] / src / src / auths / cyrus_sasl.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 /* This code was originally contributed by Matthew Byng-Maddick */
9
10 /* Copyright (c) A L Digital 2004 */
11
12 /* A generic (mechanism independent) Cyrus SASL authenticator. */
13
14
15 #include "../exim.h"
16
17
18 /* We can't just compile this code and allow the library mechanism to omit the
19 functions if they are not wanted, because we need to have the Cyrus SASL header
20 available for compiling. Therefore, compile these functions only if
21 AUTH_CYRUS_SASL is defined. However, some compilers don't like compiling empty
22 modules, so keep them happy with a dummy when skipping the rest. Make it
23 reference itself to stop picky compilers complaining that it is unused, and put
24 in a dummy argument to stop even pickier compilers complaining about infinite
25 loops. */
26
27 #ifndef AUTH_CYRUS_SASL
28 static void dummy(int x);
29 static void dummy2(int x) { dummy(x-1); }
30 static void dummy(int x) { dummy2(x-1); }
31 #else
32
33
34 #include <sasl/sasl.h>
35 #include "cyrus_sasl.h"
36
37 /* Options specific to the cyrus_sasl authentication mechanism. */
38
39 optionlist auth_cyrus_sasl_options[] = {
40   { "server_hostname",      opt_stringptr,
41       OPT_OFF(auth_cyrus_sasl_options_block, server_hostname) },
42   { "server_mech",          opt_stringptr,
43       OPT_OFF(auth_cyrus_sasl_options_block, server_mech) },
44   { "server_realm",         opt_stringptr,
45       OPT_OFF(auth_cyrus_sasl_options_block, server_realm) },
46   { "server_service",       opt_stringptr,
47       OPT_OFF(auth_cyrus_sasl_options_block, server_service) }
48 };
49
50 /* Size of the options list. An extern variable has to be used so that its
51 address can appear in the tables drtables.c. */
52
53 int auth_cyrus_sasl_options_count =
54   sizeof(auth_cyrus_sasl_options)/sizeof(optionlist);
55
56 /* Default private options block for the cyrus_sasl authentication method. */
57
58 auth_cyrus_sasl_options_block auth_cyrus_sasl_option_defaults = {
59   US"smtp",         /* server_service */
60   US"$primary_hostname", /* server_hostname */
61   NULL,             /* server_realm */
62   NULL              /* server_mech */
63 };
64
65
66 #ifdef MACRO_PREDEF
67
68 /* Dummy values */
69 void auth_cyrus_sasl_init(auth_instance *ablock) {}
70 int auth_cyrus_sasl_server(auth_instance *ablock, uschar *data) {return 0;}
71 int auth_cyrus_sasl_client(auth_instance *ablock, void * sx,
72   int timeout, uschar *buffer, int buffsize) {return 0;}
73 void auth_cyrus_sasl_version_report(FILE *f) {}
74
75 #else   /*!MACRO_PREDEF*/
76
77
78
79
80 /*************************************************
81 *          Initialization entry point            *
82 *************************************************/
83
84 /* Called for each instance, after its options have been read, to
85 enable consistency checks to be done, or anything else that needs
86 to be set up. */
87
88
89 /* Auxiliary function, passed in data to sasl_server_init(). */
90
91 static int
92 mysasl_config(void *context, const char *plugin_name, const char *option,
93       const char **result, unsigned int *len)
94 {
95 if (context && !strcmp(option, "mech_list"))
96   {
97   *result = context;
98   if (len) *len = strlen(*result);
99   return SASL_OK;
100   }
101 return SASL_FAIL;
102 }
103
104 /* Here's the real function */
105
106 void
107 auth_cyrus_sasl_init(auth_instance *ablock)
108 {
109 auth_cyrus_sasl_options_block *ob =
110   (auth_cyrus_sasl_options_block *)(ablock->options_block);
111 const uschar *list, *listptr, *buffer;
112 int rc, i;
113 unsigned int len;
114 rmark rs_point;
115 uschar *expanded_hostname;
116 char *realm_expanded;
117
118 sasl_conn_t *conn;
119 sasl_callback_t cbs[] = {
120   {SASL_CB_GETOPT, NULL, NULL },
121   {SASL_CB_LIST_END, NULL, NULL}};
122
123 /* default the mechanism to our "public name" */
124
125 if (!ob->server_mech) ob->server_mech = string_copy(ablock->public_name);
126
127 if (!(expanded_hostname = expand_string(ob->server_hostname)))
128   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s authenticator:  "
129       "couldn't expand server_hostname [%s]: %s",
130       ablock->name, ob->server_hostname, expand_string_message);
131
132 realm_expanded = NULL;
133 if (  ob->server_realm
134    && !(realm_expanded = CS expand_string(ob->server_realm)))
135   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s authenticator:  "
136       "couldn't expand server_realm [%s]: %s",
137       ablock->name, ob->server_realm, expand_string_message);
138
139 /* we're going to initialise the library to check that there is an
140 authenticator of type whatever mechanism we're using */
141
142 cbs[0].proc = (int(*)(void)) &mysasl_config;
143 cbs[0].context = ob->server_mech;
144
145 if ((rc = sasl_server_init(cbs, "exim")) != SASL_OK)
146   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s authenticator:  "
147       "couldn't initialise Cyrus SASL library.", ablock->name);
148
149 if ((rc = sasl_server_new(CS ob->server_service, CS expanded_hostname,
150                    realm_expanded, NULL, NULL, NULL, 0, &conn)) != SASL_OK)
151   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s authenticator:  "
152       "couldn't initialise Cyrus SASL server connection.", ablock->name);
153
154 if ((rc = sasl_listmech(conn, NULL, "", ":", "", CCSS &list, &len, &i)) != SASL_OK)
155   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s authenticator:  "
156       "couldn't get Cyrus SASL mechanism list.", ablock->name);
157
158 i = ':';
159 listptr = list;
160
161 HDEBUG(D_auth)
162   {
163   debug_printf("Initialised Cyrus SASL service=\"%s\" fqdn=\"%s\" realm=\"%s\"\n",
164       ob->server_service, expanded_hostname, realm_expanded);
165   debug_printf("Cyrus SASL knows mechanisms: %s\n", list);
166   }
167
168 /* the store_get / store_reset mechanism is hierarchical
169  the hierarchy is stored for us behind our back. This point
170  creates a hierarchy point for this function.  */
171
172 rs_point = store_mark();
173
174 /* loop until either we get to the end of the list, or we match the
175 public name of this authenticator */
176
177 while (  (buffer = string_nextinlist(&listptr, &i, NULL, 0))
178       && strcmpic(buffer,ob->server_mech) );
179
180 if (!buffer)
181   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s authenticator:  "
182       "Cyrus SASL doesn't know about mechanism %s.", ablock->name, ob->server_mech);
183
184 store_reset(rs_point);
185
186 HDEBUG(D_auth) debug_printf("Cyrus SASL driver %s: %s initialised\n", ablock->name, ablock->public_name);
187
188 /* make sure that if we get here then we're allowed to advertise. */
189 ablock->server = TRUE;
190
191 sasl_dispose(&conn);
192 sasl_done();
193 }
194
195 /*************************************************
196 *             Server entry point                 *
197 *************************************************/
198
199 /* For interface, see auths/README */
200
201 /* note, we don't care too much about memory allocation in this, because this is entirely
202 within a shortlived child */
203
204 int
205 auth_cyrus_sasl_server(auth_instance *ablock, uschar *data)
206 {
207 auth_cyrus_sasl_options_block *ob =
208   (auth_cyrus_sasl_options_block *)(ablock->options_block);
209 uschar *output, *out2, *input, *clear, *hname;
210 uschar *debug = NULL;   /* Stops compiler complaining */
211 sasl_callback_t cbs[] = {{SASL_CB_LIST_END, NULL, NULL}};
212 sasl_conn_t *conn;
213 char * realm_expanded = NULL;
214 int rc, firsttime = 1, clen, *negotiated_ssf_ptr = NULL, negotiated_ssf;
215 unsigned int inlen, outlen;
216
217 input = data;
218 inlen = Ustrlen(data);
219
220 HDEBUG(D_auth) debug = string_copy(data);
221
222 hname = expand_string(ob->server_hostname);
223 if (hname && ob->server_realm)
224   realm_expanded = CS expand_string(ob->server_realm);
225 if (!hname  ||  !realm_expanded  && ob->server_realm)
226   {
227   auth_defer_msg = expand_string_message;
228   return DEFER;
229   }
230
231 if (inlen)
232   {
233   if ((clen = b64decode(input, &clear)) < 0)
234     return BAD64;
235   input = clear;
236   inlen = clen;
237   }
238
239 if ((rc = sasl_server_init(cbs, "exim")) != SASL_OK)
240   {
241   auth_defer_msg = US"couldn't initialise Cyrus SASL library";
242   return DEFER;
243   }
244
245 rc = sasl_server_new(CS ob->server_service, CS hname, realm_expanded, NULL,
246   NULL, NULL, 0, &conn);
247
248 HDEBUG(D_auth)
249   debug_printf("Initialised Cyrus SASL server connection; service=\"%s\" fqdn=\"%s\" realm=\"%s\"\n",
250       ob->server_service, hname, realm_expanded);
251
252 if (rc != SASL_OK )
253   {
254   auth_defer_msg = US"couldn't initialise Cyrus SASL connection";
255   sasl_done();
256   return DEFER;
257   }
258
259 if (tls_in.cipher)
260   {
261   if ((rc = sasl_setprop(conn, SASL_SSF_EXTERNAL, (sasl_ssf_t *) &tls_in.bits)) != SASL_OK)
262     {
263     HDEBUG(D_auth) debug_printf("Cyrus SASL EXTERNAL SSF set %d failed: %s\n",
264         tls_in.bits, sasl_errstring(rc, NULL, NULL));
265     auth_defer_msg = US"couldn't set Cyrus SASL EXTERNAL SSF";
266     sasl_done();
267     return DEFER;
268     }
269   else
270     HDEBUG(D_auth) debug_printf("Cyrus SASL set EXTERNAL SSF to %d\n", tls_in.bits);
271
272   /*XXX Set channel-binding here with sasl_channel_binding_t / SASL_CHANNEL_BINDING
273   Unclear what the "name" element does though, ditto the "critical" flag. */
274   }
275 else
276   HDEBUG(D_auth) debug_printf("Cyrus SASL: no TLS, no EXTERNAL SSF set\n");
277
278 /* So sasl_setprop() documents non-shorted IPv6 addresses which is incredibly
279 annoying; looking at cyrus-imapd-2.3.x source, the IP address is constructed
280 with their iptostring() function, which just wraps
281 getnameinfo(..., NI_NUMERICHOST|NI_NUMERICSERV), which is equivalent to the
282 inet_ntop which we wrap in our host_ntoa() function.
283
284 So the docs are too strict and we shouldn't worry about :: contractions. */
285
286 /* Set properties for remote and local host-ip;port */
287 for (int i = 0; i < 2; ++i)
288   {
289   int propnum;
290   const uschar * label;
291   uschar * address_port;
292   const char *s_err;
293   socklen_t sslen;
294
295   if (i)
296     {
297     propnum = SASL_IPREMOTEPORT;
298     label = CUS"peer";
299     address_port = string_sprintf("%s;%d",
300                                   sender_host_address, sender_host_port);
301     }
302   else
303     {
304     propnum = SASL_IPLOCALPORT;
305     label = CUS"local";
306     address_port = string_sprintf("%s;%d", interface_address, interface_port);
307     }
308
309   if ((rc = sasl_setprop(conn, propnum, address_port)) != SASL_OK)
310     {
311     HDEBUG(D_auth)
312       {
313       s_err = sasl_errdetail(conn);
314       debug_printf("Failed to set %s SASL property: [%d] %s\n",
315           label, rc, s_err ? s_err : "<unknown reason>");
316       }
317     break;
318     }
319   HDEBUG(D_auth) debug_printf("Cyrus SASL set %s hostport to: %s\n",
320       label, address_port);
321   }
322
323 for (rc = SASL_CONTINUE; rc == SASL_CONTINUE; )
324   {
325   if (firsttime)
326     {
327     firsttime = 0;
328     HDEBUG(D_auth) debug_printf("Calling sasl_server_start(%s,\"%s\")\n", ob->server_mech, debug);
329     rc = sasl_server_start(conn, CS ob->server_mech, inlen ? CS input : NULL, inlen,
330            CCSS &output, &outlen);
331     }
332   else
333     {
334     /* make sure that we have a null-terminated string */
335     out2 = string_copyn(output, outlen);
336
337     if ((rc = auth_get_data(&input, out2, outlen)) != OK)
338       {
339       /* we couldn't get the data, so free up the library before
340       returning whatever error we get */
341       sasl_dispose(&conn);
342       sasl_done();
343       return rc;
344       }
345     inlen = Ustrlen(input);
346
347     HDEBUG(D_auth) debug = string_copy(input);
348     if (inlen)
349       {
350       if ((clen = b64decode(input, &clear)) < 0)
351        {
352        sasl_dispose(&conn);
353        sasl_done();
354        return BAD64;
355        }
356       input = clear;
357       inlen = clen;
358       }
359
360     HDEBUG(D_auth) debug_printf("Calling sasl_server_step(\"%s\")\n", debug);
361     rc = sasl_server_step(conn, CS input, inlen, CCSS &output, &outlen);
362     }
363
364   if (rc == SASL_BADPROT)
365     {
366     sasl_dispose(&conn);
367     sasl_done();
368     return UNEXPECTED;
369     }
370   if (rc == SASL_CONTINUE)
371     continue;
372
373   /* Get the username and copy it into $auth1 and $1. The former is now the
374   preferred variable; the latter is the original variable. */
375
376   if ((sasl_getprop(conn, SASL_USERNAME, (const void **)(&out2))) != SASL_OK)
377     {
378     HDEBUG(D_auth)
379       debug_printf("Cyrus SASL library will not tell us the username: %s\n",
380           sasl_errstring(rc, NULL, NULL));
381     log_write(0, LOG_REJECT, "%s authenticator (%s):\n  "
382        "Cyrus SASL username fetch problem: %s", ablock->name, ob->server_mech,
383        sasl_errstring(rc, NULL, NULL));
384     sasl_dispose(&conn);
385     sasl_done();
386     return FAIL;
387     }
388   auth_vars[0] = expand_nstring[1] = string_copy(out2);
389   expand_nlength[1] = Ustrlen(out2);
390   expand_nmax = 1;
391
392   switch (rc)
393     {
394     case SASL_FAIL: case SASL_BUFOVER: case SASL_BADMAC: case SASL_BADAUTH:
395     case SASL_NOAUTHZ: case SASL_ENCRYPT: case SASL_EXPIRED:
396     case SASL_DISABLED: case SASL_NOUSER:
397       /* these are considered permanent failure codes */
398       HDEBUG(D_auth)
399         debug_printf("Cyrus SASL permanent failure %d (%s)\n", rc, sasl_errstring(rc, NULL, NULL));
400       log_write(0, LOG_REJECT, "%s authenticator (%s):\n  "
401          "Cyrus SASL permanent failure: %s", ablock->name, ob->server_mech,
402          sasl_errstring(rc, NULL, NULL));
403       sasl_dispose(&conn);
404       sasl_done();
405       return FAIL;
406
407     case SASL_NOMECH:
408       /* this is a temporary failure, because the mechanism is not
409       available for this user. If it wasn't available at all, we
410       shouldn't have got here in the first place...  */
411
412       HDEBUG(D_auth)
413         debug_printf("Cyrus SASL temporary failure %d (%s)\n", rc, sasl_errstring(rc, NULL, NULL));
414       auth_defer_msg =
415           string_sprintf("Cyrus SASL: mechanism %s not available", ob->server_mech);
416       sasl_dispose(&conn);
417       sasl_done();
418       return DEFER;
419
420     case SASL_OK:
421       HDEBUG(D_auth)
422         debug_printf("Cyrus SASL %s authentication succeeded for %s\n",
423             ob->server_mech, auth_vars[0]);
424
425       if ((rc = sasl_getprop(conn, SASL_SSF, (const void **)(&negotiated_ssf_ptr)))!= SASL_OK)
426         {
427         HDEBUG(D_auth)
428           debug_printf("Cyrus SASL library will not tell us the SSF: %s\n",
429               sasl_errstring(rc, NULL, NULL));
430         log_write(0, LOG_REJECT, "%s authenticator (%s):\n  "
431             "Cyrus SASL SSF value not available: %s", ablock->name, ob->server_mech,
432             sasl_errstring(rc, NULL, NULL));
433         sasl_dispose(&conn);
434         sasl_done();
435         return FAIL;
436         }
437       negotiated_ssf = *negotiated_ssf_ptr;
438       HDEBUG(D_auth)
439         debug_printf("Cyrus SASL %s negotiated SSF: %d\n", ob->server_mech, negotiated_ssf);
440       if (negotiated_ssf > 0)
441         {
442         HDEBUG(D_auth)
443           debug_printf("Exim does not implement SASL wrapping (needed for SSF %d).\n", negotiated_ssf);
444         log_write(0, LOG_REJECT, "%s authenticator (%s):\n  "
445             "Cyrus SASL SSF %d not supported by Exim", ablock->name, ob->server_mech, negotiated_ssf);
446         sasl_dispose(&conn);
447         sasl_done();
448         return FAIL;
449         }
450
451       /* close down the connection, freeing up library's memory */
452       sasl_dispose(&conn);
453       sasl_done();
454
455       /* Expand server_condition as an authorization check */
456       return auth_check_serv_cond(ablock);
457
458     default:
459       /* Anything else is a temporary failure, and we'll let SASL print out
460        * the error string for us
461        */
462       HDEBUG(D_auth)
463         debug_printf("Cyrus SASL temporary failure %d (%s)\n", rc, sasl_errstring(rc, NULL, NULL));
464       auth_defer_msg =
465           string_sprintf("Cyrus SASL: %s", sasl_errstring(rc, NULL, NULL));
466       sasl_dispose(&conn);
467       sasl_done();
468       return DEFER;
469     }
470   }
471 /* NOTREACHED */
472 return 0;  /* Stop compiler complaints */
473 }
474
475 /*************************************************
476 *                Diagnostic API                  *
477 *************************************************/
478
479 void
480 auth_cyrus_sasl_version_report(FILE *f)
481 {
482 const char *implementation, *version;
483 sasl_version_info(&implementation, &version, NULL, NULL, NULL, NULL);
484 fprintf(f, "Library version: Cyrus SASL: Compile: %d.%d.%d\n"
485            "                             Runtime: %s [%s]\n",
486         SASL_VERSION_MAJOR, SASL_VERSION_MINOR, SASL_VERSION_STEP,
487         version, implementation);
488 }
489
490 /*************************************************
491 *              Client entry point                *
492 *************************************************/
493
494 /* For interface, see auths/README */
495
496 int
497 auth_cyrus_sasl_client(
498   auth_instance *ablock,                 /* authenticator block */
499   void * sx,                             /* connexction */
500   int timeout,                           /* command timeout */
501   uschar *buffer,                        /* for reading response */
502   int buffsize)                          /* size of buffer */
503 {
504 /* We don't support clients (yet) in this implementation of cyrus_sasl */
505 return FAIL;
506 }
507
508 #endif   /*!MACRO_PREDEF*/
509 #endif  /* AUTH_CYRUS_SASL */
510
511 /* End of cyrus_sasl.c */