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