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