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