src/src/auths/gsasl_exim.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 /* Copyright (c) Twitter Inc 2012
   9    Author: Phil Pennock <pdp@exim.org> */
  10 /* Copyright (c) Phil Pennock 2012 */
  11
  12 /* Interface to GNU SASL library for generic authentication. */
  13
  14 /* Trade-offs:
  15
  16 GNU SASL does not provide authentication data itself, so we have to expose
  17 that decision to configuration.  For some mechanisms, we need to act much
  18 like plaintext.  For others, we only need to be able to provide some
  19 evaluated data on demand.  There's no abstracted way (ie, without hardcoding
  20 knowledge of authenticators here) to know which need what properties; we
  21 can't query a session or the library for "we will need these for mechanism X".
  22
  23 So: we always require server_condition, even if sometimes it will just be
  24 set as "yes".  We do provide a number of other hooks, which might not make
  25 sense in all contexts.  For some, we can do checks at init time.
  26 */
  27
  28 #include "../exim.h"
  29
  30 #ifndef AUTH_GSASL
  31 /* dummy function to satisfy compilers when we link in an "empty" file. */
  32 static void dummy(int x);
  33 static void dummy2(int x) { dummy(x-1); }
  34 static void dummy(int x) { dummy2(x-1); }
  35 #else
  36
  37 #include <gsasl.h>
  38 #include "gsasl_exim.h"
  39
  40 /* Authenticator-specific options. */
  41 /* I did have server_*_condition options for various mechanisms, but since
  42 we only ever handle one mechanism at a time, I didn't see the point in keeping
  43 that.  In case someone sees a point, I've left the condition_check() API
  44 alone. */
  45 optionlist auth_gsasl_options[] = {
  46   { "server_channelbinding", opt_bool,
  47       (void *)(offsetof(auth_gsasl_options_block, server_channelbinding)) },
  48   { "server_hostname",      opt_stringptr,
  49       (void *)(offsetof(auth_gsasl_options_block, server_hostname)) },
  50   { "server_mech",          opt_stringptr,
  51       (void *)(offsetof(auth_gsasl_options_block, server_mech)) },
  52   { "server_password",      opt_stringptr,
  53       (void *)(offsetof(auth_gsasl_options_block, server_password)) },
  54   { "server_realm",         opt_stringptr,
  55       (void *)(offsetof(auth_gsasl_options_block, server_realm)) },
  56   { "server_scram_iter",    opt_stringptr,
  57       (void *)(offsetof(auth_gsasl_options_block, server_scram_iter)) },
  58   { "server_scram_salt",    opt_stringptr,
  59       (void *)(offsetof(auth_gsasl_options_block, server_scram_salt)) },
  60   { "server_service",       opt_stringptr,
  61       (void *)(offsetof(auth_gsasl_options_block, server_service)) }
  62 };
  63 /* GSASL_SCRAM_SALTED_PASSWORD documented only for client, so not implementing
  64 hooks to avoid cleartext passwords in the Exim server. */
  65
  66 int auth_gsasl_options_count =
  67   sizeof(auth_gsasl_options)/sizeof(optionlist);
  68
  69 /* Defaults for the authenticator-specific options. */
  70 auth_gsasl_options_block auth_gsasl_option_defaults = {
  71   US"smtp",                 /* server_service */
  72   US"$primary_hostname",    /* server_hostname */
  73   NULL,                     /* server_realm */
  74   NULL,                     /* server_mech */
  75   NULL,                     /* server_password */
  76   NULL,                     /* server_scram_iter */
  77   NULL,                     /* server_scram_salt */
  78   FALSE                     /* server_channelbinding */
  79 };
  80
  81
  82 #ifdef MACRO_PREDEF
  83
  84 /* Dummy values */
  85 void auth_gsasl_init(auth_instance *ablock) {}
  86 int auth_gsasl_server(auth_instance *ablock, uschar *data) {return 0;}
  87 int auth_gsasl_client(auth_instance *ablock, smtp_inblock * sx,
  88   int timeout, uschar *buffer, int buffsize) {return 0;}
  89 void auth_gsasl_version_report(FILE *f) {}
  90
  91 #else   /*!MACRO_PREDEF*/
  92
  93
  94
  95 /* "Globals" for managing the gsasl interface. */
  96
  97 static Gsasl *gsasl_ctx = NULL;
  98 static int
  99   main_callback(Gsasl *ctx, Gsasl_session *sctx, Gsasl_property prop);
 100 static int
 101   server_callback(Gsasl *ctx, Gsasl_session *sctx, Gsasl_property prop, auth_instance *ablock);
 102 static int
 103   client_callback(Gsasl *ctx, Gsasl_session *sctx, Gsasl_property prop, auth_instance *ablock);
 104
 105 static BOOL sasl_error_should_defer = FALSE;
 106 static Gsasl_property callback_loop = 0;
 107 static BOOL checked_server_condition = FALSE;
 108
 109 enum { CURRENTLY_SERVER = 1, CURRENTLY_CLIENT = 2 };
 110
 111 struct callback_exim_state {
 112   auth_instance *ablock;
 113   int currently;
 114 };
 115
 116
 117 /*************************************************
 118 *          Initialization entry point            *
 119 *************************************************/
 120
 121 /* Called for each instance, after its options have been read, to
 122 enable consistency checks to be done, or anything else that needs
 123 to be set up. */
 124
 125 void
 126 auth_gsasl_init(auth_instance *ablock)
 127 {
 128 char *p;
 129 int rc, supported;
 130 auth_gsasl_options_block *ob =
 131   (auth_gsasl_options_block *)(ablock->options_block);
 132
 133 /* As per existing Cyrus glue, use the authenticator's public name as
 134 the default for the mechanism name; we don't handle multiple mechanisms
 135 in one authenticator, but the same driver can be used multiple times. */
 136
 137 if (ob->server_mech == NULL)
 138   ob->server_mech = string_copy(ablock->public_name);
 139
 140 /* Can get multiple session contexts from one library context, so just
 141 initialise the once. */
 142 if (gsasl_ctx == NULL) {
 143   rc = gsasl_init(&gsasl_ctx);
 144   if (rc != GSASL_OK) {
 145     log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s authenticator:  "
 146               "couldn't initialise GNU SASL library: %s (%s)",
 147               ablock->name, gsasl_strerror_name(rc), gsasl_strerror(rc));
 148   }
 149   gsasl_callback_set(gsasl_ctx, main_callback);
 150 }
 151
 152 /* We don't need this except to log it for debugging. */
 153 rc = gsasl_server_mechlist(gsasl_ctx, &p);
 154 if (rc != GSASL_OK)
 155   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s authenticator:  "
 156             "failed to retrieve list of mechanisms: %s (%s)",
 157             ablock->name,  gsasl_strerror_name(rc), gsasl_strerror(rc));
 158 HDEBUG(D_auth) debug_printf("GNU SASL supports: %s\n", p);
 159
 160 supported = gsasl_client_support_p(gsasl_ctx, CCS ob->server_mech);
 161 if (!supported)
 162   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s authenticator:  "
 163             "GNU SASL does not support mechanism \"%s\"",
 164             ablock->name, ob->server_mech);
 165
 166 if ((ablock->server_condition == NULL) &&
 167     (streqic(ob->server_mech, US"EXTERNAL") ||
 168      streqic(ob->server_mech, US"ANONYMOUS") ||
 169      streqic(ob->server_mech, US"PLAIN") ||
 170      streqic(ob->server_mech, US"LOGIN")))
 171   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s authenticator:  "
 172             "Need server_condition for %s mechanism",
 173             ablock->name, ob->server_mech);
 174
 175 /* This does *not* scale to new SASL mechanisms.  Need a better way to ask
 176 which properties will be needed. */
 177 if ((ob->server_realm == NULL) &&
 178     streqic(ob->server_mech, US"DIGEST-MD5"))
 179   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s authenticator:  "
 180             "Need server_realm for %s mechanism",
 181             ablock->name, ob->server_mech);
 182
 183 /* At present, for mechanisms we don't panic on absence of server_condition;
 184 need to figure out the most generically correct approach to deciding when
 185 it's critical and when it isn't.  Eg, for simple validation (PLAIN mechanism,
 186 etc) it clearly is critical.
 187
 188 So don't activate without server_condition, this might be relaxed in the future.
 189 */
 190 if (ablock->server_condition != NULL) ablock->server = TRUE;
 191 ablock->client = FALSE;
 192 }
 193
 194
 195 /* GNU SASL uses one top-level callback, registered at library level.
 196 We dispatch to client and server functions instead. */
 197
 198 static int
 199 main_callback(Gsasl *ctx, Gsasl_session *sctx, Gsasl_property prop)
 200 {
 201 int rc = 0;
 202 struct callback_exim_state *cb_state =
 203   (struct callback_exim_state *)gsasl_session_hook_get(sctx);
 204
 205 HDEBUG(D_auth)
 206   debug_printf("GNU SASL Callback entered, prop=%d (loop prop=%d)\n",
 207       prop, callback_loop);
 208
 209 if (cb_state == NULL)
 210   {
 211   HDEBUG(D_auth) debug_printf("  not from our server/client processing.\n");
 212   return GSASL_NO_CALLBACK;
 213   }
 214
 215 if (callback_loop > 0)
 216   {
 217   /* Most likely is that we were asked for property foo, and to
 218   expand the string we asked for property bar to put into an auth
 219   variable, but property bar is not supplied for this mechanism. */
 220   HDEBUG(D_auth)
 221     debug_printf("Loop, asked for property %d while handling property %d\n",
 222         prop, callback_loop);
 223   return GSASL_NO_CALLBACK;
 224   }
 225 callback_loop = prop;
 226
 227 if (cb_state->currently == CURRENTLY_CLIENT)
 228   rc = client_callback(ctx, sctx, prop, cb_state->ablock);
 229 else if (cb_state->currently == CURRENTLY_SERVER)
 230   rc = server_callback(ctx, sctx, prop, cb_state->ablock);
 231 else
 232   log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s authenticator:  "
 233       "unhandled callback state, bug in Exim", cb_state->ablock->name);
 234   /* NOTREACHED */
 235
 236 callback_loop = 0;
 237 return rc;
 238 }
 239
 240
 241 /*************************************************
 242 *             Server entry point                 *
 243 *************************************************/
 244
 245 /* For interface, see auths/README */
 246
 247 int
 248 auth_gsasl_server(auth_instance *ablock, uschar *initial_data)
 249 {
 250 char *tmps;
 251 char *to_send, *received;
 252 Gsasl_session *sctx = NULL;
 253 auth_gsasl_options_block *ob =
 254   (auth_gsasl_options_block *)(ablock->options_block);
 255 struct callback_exim_state cb_state;
 256 int rc, auth_result, exim_error, exim_error_override;
 257
 258 HDEBUG(D_auth)
 259   debug_printf("GNU SASL: initialising session for %s, mechanism %s.\n",
 260       ablock->name, ob->server_mech);
 261
 262 rc = gsasl_server_start(gsasl_ctx, CCS ob->server_mech, &sctx);
 263 if (rc != GSASL_OK)
 264   {
 265   auth_defer_msg = string_sprintf("GNU SASL: session start failure: %s (%s)",
 266       gsasl_strerror_name(rc), gsasl_strerror(rc));
 267   HDEBUG(D_auth) debug_printf("%s\n", auth_defer_msg);
 268   return DEFER;
 269   }
 270 /* Hereafter: gsasl_finish(sctx) please */
 271
 272 gsasl_session_hook_set(sctx, (void *)ablock);
 273 cb_state.ablock = ablock;
 274 cb_state.currently = CURRENTLY_SERVER;
 275 gsasl_session_hook_set(sctx, (void *)&cb_state);
 276
 277 tmps = CS expand_string(ob->server_service);
 278 gsasl_property_set(sctx, GSASL_SERVICE, tmps);
 279 tmps = CS expand_string(ob->server_hostname);
 280 gsasl_property_set(sctx, GSASL_HOSTNAME, tmps);
 281 if (ob->server_realm)
 282   {
 283   tmps = CS expand_string(ob->server_realm);
 284   if (tmps && *tmps)
 285     gsasl_property_set(sctx, GSASL_REALM, tmps);
 286   }
 287 /* We don't support protection layers. */
 288 gsasl_property_set(sctx, GSASL_QOPS, "qop-auth");
 289 #ifndef DISABLE_TLS
 290 if (tls_channelbinding_b64)
 291   {
 292   /* Some auth mechanisms can ensure that both sides are talking withing the
 293   same security context; for TLS, this means that even if a bad certificate
 294   has been accepted, they remain MitM-proof because both sides must be within
 295   the same negotiated session; if someone is terminating one session and
 296   proxying data on within a second, authentication will fail.
 297
 298   We might not have this available, depending upon TLS implementation,
 299   ciphersuite, phase of moon ...
 300
 301   If we do, it results in extra SASL mechanisms being available; here,
 302   Exim's one-mechanism-per-authenticator potentially causes problems.
 303   It depends upon how GNU SASL will implement the PLUS variants of GS2
 304   and whether it automatically mandates a switch to the bound PLUS
 305   if the data is available.  Since default-on, despite being more secure,
 306   would then result in mechanism name changes on a library update, we
 307   have little choice but to default it off and let the admin choose to
 308   enable it.  *sigh*
 309   */
 310   if (ob->server_channelbinding)
 311     {
 312     HDEBUG(D_auth) debug_printf("Auth %s: Enabling channel-binding\n",
 313         ablock->name);
 314     gsasl_property_set(sctx, GSASL_CB_TLS_UNIQUE,
 315         CCS  tls_channelbinding_b64);
 316     }
 317   else
 318     {
 319     HDEBUG(D_auth)
 320       debug_printf("Auth %s: Not enabling channel-binding (data available)\n",
 321           ablock->name);
 322     }
 323   }
 324 else
 325   HDEBUG(D_auth)
 326     debug_printf("Auth %s: no channel-binding data available\n",
 327         ablock->name);
 328 #endif
 329
 330 checked_server_condition = FALSE;
 331
 332 received = CS initial_data;
 333 to_send = NULL;
 334 exim_error = exim_error_override = OK;
 335
 336 do {
 337   rc = gsasl_step64(sctx, received, &to_send);
 338
 339   switch (rc)
 340     {
 341     case GSASL_OK:
 342       if (!to_send)
 343         goto STOP_INTERACTION;
 344       break;
 345
 346     case GSASL_NEEDS_MORE:
 347       break;
 348
 349     case GSASL_AUTHENTICATION_ERROR:
 350     case GSASL_INTEGRITY_ERROR:
 351     case GSASL_NO_AUTHID:
 352     case GSASL_NO_ANONYMOUS_TOKEN:
 353     case GSASL_NO_AUTHZID:
 354     case GSASL_NO_PASSWORD:
 355     case GSASL_NO_PASSCODE:
 356     case GSASL_NO_PIN:
 357     case GSASL_BASE64_ERROR:
 358       HDEBUG(D_auth) debug_printf("GNU SASL permanent error: %s (%s)\n",
 359           gsasl_strerror_name(rc), gsasl_strerror(rc));
 360       log_write(0, LOG_REJECT, "%s authenticator (%s):\n  "
 361           "GNU SASL permanent failure: %s (%s)",
 362           ablock->name, ob->server_mech,
 363           gsasl_strerror_name(rc), gsasl_strerror(rc));
 364       if (rc == GSASL_BASE64_ERROR)
 365         exim_error_override = BAD64;
 366       goto STOP_INTERACTION;
 367
 368     default:
 369       auth_defer_msg = string_sprintf("GNU SASL temporary error: %s (%s)",
 370           gsasl_strerror_name(rc), gsasl_strerror(rc));
 371       HDEBUG(D_auth) debug_printf("%s\n", auth_defer_msg);
 372       exim_error_override = DEFER;
 373       goto STOP_INTERACTION;
 374     }
 375
 376   if ((rc == GSASL_NEEDS_MORE) ||
 377       (to_send && *to_send))
 378     exim_error =
 379       auth_get_no64_data((uschar **)&received, US to_send);
 380
 381   if (to_send)
 382     {
 383     free(to_send);
 384     to_send = NULL;
 385     }
 386
 387   if (exim_error)
 388     break; /* handles * cancelled check */
 389
 390   } while (rc == GSASL_NEEDS_MORE);
 391
 392 STOP_INTERACTION:
 393 auth_result = rc;
 394
 395 gsasl_finish(sctx);
 396
 397 /* Can return: OK DEFER FAIL CANCELLED BAD64 UNEXPECTED */
 398
 399 if (exim_error != OK)
 400   return exim_error;
 401
 402 if (auth_result != GSASL_OK)
 403   {
 404   HDEBUG(D_auth) debug_printf("authentication returned %s (%s)\n",
 405       gsasl_strerror_name(auth_result), gsasl_strerror(auth_result));
 406   if (exim_error_override != OK)
 407     return exim_error_override; /* might be DEFER */
 408   if (sasl_error_should_defer) /* overriding auth failure SASL error */
 409     return DEFER;
 410   return FAIL;
 411   }
 412
 413 /* Auth succeeded, check server_condition unless already done in callback */
 414 return checked_server_condition ? OK : auth_check_serv_cond(ablock);
 415 }
 416
 417
 418 /* returns the GSASL status of expanding the Exim string given */
 419 static int
 420 condition_check(auth_instance *ablock, uschar *label, uschar *condition_string)
 421 {
 422 int exim_rc;
 423
 424 exim_rc = auth_check_some_cond(ablock, label, condition_string, FAIL);
 425
 426 if (exim_rc == OK)
 427   return GSASL_OK;
 428 else if (exim_rc == DEFER)
 429   {
 430   sasl_error_should_defer = TRUE;
 431   return GSASL_AUTHENTICATION_ERROR;
 432   }
 433 else if (exim_rc == FAIL)
 434   return GSASL_AUTHENTICATION_ERROR;
 435
 436 log_write(0, LOG_PANIC_DIE|LOG_CONFIG_FOR, "%s authenticator:  "
 437           "Unhandled return from checking %s: %d",
 438           ablock->name, label, exim_rc);
 439 /* NOTREACHED */
 440 return GSASL_AUTHENTICATION_ERROR;
 441 }
 442
 443 static int
 444 server_callback(Gsasl *ctx, Gsasl_session *sctx, Gsasl_property prop, auth_instance *ablock)
 445 {
 446 char *tmps;
 447 uschar *propval;
 448 int cbrc = GSASL_NO_CALLBACK;
 449 auth_gsasl_options_block *ob =
 450   (auth_gsasl_options_block *)(ablock->options_block);
 451
 452 HDEBUG(D_auth)
 453   debug_printf("GNU SASL callback %d for %s/%s as server\n",
 454       prop, ablock->name, ablock->public_name);
 455
 456 for (int i = 0; i < AUTH_VARS; i++) auth_vars[i] = NULL;
 457 expand_nmax = 0;
 458
 459 switch (prop)
 460   {
 461   case GSASL_VALIDATE_SIMPLE:
 462     /* GSASL_AUTHID, GSASL_AUTHZID, and GSASL_PASSWORD */
 463     propval = US  gsasl_property_fast(sctx, GSASL_AUTHID);
 464     auth_vars[0] = expand_nstring[1] = propval ? propval : US"";
 465     propval = US  gsasl_property_fast(sctx, GSASL_AUTHZID);
 466     auth_vars[1] = expand_nstring[2] = propval ? propval : US"";
 467     propval = US  gsasl_property_fast(sctx, GSASL_PASSWORD);
 468     auth_vars[2] = expand_nstring[3] = propval ? propval : US"";
 469     expand_nmax = 3;
 470     for (int i = 1; i <= 3; ++i)
 471       expand_nlength[i] = Ustrlen(expand_nstring[i]);
 472
 473     cbrc = condition_check(ablock, US"server_condition", ablock->server_condition);
 474     checked_server_condition = TRUE;
 475     break;
 476
 477   case GSASL_VALIDATE_EXTERNAL:
 478     if (ablock->server_condition == NULL)
 479       {
 480       HDEBUG(D_auth) debug_printf("No server_condition supplied, to validate EXTERNAL.\n");
 481       cbrc = GSASL_AUTHENTICATION_ERROR;
 482       break;
 483       }
 484     propval = US  gsasl_property_fast(sctx, GSASL_AUTHZID);
 485     /* We always set $auth1, even if only to empty string. */
 486     auth_vars[0] = expand_nstring[1] = propval ? propval : US"";
 487     expand_nlength[1] = Ustrlen(expand_nstring[1]);
 488     expand_nmax = 1;
 489
 490     cbrc = condition_check(ablock,
 491         US"server_condition (EXTERNAL)", ablock->server_condition);
 492     checked_server_condition = TRUE;
 493     break;
 494
 495   case GSASL_VALIDATE_ANONYMOUS:
 496     if (ablock->server_condition == NULL)
 497       {
 498       HDEBUG(D_auth) debug_printf("No server_condition supplied, to validate ANONYMOUS.\n");
 499       cbrc = GSASL_AUTHENTICATION_ERROR;
 500       break;
 501       }
 502     propval = US  gsasl_property_fast(sctx, GSASL_ANONYMOUS_TOKEN);
 503     /* We always set $auth1, even if only to empty string. */
 504     auth_vars[0] = expand_nstring[1] = propval ? propval : US"";
 505     expand_nlength[1] = Ustrlen(expand_nstring[1]);
 506     expand_nmax = 1;
 507
 508     cbrc = condition_check(ablock,
 509         US"server_condition (ANONYMOUS)", ablock->server_condition);
 510     checked_server_condition = TRUE;
 511     break;
 512
 513   case GSASL_VALIDATE_GSSAPI:
 514     /* GSASL_AUTHZID and GSASL_GSSAPI_DISPLAY_NAME
 515     The display-name is authenticated as part of GSS, the authzid is claimed
 516     by the SASL integration after authentication; protected against tampering
 517     (if the SASL mechanism supports that, which Kerberos does) but is
 518     unverified, same as normal for other mechanisms.
 519
 520     First coding, we had these values swapped, but for consistency and prior
 521     to the first release of Exim with this authenticator, they've been
 522     switched to match the ordering of GSASL_VALIDATE_SIMPLE. */
 523     propval = US  gsasl_property_fast(sctx, GSASL_GSSAPI_DISPLAY_NAME);
 524     auth_vars[0] = expand_nstring[1] = propval ? propval : US"";
 525     propval = US  gsasl_property_fast(sctx, GSASL_AUTHZID);
 526     auth_vars[1] = expand_nstring[2] = propval ? propval : US"";
 527     expand_nmax = 2;
 528     for (int i = 1; i <= 2; ++i)
 529       expand_nlength[i] = Ustrlen(expand_nstring[i]);
 530
 531     /* In this one case, it perhaps makes sense to default back open?
 532     But for consistency, let's just mandate server_condition here too. */
 533     cbrc = condition_check(ablock,
 534         US"server_condition (GSSAPI family)", ablock->server_condition);
 535     checked_server_condition = TRUE;
 536     break;
 537
 538   case GSASL_PASSWORD:
 539     /* DIGEST-MD5: GSASL_AUTHID, GSASL_AUTHZID and GSASL_REALM
 540        CRAM-MD5: GSASL_AUTHID
 541        PLAIN: GSASL_AUTHID and GSASL_AUTHZID
 542        LOGIN: GSASL_AUTHID
 543      */
 544     if (ob->server_scram_iter)
 545       {
 546       tmps = CS expand_string(ob->server_scram_iter);
 547       gsasl_property_set(sctx, GSASL_SCRAM_ITER, tmps);
 548       }
 549     if (ob->server_scram_salt)
 550       {
 551       tmps = CS expand_string(ob->server_scram_salt);
 552       gsasl_property_set(sctx, GSASL_SCRAM_SALT, tmps);
 553       }
 554     /* Asking for GSASL_AUTHZID calls back into us if we use
 555     gsasl_property_get(), thus the use of gsasl_property_fast().
 556     Do we really want to hardcode limits per mechanism?  What happens when
 557     a new mechanism is added to the library.  It *shouldn't* result in us
 558     needing to add more glue, since avoiding that is a large part of the
 559     point of SASL. */
 560     propval = US  gsasl_property_fast(sctx, GSASL_AUTHID);
 561     auth_vars[0] = expand_nstring[1] = propval ? propval : US"";
 562     propval = US  gsasl_property_fast(sctx, GSASL_AUTHZID);
 563     auth_vars[1] = expand_nstring[2] = propval ? propval : US"";
 564     propval = US  gsasl_property_fast(sctx, GSASL_REALM);
 565     auth_vars[2] = expand_nstring[3] = propval ? propval : US"";
 566     expand_nmax = 3;
 567     for (int i = 1; i <= 3; ++i)
 568       expand_nlength[i] = Ustrlen(expand_nstring[i]);
 569
 570     tmps = CS expand_string(ob->server_password);
 571     if (tmps == NULL)
 572       {
 573       sasl_error_should_defer = f.expand_string_forcedfail ? FALSE : TRUE;
 574       HDEBUG(D_auth) debug_printf("server_password expansion failed, so "
 575           "can't tell GNU SASL library the password for %s\n", auth_vars[0]);
 576       return GSASL_AUTHENTICATION_ERROR;
 577       }
 578     gsasl_property_set(sctx, GSASL_PASSWORD, tmps);
 579     /* This is inadequate; don't think Exim's store stacks are geared
 580     for memory wiping, so expanding strings will leave stuff laying around.
 581     But no need to compound the problem, so get rid of the one we can. */
 582     memset(tmps, '\0', strlen(tmps));
 583     cbrc = GSASL_OK;
 584     break;
 585
 586   default:
 587     HDEBUG(D_auth) debug_printf("Unrecognised callback: %d\n", prop);
 588     cbrc = GSASL_NO_CALLBACK;
 589   }
 590
 591 HDEBUG(D_auth) debug_printf("Returning %s (%s)\n",
 592     gsasl_strerror_name(cbrc), gsasl_strerror(cbrc));
 593
 594 return cbrc;
 595 }
 596
 597
 598 /*************************************************
 599 *              Client entry point                *
 600 *************************************************/
 601
 602 /* For interface, see auths/README */
 603
 604 int
 605 auth_gsasl_client(
 606   auth_instance *ablock,                /* authenticator block */
 607   smtp_inblock * sx,                    /* connection */
 608   int timeout,                          /* command timeout */
 609   uschar *buffer,                       /* buffer for reading response */
 610   int buffsize)                         /* size of buffer */
 611 {
 612 HDEBUG(D_auth)
 613   debug_printf("Client side NOT IMPLEMENTED: you should not see this!\n");
 614 /* NOT IMPLEMENTED */
 615 return FAIL;
 616 }
 617
 618 static int
 619 client_callback(Gsasl *ctx, Gsasl_session *sctx, Gsasl_property prop, auth_instance *ablock)
 620 {
 621 int cbrc = GSASL_NO_CALLBACK;
 622 HDEBUG(D_auth)
 623   debug_printf("GNU SASL callback %d for %s/%s as client\n",
 624       prop, ablock->name, ablock->public_name);
 625
 626 HDEBUG(D_auth)
 627   debug_printf("Client side NOT IMPLEMENTED: you should not see this!\n");
 628
 629 return cbrc;
 630 }
 631
 632 /*************************************************
 633 *                Diagnostic API                  *
 634 *************************************************/
 635
 636 void
 637 auth_gsasl_version_report(FILE *f)
 638 {
 639 const char *runtime;
 640 runtime = gsasl_check_version(NULL);
 641 fprintf(f, "Library version: GNU SASL: Compile: %s\n"
 642            "                           Runtime: %s\n",
 643         GSASL_VERSION, runtime);
 644 }
 645
 646 #endif   /*!MACRO_PREDEF*/
 647 #endif  /* AUTH_GSASL */
 648
 649 /* End of gsasl_exim.c */