pop/pop_auth.c

   1 /*
   2  * Copyright notice from original mutt:
   3  * Copyright (C) 2000-2001 Vsevolod Volkov <vvv@mutt.org.ua>
   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 #if HAVE_CONFIG_H
  11 # include "config.h"
  12 #endif
  13
  14 #include <lib-lib/mem.h>
  15 #include <lib-lib/ascii.h>
  16 #include <lib-lib/macros.h>
  17 #include <lib-hash/hash.h>
  18 #include <lib-lib/debug.h>
  19
  20 #include "mutt.h"
  21 #include "mx.h"
  22 #include "pop.h"
  23
  24
  25 #include <string.h>
  26 #include <unistd.h>
  27
  28 #ifdef USE_SASL
  29 #include <sasl/sasl.h>
  30 #include <sasl/saslutil.h>
  31 #include "mutt_sasl.h"
  32 #endif
  33
  34 #ifdef USE_SASL
  35 /* SASL authenticator */
  36 static pop_auth_res_t pop_auth_sasl (POP_DATA * pop_data, const char *method)
  37 {
  38   sasl_conn_t *saslconn;
  39   sasl_interact_t *interaction = NULL;
  40   int rc;
  41   char buf[LONG_STRING];
  42   char inbuf[LONG_STRING];
  43   const char *mech;
  44
  45 #ifdef USE_SASL
  46   const char *pc = NULL;
  47 #endif
  48   unsigned int len, olen;
  49   unsigned char client_start;
  50
  51   if (mutt_sasl_client_new (pop_data->conn, &saslconn) < 0) {
  52     debug_print (1, ("Error allocating SASL connection.\n"));
  53     return POP_A_FAILURE;
  54   }
  55
  56   if (!method)
  57     method = pop_data->auth_list;
  58
  59   for (;;) {
  60 #ifdef USE_SASL
  61     rc =
  62       sasl_client_start (saslconn, method, &interaction, &pc, &olen, &mech);
  63 #endif
  64     if (rc != SASL_INTERACT)
  65       break;
  66     mutt_sasl_interact (interaction);
  67   }
  68
  69   if (rc != SASL_OK && rc != SASL_CONTINUE) {
  70     debug_print (1, ("Failure starting authentication exchange. No shared mechanisms?\n"));
  71
  72     /* SASL doesn't support suggested mechanisms, so fall back */
  73     return POP_A_UNAVAIL;
  74   }
  75
  76   client_start = (olen > 0);
  77
  78   mutt_message _("Authenticating (SASL)...");
  79
  80   snprintf (buf, sizeof (buf), "AUTH %s", mech);
  81   olen = strlen (buf);
  82
  83   /* looping protocol */
  84   for (;;) {
  85     m_strcpy(buf + olen, sizeof(buf) - olen, "\r\n");
  86     mutt_socket_write (pop_data->conn, buf);
  87     if (mutt_socket_readln (inbuf, sizeof (inbuf), pop_data->conn) < 0) {
  88       sasl_dispose (&saslconn);
  89       pop_data->status = POP_DISCONNECTED;
  90       return POP_A_SOCKET;
  91     }
  92
  93     if (rc != SASL_CONTINUE)
  94       break;
  95
  96 #ifdef USE_SASL
  97     if (!m_strncmp(inbuf, "+ ", 2)
  98         && sasl_decode64 (inbuf, strlen (inbuf), buf, LONG_STRING - 1,
  99                           &len) != SASL_OK)
 100 #endif
 101     {
 102       debug_print (1, ("error base64-decoding server response.\n"));
 103       goto bail;
 104     }
 105
 106     if (!client_start)
 107       for (;;) {
 108       rc = sasl_client_step (saslconn, buf, len, &interaction, &pc, &olen);
 109       if (rc != SASL_INTERACT)
 110         break;
 111       mutt_sasl_interact (interaction);
 112       }
 113     else
 114       client_start = 0;
 115
 116     if (rc != SASL_CONTINUE && (olen == 0 || rc != SASL_OK))
 117       break;
 118
 119     /* send out response, or line break if none needed */
 120     if (pc) {
 121       if (sasl_encode64 (pc, olen, buf, sizeof (buf), &olen) != SASL_OK) {
 122         debug_print (1, ("error base64-encoding client response.\n"));
 123         goto bail;
 124       }
 125
 126       /* sasl_client_st(art|ep) allocate pc with malloc, expect me to
 127        * free it */
 128 #ifndef USE_SASL
 129       p_delete(&pc);
 130 #endif
 131     }
 132   }
 133
 134   if (rc != SASL_OK)
 135     goto bail;
 136
 137   if (!m_strncmp(inbuf, "+OK", 3)) {
 138     mutt_sasl_setup_conn (pop_data->conn, saslconn);
 139     return POP_A_SUCCESS;
 140   }
 141
 142 bail:
 143   sasl_dispose (&saslconn);
 144
 145   /* terminate SASL sessoin if the last responce is not +OK nor -ERR */
 146   if (!m_strncmp(inbuf, "+ ", 2)) {
 147     snprintf (buf, sizeof (buf), "*\r\n");
 148     if (pop_query (pop_data, buf, sizeof (buf)) == PQ_NOT_CONNECTED)
 149       return POP_A_SOCKET;
 150   }
 151
 152   mutt_error _("SASL authentication failed.");
 153
 154   mutt_sleep (2);
 155
 156   return POP_A_FAILURE;
 157 }
 158 #endif
 159
 160 /* Get the server timestamp for APOP authentication */
 161 void pop_apop_timestamp (POP_DATA * pop_data, char *buf)
 162 {
 163   char *p1, *p2;
 164
 165   p_delete(&pop_data->timestamp);
 166
 167   if ((p1 = strchr (buf, '<')) && (p2 = strchr (p1, '>'))) {
 168     p2[1] = '\0';
 169     pop_data->timestamp = m_strdup(p1);
 170   }
 171 }
 172
 173 /* APOP authenticator */
 174 static pop_auth_res_t pop_auth_apop (POP_DATA * pop_data,
 175                                      const char *method __attribute__ ((unused)))
 176 {
 177   MD5_CTX mdContext;
 178   unsigned char digest[16];
 179   char hash[33];
 180   char buf[LONG_STRING];
 181   int i;
 182
 183   if (!pop_data->timestamp)
 184     return POP_A_UNAVAIL;
 185
 186   mutt_message _("Authenticating (APOP)...");
 187
 188   /* Compute the authentication hash to send to the server */
 189   MD5Init (&mdContext);
 190   MD5Update (&mdContext, (unsigned char *) pop_data->timestamp,
 191              strlen (pop_data->timestamp));
 192   MD5Update (&mdContext, (unsigned char *) pop_data->conn->account.pass,
 193              strlen (pop_data->conn->account.pass));
 194   MD5Final (digest, &mdContext);
 195
 196   for (i = 0; i < ssizeof(digest); i++)
 197     sprintf (hash + 2 * i, "%02x", digest[i]);
 198
 199   /* Send APOP command to server */
 200   snprintf(buf, sizeof(buf), "APOP %s %s\r\n", pop_data->conn->account.user,
 201            hash);
 202
 203   switch (pop_query (pop_data, buf, sizeof (buf))) {
 204   case PQ_OK:
 205     return POP_A_SUCCESS;
 206   case PQ_NOT_CONNECTED:
 207     return POP_A_SOCKET;
 208   case PFD_FUNCT_ERROR:
 209   case PQ_ERR:
 210   default:
 211     break;
 212   }
 213
 214   mutt_error ("%s %s", _("APOP authentication failed."), pop_data->err_msg);
 215   mutt_sleep (2);
 216
 217   return POP_A_FAILURE;
 218 }
 219
 220 /* USER authenticator */
 221 static pop_auth_res_t pop_auth_user (POP_DATA * pop_data,
 222                                      const char *method __attribute__ ((unused)))
 223 {
 224   char buf[LONG_STRING];
 225   pop_query_status ret;
 226
 227   if (pop_data->cmd_user == CMD_NOT_AVAILABLE)
 228     return POP_A_UNAVAIL;
 229
 230   mutt_message _("Logging in...");
 231
 232   snprintf (buf, sizeof (buf), "USER %s\r\n", pop_data->conn->account.user);
 233   ret = pop_query (pop_data, buf, sizeof (buf));
 234
 235   if (pop_data->cmd_user == CMD_UNKNOWN) {
 236     if (ret == PQ_OK) {
 237       pop_data->cmd_user = CMD_AVAILABLE;
 238
 239       debug_print (1, ("set USER capability\n"));
 240     }
 241
 242     if (ret == PQ_ERR) {
 243       pop_data->cmd_user = CMD_NOT_AVAILABLE;
 244
 245       debug_print (1, ("unset USER capability\n"));
 246       snprintf (pop_data->err_msg, sizeof (pop_data->err_msg),
 247                 _("Command USER is not supported by server."));
 248     }
 249   }
 250
 251   if (ret == PQ_OK) {
 252     snprintf (buf, sizeof (buf), "PASS %s\r\n", pop_data->conn->account.pass);
 253     ret = pop_query_d (pop_data, buf, sizeof (buf),
 254 #ifdef DEBUG
 255     /* don't print the password unless we're at the ungodly debugging level */
 256     DebugLevel < M_SOCK_LOG_FULL ? "PASS *\r\n" :
 257 #endif
 258     NULL);
 259   }
 260
 261   switch (ret) {
 262   case PQ_OK:
 263     return POP_A_SUCCESS;
 264   case PQ_NOT_CONNECTED:
 265     return POP_A_SOCKET;
 266   case PFD_FUNCT_ERROR:
 267   case PQ_ERR:
 268   default:
 269     break;
 270   }
 271
 272   mutt_error ("%s %s", _("Login failed."), pop_data->err_msg);
 273   mutt_sleep (2);
 274
 275   return POP_A_FAILURE;
 276 }
 277
 278 static pop_auth_t pop_authenticators[] = {
 279 #ifdef USE_SASL
 280   {pop_auth_sasl, NULL},
 281 #endif
 282   {pop_auth_apop, "apop"},
 283   {pop_auth_user, "user"},
 284   {NULL, NULL}
 285 };
 286
 287 /*
 288  * Authentication
 289  *  0 - successful,
 290  * -1 - conection lost,
 291  * -2 - login failed,
 292  * -3 - authentication canceled.
 293 */
 294 pop_query_status pop_authenticate (POP_DATA * pop_data)
 295 {
 296   ACCOUNT *act = &pop_data->conn->account;
 297   pop_auth_t *authenticator;
 298   char *methods;
 299   char *comma;
 300   char *method;
 301   int attempts = 0;
 302   int ret = POP_A_UNAVAIL;
 303
 304   if (mutt_account_getuser (act) || !act->user[0] ||
 305       mutt_account_getpass (act) || !act->pass[0])
 306     return PFD_FUNCT_ERROR;
 307
 308   if (PopAuthenticators && *PopAuthenticators) {
 309     /* Try user-specified list of authentication methods */
 310     methods = m_strdup(PopAuthenticators);
 311     method = methods;
 312
 313     while (method) {
 314       comma = strchr (method, ':');
 315       if (comma)
 316         *comma++ = '\0';
 317       debug_print (2, ("Trying method %s\n", method));
 318       authenticator = pop_authenticators;
 319
 320       while (authenticator->authenticate) {
 321         if (!authenticator->method ||
 322             !ascii_strcasecmp (authenticator->method, method)) {
 323           ret = authenticator->authenticate (pop_data, method);
 324           if (ret == POP_A_SOCKET)
 325             switch (pop_connect (pop_data)) {
 326             case PQ_OK:
 327               {
 328                 ret = authenticator->authenticate (pop_data, method);
 329                 break;
 330               }
 331             case PQ_ERR:
 332               ret = POP_A_FAILURE;
 333             }
 334
 335           if (ret != POP_A_UNAVAIL)
 336             attempts++;
 337           if (ret == POP_A_SUCCESS || ret == POP_A_SOCKET ||
 338               (ret == POP_A_FAILURE && !option (OPTPOPAUTHTRYALL))) {
 339             comma = NULL;
 340             break;
 341           }
 342         }
 343         authenticator++;
 344       }
 345
 346       method = comma;
 347     }
 348
 349     p_delete(&methods);
 350   }
 351   else {
 352     /* Fall back to default: any authenticator */
 353     debug_print (2, ("Using any available method.\n"));
 354     authenticator = pop_authenticators;
 355
 356     while (authenticator->authenticate) {
 357       ret = authenticator->authenticate (pop_data, authenticator->method);
 358       if (ret == POP_A_SOCKET)
 359         switch (pop_connect (pop_data)) {
 360         case PQ_OK:
 361           {
 362             ret =
 363               authenticator->authenticate (pop_data, authenticator->method);
 364             break;
 365           }
 366         case PQ_ERR:
 367           ret = POP_A_FAILURE;
 368         }
 369
 370       if (ret != POP_A_UNAVAIL)
 371         attempts++;
 372       if (ret == POP_A_SUCCESS || ret == POP_A_SOCKET ||
 373           (ret == POP_A_FAILURE && !option (OPTPOPAUTHTRYALL)))
 374         break;
 375
 376       authenticator++;
 377     }
 378   }
 379
 380   switch (ret) {
 381   case POP_A_SUCCESS:
 382     return PQ_OK;
 383   case POP_A_SOCKET:
 384     return PQ_NOT_CONNECTED;
 385   case POP_A_UNAVAIL:
 386     if (!attempts)
 387       mutt_error (_("No authenticators available"));
 388   }
 389
 390   return PQ_ERR;
 391 }