mutt_sasl.c

   1 /*
   2  * Copyright notice from original mutt:
   3  * Copyright (C) 2000-5 Brendan Cully <brendan@kublai.com>
   4  *
   5  * This file is part of mutt-ng, see http://www.muttng.org/.
   6  * It's licensed under the GNU General Public License,
   7  * please see the file GPL in the top level source directory.
   8  */
   9
  10 /* common SASL helper routines */
  11
  12 #if HAVE_CONFIG_H
  13 # include "config.h"
  14 #endif
  15
  16 #include <errno.h>
  17 #include <netdb.h>
  18 #include <sasl/sasl.h>
  19 #include <sys/socket.h>
  20 #include <netinet/in.h>
  21
  22 #include <lib-lib/lib-lib.h>
  23 #include <lib-ui/curses.h>
  24 #include <lib-sys/mutt_socket.h>
  25
  26 #include "mutt.h"
  27 #include "account.h"
  28 #include "mutt_sasl.h"
  29
  30 static int getnameinfo_err (int ret)
  31 {
  32   int err;
  33
  34   switch (ret) {
  35   case EAI_AGAIN:
  36     err = SASL_TRYAGAIN;
  37     break;
  38   case EAI_BADFLAGS:
  39     err = SASL_BADPARAM;
  40     break;
  41   case EAI_FAIL:
  42     err = SASL_FAIL;
  43     break;
  44   case EAI_FAMILY:
  45     err = SASL_BADPROT;
  46     break;
  47   case EAI_MEMORY:
  48     err = SASL_NOMEM;
  49     break;
  50   case EAI_NONAME:
  51     err = SASL_FAIL;            /* no real equivalent */
  52     break;
  53   case EAI_SYSTEM:
  54     err = SASL_FAIL;            /* no real equivalent */
  55     break;
  56   default:
  57     err = SASL_FAIL;            /* no real equivalent */
  58     break;
  59   }
  60   return err;
  61 }
  62
  63 /* arbitrary. SASL will probably use a smaller buffer anyway. OTOH it's
  64  * been a while since I've had access to an SASL server which negotiated
  65  * a protection buffer. */
  66 #define M_SASL_MAXBUF 65536
  67
  68 #define IP_PORT_BUFLEN 1024
  69
  70 static sasl_callback_t mutt_sasl_callbacks[5];
  71
  72 static int mutt_sasl_start (void);
  73
  74 /* callbacks */
  75 static int mutt_sasl_cb_authname (void *context, int id, const char **result,
  76                                   unsigned int *len);
  77 static int mutt_sasl_cb_pass (sasl_conn_t * conn, void *context, int id,
  78                               sasl_secret_t ** psecret);
  79
  80 /* socket wrappers for a SASL security layer */
  81 static int mutt_sasl_conn_open (CONNECTION * conn);
  82 static int mutt_sasl_conn_close (CONNECTION * conn);
  83 static int mutt_sasl_conn_read (CONNECTION * conn, char *buf, ssize_t len);
  84 static int mutt_sasl_conn_write (CONNECTION * conn, const char *buf,
  85                                  ssize_t count);
  86
  87 /* utility function, stolen from sasl2 sample code */
  88 static int iptostring (const struct sockaddr *addr, socklen_t addrlen,
  89                        char *out, unsigned outlen)
  90 {
  91   char hbuf[NI_MAXHOST], pbuf[NI_MAXSERV];
  92   int ret;
  93
  94   if (!addr || !out)
  95     return SASL_BADPARAM;
  96
  97   ret = getnameinfo (addr, addrlen, hbuf, sizeof (hbuf), pbuf, sizeof (pbuf),
  98                      NI_NUMERICHOST |
  99 #ifdef NI_WITHSCOPEID
 100                      NI_WITHSCOPEID |
 101 #endif
 102                      NI_NUMERICSERV);
 103   if (ret)
 104     return getnameinfo_err (ret);
 105
 106   if (outlen < m_strlen(hbuf) + m_strlen(pbuf) + 2)
 107     return SASL_BUFOVER;
 108
 109   snprintf (out, outlen, "%s;%s", hbuf, pbuf);
 110
 111   return SASL_OK;
 112 }
 113
 114 /* mutt_sasl_cb_log: callback to log SASL messages */
 115 static int mutt_sasl_cb_log (void *context, int priority, const char *message)
 116 {
 117   return SASL_OK;
 118 }
 119
 120 /* mutt_sasl_start: called before doing a SASL exchange - initialises library
 121  *   (if necessary). */
 122 int mutt_sasl_start (void)
 123 {
 124   static unsigned char sasl_init = 0;
 125
 126   static sasl_callback_t callbacks[2];
 127   int rc;
 128
 129   if (sasl_init)
 130     return SASL_OK;
 131
 132   /* set up default logging callback */
 133   callbacks[0].id = SASL_CB_LOG;
 134   callbacks[0].proc = mutt_sasl_cb_log;
 135   callbacks[0].context = NULL;
 136
 137   callbacks[1].id = SASL_CB_LIST_END;
 138   callbacks[1].proc = NULL;
 139   callbacks[1].context = NULL;
 140
 141   rc = sasl_client_init (callbacks);
 142
 143   if (rc != SASL_OK) {
 144     return SASL_FAIL;
 145   }
 146
 147   sasl_init = 1;
 148
 149   return SASL_OK;
 150 }
 151
 152 /* mutt_sasl_client_new: wrapper for sasl_client_new which also sets various
 153  * security properties. If this turns out to be fine for POP too we can
 154  * probably stop exporting mutt_sasl_get_callbacks(). */
 155 int mutt_sasl_client_new (CONNECTION * conn, sasl_conn_t ** saslconn)
 156 {
 157   sasl_security_properties_t secprops;
 158
 159   struct sockaddr_storage local, remote;
 160   socklen_t size;
 161   char iplocalport[IP_PORT_BUFLEN], ipremoteport[IP_PORT_BUFLEN];
 162   const char *service;
 163   int rc;
 164
 165   if (mutt_sasl_start () != SASL_OK)
 166     return -1;
 167
 168   switch (conn->account.type) {
 169   case M_ACCT_TYPE_IMAP:
 170     service = "imap";
 171     break;
 172   case M_ACCT_TYPE_POP:
 173     service = "pop";
 174     break;
 175   default:
 176     return -1;
 177   }
 178
 179   size = sizeof (local);
 180   if (getsockname (conn->fd, (struct sockaddr *) &local, &size)) {
 181     return -1;
 182   }
 183   else
 184     if (iptostring((struct sockaddr *)&local, size, iplocalport,
 185          IP_PORT_BUFLEN) != SASL_OK) {
 186     return -1;
 187   }
 188
 189   size = sizeof (remote);
 190   if (getpeername (conn->fd, (struct sockaddr *) &remote, &size)) {
 191     return -1;
 192   }
 193   else
 194     if (iptostring
 195         ((struct sockaddr *) &remote, size, ipremoteport,
 196          IP_PORT_BUFLEN) != SASL_OK) {
 197     return -1;
 198   }
 199
 200   rc = sasl_client_new(service, conn->account.host, iplocalport, ipremoteport,
 201                        mutt_sasl_get_callbacks(&conn->account), 0, saslconn);
 202
 203   if (rc != SASL_OK) {
 204     return -1;
 205   }
 206
 207   /*** set sasl IP properties, necessary for use with krb4 ***/
 208   /* Do we need to fail if this fails? I would assume having these unset
 209    * would just disable KRB4. Who wrote this code?
 210    */
 211   {
 212     struct sockaddr_in local, remote;
 213     socklen_t size;
 214
 215     size = sizeof (local);
 216     if (getsockname (conn->fd, (struct sockaddr *) &local, &size))
 217       return -1;
 218
 219     size = sizeof (remote);
 220     if (getpeername (conn->fd, (struct sockaddr *) &remote, &size))
 221       return -1;
 222
 223 #ifdef SASL_IP_LOCAL
 224     if (sasl_setprop (*saslconn, SASL_IP_LOCAL, &local) != SASL_OK) {
 225       return -1;
 226     }
 227 #endif
 228
 229 #ifdef SASL_IP_REMOTE
 230     if (sasl_setprop (*saslconn, SASL_IP_REMOTE, &remote) != SASL_OK) {
 231       return -1;
 232     }
 233 #endif
 234   }
 235
 236   /* set security properties. We use NOPLAINTEXT globally, since we can
 237    * just fall back to LOGIN in the IMAP case anyway. If that doesn't
 238    * work for POP, we can make it a flag or move this code into
 239    * imap/auth_sasl.c */
 240   p_clear(&secprops, 1);
 241   /* Work around a casting bug in the SASL krb4 module */
 242   secprops.max_ssf = 0x7fff;
 243   secprops.maxbufsize = M_SASL_MAXBUF;
 244   secprops.security_flags |= SASL_SEC_NOPLAINTEXT;
 245   if (sasl_setprop (*saslconn, SASL_SEC_PROPS, &secprops) != SASL_OK) {
 246     return -1;
 247   }
 248
 249   if (conn->ssf) {
 250     if (sasl_setprop (*saslconn, SASL_SSF_EXTERNAL, &(conn->ssf)) != SASL_OK)
 251     {
 252       return -1;
 253     }
 254     if (sasl_setprop (*saslconn, SASL_AUTH_EXTERNAL, conn->account.user) !=
 255         SASL_OK) {
 256       return -1;
 257     }
 258   }
 259
 260   return 0;
 261 }
 262
 263 sasl_callback_t *mutt_sasl_get_callbacks (ACCOUNT * account)
 264 {
 265   sasl_callback_t *callback;
 266
 267   callback = mutt_sasl_callbacks;
 268
 269   callback->id = SASL_CB_USER;
 270   callback->proc = mutt_sasl_cb_authname;
 271   callback->context = account;
 272   callback++;
 273
 274   callback->id = SASL_CB_AUTHNAME;
 275   callback->proc = mutt_sasl_cb_authname;
 276   callback->context = account;
 277   callback++;
 278
 279   callback->id = SASL_CB_PASS;
 280   callback->proc = mutt_sasl_cb_pass;
 281   callback->context = account;
 282   callback++;
 283
 284   callback->id = SASL_CB_GETREALM;
 285   callback->proc = NULL;
 286   callback->context = NULL;
 287   callback++;
 288
 289   callback->id = SASL_CB_LIST_END;
 290   callback->proc = NULL;
 291   callback->context = NULL;
 292
 293   return mutt_sasl_callbacks;
 294 }
 295
 296 int mutt_sasl_interact (sasl_interact_t * interaction)
 297 {
 298   char prompt[SHORT_STRING];
 299   char resp[SHORT_STRING];
 300
 301   while (interaction->id != SASL_CB_LIST_END) {
 302     snprintf (prompt, sizeof (prompt), "%s: ", interaction->prompt);
 303     resp[0] = '\0';
 304     if (mutt_get_field (prompt, resp, sizeof (resp), 0))
 305       return SASL_FAIL;
 306
 307     interaction->len = m_strlen(resp) + 1;
 308     interaction->result = p_dupstr(resp, interaction->len - 1);
 309     interaction++;
 310   }
 311
 312   return SASL_OK;
 313 }
 314
 315 /* SASL can stack a protection layer on top of an existing connection.
 316  * To handle this, we store a saslconn_t in conn->sockdata, and write
 317  * wrappers which en/decode the read/write stream, then replace sockdata
 318  * with an embedded copy of the old sockdata and call the underlying
 319  * functions (which we've also preserved). I thought about trying to make
 320  * a general stackable connection system, but it seemed like overkill -
 321  * something is wrong if we have 15 filters on top of a socket. Anyway,
 322  * anything else which wishes to stack can use the same method. The only
 323  * disadvantage is we have to write wrappers for all the socket methods,
 324  * even if we only stack over read and write. Thinking about it, the
 325  * abstraction problem is that there is more in CONNECTION than there
 326  * needs to be. Ideally it would have only (void*)data and methods. */
 327
 328 /* mutt_sasl_setup_conn: replace connection methods, sockdata with
 329  *   SASL wrappers, for protection layers. Also get ssf, as a fastpath
 330  *   for the read/write methods. */
 331 void mutt_sasl_setup_conn (CONNECTION * conn, sasl_conn_t * saslconn)
 332 {
 333   SASL_DATA *sasldata = p_new(SASL_DATA, 1);
 334
 335   sasldata->saslconn = saslconn;
 336   /* get ssf so we know whether we have to (en|de)code read/write */
 337   sasl_getprop (saslconn, SASL_SSF, (const void **)(void *)&sasldata->ssf);
 338
 339   /* Add SASL SSF to transport SSF */
 340   conn->ssf += *sasldata->ssf;
 341   sasl_getprop (saslconn, SASL_MAXOUTBUF,
 342                 (const void **)(void *)&sasldata->pbufsize);
 343
 344   /* clear input buffer */
 345   sasldata->buf = NULL;
 346   sasldata->bpos = 0;
 347   sasldata->blen = 0;
 348
 349   /* preserve old functions */
 350   sasldata->sockdata = conn->sockdata;
 351   sasldata->msasl_open = conn->conn_open;
 352   sasldata->msasl_close = conn->conn_close;
 353   sasldata->msasl_read = conn->conn_read;
 354   sasldata->msasl_write = conn->conn_write;
 355
 356   /* and set up new functions */
 357   conn->sockdata = sasldata;
 358   conn->conn_open = mutt_sasl_conn_open;
 359   conn->conn_close = mutt_sasl_conn_close;
 360   conn->conn_read = mutt_sasl_conn_read;
 361   conn->conn_write = mutt_sasl_conn_write;
 362 }
 363
 364 void mutt_sasl_done (void) {
 365   sasl_done ();
 366 }
 367
 368 /* mutt_sasl_cb_authname: callback to retrieve authname or user from ACCOUNT */
 369 static int mutt_sasl_cb_authname (void *context, int id, const char **result,
 370                                   unsigned *len)
 371 {
 372   ACCOUNT *account = (ACCOUNT *) context;
 373
 374   *result = NULL;
 375   if (len)
 376     *len = 0;
 377
 378   if (!account)
 379     return SASL_BADPARAM;
 380
 381   if (id == SASL_CB_AUTHNAME) {
 382     if (mutt_account_getlogin (account))
 383       return SASL_FAIL;
 384     *result = account->login;
 385   } else {
 386     if (mutt_account_getuser (account))
 387       return SASL_FAIL;
 388     *result = account->user;
 389   }
 390
 391   if (len)
 392     *len = m_strlen(*result);
 393
 394   return SASL_OK;
 395 }
 396
 397 static int mutt_sasl_cb_pass (sasl_conn_t * conn, void *context, int id,
 398                               sasl_secret_t ** psecret)
 399 {
 400   ACCOUNT *account = (ACCOUNT *) context;
 401   int len;
 402
 403   if (!account || !psecret)
 404     return SASL_BADPARAM;
 405
 406   if (mutt_account_getpass (account))
 407     return SASL_FAIL;
 408
 409   len = m_strlen(account->pass);
 410
 411   *psecret = xmalloc(sizeof(sasl_secret_t) + len);
 412   (*psecret)->len = len;
 413   strcpy ((char*) (*psecret)->data, account->pass);     /* __STRCPY_CHECKED__ */
 414
 415   return SASL_OK;
 416 }
 417
 418 /* mutt_sasl_conn_open: empty wrapper for underlying open function. We
 419  *   don't know in advance that a connection will use SASL, so we
 420  *   replace conn's methods with sasl methods when authentication
 421  *   is successful, using mutt_sasl_setup_conn */
 422 static int mutt_sasl_conn_open (CONNECTION * conn)
 423 {
 424   SASL_DATA *sasldata;
 425   int rc;
 426
 427   sasldata = (SASL_DATA *) conn->sockdata;
 428   conn->sockdata = sasldata->sockdata;
 429   rc = (sasldata->msasl_open) (conn);
 430   conn->sockdata = sasldata;
 431
 432   return rc;
 433 }
 434
 435 /* mutt_sasl_conn_close: calls underlying close function and disposes of
 436  *   the sasl_conn_t object, then restores connection to pre-sasl state */
 437 static int mutt_sasl_conn_close (CONNECTION * conn)
 438 {
 439   SASL_DATA *sasldata;
 440   int rc;
 441
 442   sasldata = (SASL_DATA *) conn->sockdata;
 443
 444   /* restore connection's underlying methods */
 445   conn->sockdata = sasldata->sockdata;
 446   conn->conn_open = sasldata->msasl_open;
 447   conn->conn_close = sasldata->msasl_close;
 448   conn->conn_read = sasldata->msasl_read;
 449   conn->conn_write = sasldata->msasl_write;
 450
 451   /* release sasl resources */
 452   sasl_dispose (&sasldata->saslconn);
 453   p_delete(&sasldata->buf);
 454   p_delete(&sasldata);
 455
 456   /* call underlying close */
 457   rc = (conn->conn_close) (conn);
 458
 459   return rc;
 460 }
 461
 462 static int mutt_sasl_conn_read (CONNECTION * conn, char *buf, ssize_t len)
 463 {
 464   SASL_DATA *sasldata;
 465   int rc;
 466
 467   unsigned int olen;
 468
 469   sasldata = (SASL_DATA *) conn->sockdata;
 470
 471   /* if we still have data in our read buffer, copy it into buf */
 472   if (sasldata->blen > sasldata->bpos) {
 473     olen = (sasldata->blen - sasldata->bpos > len) ? len :
 474       sasldata->blen - sasldata->bpos;
 475
 476     memcpy (buf, sasldata->buf + sasldata->bpos, olen);
 477     sasldata->bpos += olen;
 478
 479     return olen;
 480   }
 481
 482   conn->sockdata = sasldata->sockdata;
 483
 484   p_delete(&sasldata->buf);
 485   sasldata->bpos = 0;
 486   sasldata->blen = 0;
 487
 488   /* and decode the result, if necessary */
 489   if (*sasldata->ssf) {
 490     do {
 491       /* call the underlying read function to fill the buffer */
 492       rc = (sasldata->msasl_read) (conn, buf, len);
 493       if (rc <= 0)
 494         goto out;
 495
 496       rc = sasl_decode (sasldata->saslconn, buf, rc, &sasldata->buf,
 497                         &sasldata->blen);
 498       if (rc != SASL_OK) {
 499         goto out;
 500       }
 501     }
 502     while (!sasldata->blen);
 503
 504     olen = (sasldata->blen - sasldata->bpos > len) ? len :
 505       sasldata->blen - sasldata->bpos;
 506
 507     memcpy (buf, sasldata->buf, olen);
 508     sasldata->bpos += olen;
 509
 510     rc = olen;
 511   }
 512   else
 513     rc = (sasldata->msasl_read) (conn, buf, len);
 514
 515 out:
 516   conn->sockdata = sasldata;
 517
 518   return rc;
 519 }
 520
 521 static int mutt_sasl_conn_write (CONNECTION * conn, const char *buf,
 522                                  ssize_t len)
 523 {
 524   SASL_DATA *sasldata;
 525   int rc;
 526
 527   const char *pbuf;
 528   unsigned int olen, plen;
 529
 530   sasldata = (SASL_DATA *) conn->sockdata;
 531   conn->sockdata = sasldata->sockdata;
 532
 533   /* encode data, if necessary */
 534   if (*sasldata->ssf) {
 535     /* handle data larger than MAXOUTBUF */
 536     do {
 537       olen = (len > *sasldata->pbufsize) ? *sasldata->pbufsize : len;
 538
 539       rc = sasl_encode (sasldata->saslconn, buf, olen, &pbuf, &plen);
 540       if (rc != SASL_OK) {
 541         goto fail;
 542       }
 543
 544       rc = (sasldata->msasl_write) (conn, pbuf, plen);
 545       p_delete(&pbuf);
 546       if (rc != plen)
 547         goto fail;
 548
 549       len -= olen;
 550       buf += olen;
 551     }
 552     while (len > *sasldata->pbufsize);
 553   }
 554   else
 555     /* just write using the underlying socket function */
 556     rc = (sasldata->msasl_write) (conn, buf, len);
 557
 558   conn->sockdata = sasldata;
 559
 560   return rc;
 561
 562 fail:
 563   conn->sockdata = sasldata;
 564   return -1;
 565 }