imap/auth_gss.c

   1 /*
   2  * Copyright (C) 1999-2000 Brendan Cully <brendan@kublai.com>
   3  *
   4  *     This program is free software; you can redistribute it and/or modify
   5  *     it under the terms of the GNU General Public License as published by
   6  *     the Free Software Foundation; either version 2 of the License, or
   7  *     (at your option) any later version.
   8  *
   9  *     This program is distributed in the hope that it will be useful,
  10  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *     GNU General Public License for more details.
  13  *
  14  *     You should have received a copy of the GNU General Public License
  15  *     along with this program; if not, write to the Free Software
  16  *     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  17  */
  18
  19 /* GSS login/authentication code */
  20
  21 #if HAVE_CONFIG_H
  22 # include "config.h"
  23 #endif
  24
  25 #include "mutt.h"
  26 #include "imap_private.h"
  27 #include "auth.h"
  28
  29 #include <netinet/in.h>
  30
  31 #ifdef HAVE_HEIMDAL
  32 #  include <gssapi/gssapi.h>
  33 #  define gss_nt_service_name GSS_C_NT_HOSTBASED_SERVICE
  34 #else
  35 #  include <gssapi/gssapi.h>
  36 #  include <gssapi/gssapi_generic.h>
  37 #endif
  38
  39 #define GSS_BUFSIZE 8192
  40
  41 #define GSS_AUTH_P_NONE      1
  42 #define GSS_AUTH_P_INTEGRITY 2
  43 #define GSS_AUTH_P_PRIVACY   4
  44
  45 /* imap_auth_gss: AUTH=GSSAPI support. */
  46 imap_auth_res_t imap_auth_gss (IMAP_DATA* idata, const char* method)
  47 {
  48   gss_buffer_desc request_buf, send_token;
  49   gss_buffer_t sec_token;
  50   gss_name_t target_name;
  51   gss_ctx_id_t context;
  52   gss_OID mech_name;
  53   gss_qop_t quality;
  54   int cflags;
  55   OM_uint32 maj_stat, min_stat;
  56   char buf1[GSS_BUFSIZE], buf2[GSS_BUFSIZE], server_conf_flags;
  57   unsigned long buf_size;
  58   int rc;
  59
  60   if (!mutt_bit_isset (idata->capabilities, AGSSAPI))
  61     return IMAP_AUTH_UNAVAIL;
  62
  63   if (mutt_account_getuser (&idata->conn->account))
  64     return IMAP_AUTH_FAILURE;
  65
  66   /* get an IMAP service ticket for the server */
  67   snprintf (buf1, sizeof (buf1), "imap@%s", idata->conn->account.host);
  68   request_buf.value = buf1;
  69   request_buf.length = strlen (buf1) + 1;
  70   maj_stat = gss_import_name (&min_stat, &request_buf, gss_nt_service_name,
  71     &target_name);
  72   if (maj_stat != GSS_S_COMPLETE)
  73   {
  74     dprint (2, (debugfile, "Couldn't get service name for [%s]\n", buf1));
  75     return IMAP_AUTH_UNAVAIL;
  76   }
  77 #ifdef DEBUG
  78   else if (debuglevel >= 2)
  79   {
  80     maj_stat = gss_display_name (&min_stat, target_name, &request_buf,
  81       &mech_name);
  82     dprint (2, (debugfile, "Using service name [%s]\n",
  83       (char*) request_buf.value));
  84     maj_stat = gss_release_buffer (&min_stat, &request_buf);
  85   }
  86 #endif
  87   /* Acquire initial credentials - without a TGT GSSAPI is UNAVAIL */
  88   sec_token = GSS_C_NO_BUFFER;
  89   context = GSS_C_NO_CONTEXT;
  90
  91   /* build token */
  92   maj_stat = gss_init_sec_context (&min_stat, GSS_C_NO_CREDENTIAL, &context,
  93     target_name, GSS_C_NO_OID, GSS_C_MUTUAL_FLAG | GSS_C_SEQUENCE_FLAG, 0,
  94     GSS_C_NO_CHANNEL_BINDINGS, sec_token, NULL, &send_token,
  95     (unsigned int*) &cflags, NULL);
  96   if (maj_stat != GSS_S_COMPLETE && maj_stat != GSS_S_CONTINUE_NEEDED)
  97   {
  98     dprint (1, (debugfile, "Error acquiring credentials - no TGT?\n"));
  99     gss_release_name (&min_stat, &target_name);
 100
 101     return IMAP_AUTH_UNAVAIL;
 102   }
 103
 104   /* now begin login */
 105   mutt_message _("Authenticating (GSSAPI)...");
 106
 107   imap_cmd_start (idata, "AUTHENTICATE GSSAPI");
 108
 109   /* expect a null continuation response ("+") */
 110   do
 111     rc = imap_cmd_step (idata);
 112   while (rc == IMAP_CMD_CONTINUE);
 113
 114   if (rc != IMAP_CMD_RESPOND)
 115   {
 116     dprint (2, (debugfile, "Invalid response from server: %s\n", buf1));
 117     gss_release_name (&min_stat, &target_name);
 118     goto bail;
 119   }
 120
 121   /* now start the security context initialisation loop... */
 122   dprint (2, (debugfile, "Sending credentials\n"));
 123   mutt_to_base64 ((unsigned char*) buf1, send_token.value, send_token.length,
 124     sizeof (buf1) - 2);
 125   gss_release_buffer (&min_stat, &send_token);
 126   safe_strcat (buf1, sizeof (buf1), "\r\n");
 127   mutt_socket_write (idata->conn, buf1);
 128
 129   while (maj_stat == GSS_S_CONTINUE_NEEDED)
 130   {
 131     /* Read server data */
 132     do
 133       rc = imap_cmd_step (idata);
 134     while (rc == IMAP_CMD_CONTINUE);
 135
 136     if (rc != IMAP_CMD_RESPOND)
 137     {
 138       dprint (1, (debugfile, "Error receiving server response.\n"));
 139       gss_release_name (&min_stat, &target_name);
 140       goto bail;
 141     }
 142
 143     request_buf.length = mutt_from_base64 (buf2, idata->cmd.buf + 2);
 144     request_buf.value = buf2;
 145     sec_token = &request_buf;
 146
 147     /* Write client data */
 148     maj_stat = gss_init_sec_context (&min_stat, GSS_C_NO_CREDENTIAL, &context,
 149       target_name, GSS_C_NO_OID, GSS_C_MUTUAL_FLAG | GSS_C_SEQUENCE_FLAG, 0,
 150       GSS_C_NO_CHANNEL_BINDINGS, sec_token, NULL, &send_token,
 151       (unsigned int*) &cflags, NULL);
 152     if (maj_stat != GSS_S_COMPLETE && maj_stat != GSS_S_CONTINUE_NEEDED)
 153     {
 154       dprint (1, (debugfile, "Error exchanging credentials\n"));
 155       gss_release_name (&min_stat, &target_name);
 156
 157       goto err_abort_cmd;
 158     }
 159     mutt_to_base64 ((unsigned char*) buf1, send_token.value,
 160       send_token.length, sizeof (buf1) - 2);
 161     gss_release_buffer (&min_stat, &send_token);
 162     safe_strcat (buf1, sizeof (buf1), "\r\n");
 163     mutt_socket_write (idata->conn, buf1);
 164   }
 165
 166   gss_release_name (&min_stat, &target_name);
 167
 168   /* get security flags and buffer size */
 169   do
 170     rc = imap_cmd_step (idata);
 171   while (rc == IMAP_CMD_CONTINUE);
 172
 173   if (rc != IMAP_CMD_RESPOND)
 174   {
 175     dprint (1, (debugfile, "Error receiving server response.\n"));
 176     goto bail;
 177   }
 178   request_buf.length = mutt_from_base64 (buf2, idata->cmd.buf + 2);
 179   request_buf.value = buf2;
 180
 181   maj_stat = gss_unwrap (&min_stat, context, &request_buf, &send_token,
 182     &cflags, &quality);
 183   if (maj_stat != GSS_S_COMPLETE)
 184   {
 185     dprint (2, (debugfile, "Couldn't unwrap security level data\n"));
 186     gss_release_buffer (&min_stat, &send_token);
 187     goto err_abort_cmd;
 188   }
 189   dprint (2, (debugfile, "Credential exchange complete\n"));
 190
 191   /* first octet is security levels supported. We want NONE */
 192   server_conf_flags = ((char*) send_token.value)[0];
 193   if ( !(((char*) send_token.value)[0] & GSS_AUTH_P_NONE) )
 194   {
 195     dprint (2, (debugfile, "Server requires integrity or privacy\n"));
 196     gss_release_buffer (&min_stat, &send_token);
 197     goto err_abort_cmd;
 198   }
 199
 200   /* we don't care about buffer size if we don't wrap content. But here it is */
 201   ((char*) send_token.value)[0] = 0;
 202   buf_size = ntohl (*((long *) send_token.value));
 203   gss_release_buffer (&min_stat, &send_token);
 204   dprint (2, (debugfile, "Unwrapped security level flags: %c%c%c\n",
 205     server_conf_flags & GSS_AUTH_P_NONE      ? 'N' : '-',
 206     server_conf_flags & GSS_AUTH_P_INTEGRITY ? 'I' : '-',
 207     server_conf_flags & GSS_AUTH_P_PRIVACY   ? 'P' : '-'));
 208   dprint (2, (debugfile, "Maximum GSS token size is %ld\n", buf_size));
 209
 210   /* agree to terms (hack!) */
 211   buf_size = htonl (buf_size); /* not relevant without integrity/privacy */
 212   memcpy (buf1, &buf_size, 4);
 213   buf1[0] = GSS_AUTH_P_NONE;
 214   /* server decides if principal can log in as user */
 215   strncpy (buf1 + 4, idata->conn->account.user, sizeof (buf1) - 4);
 216   request_buf.value = buf1;
 217   request_buf.length = 4 + strlen (idata->conn->account.user) + 1;
 218   maj_stat = gss_wrap (&min_stat, context, 0, GSS_C_QOP_DEFAULT, &request_buf,
 219     &cflags, &send_token);
 220   if (maj_stat != GSS_S_COMPLETE)
 221   {
 222     dprint (2, (debugfile, "Error creating login request\n"));
 223     goto err_abort_cmd;
 224   }
 225
 226   mutt_to_base64 ((unsigned char*) buf1, send_token.value, send_token.length,
 227                   sizeof (buf1) - 2);
 228   dprint (2, (debugfile, "Requesting authorisation as %s\n",
 229     idata->conn->account.user));
 230   safe_strcat (buf1, sizeof (buf1), "\r\n");
 231   mutt_socket_write (idata->conn, buf1);
 232
 233   /* Joy of victory or agony of defeat? */
 234   do
 235     rc = imap_cmd_step (idata);
 236   while (rc == IMAP_CMD_CONTINUE);
 237   if (rc == IMAP_CMD_RESPOND)
 238   {
 239     dprint (1, (debugfile, "Unexpected server continuation request.\n"));
 240     goto err_abort_cmd;
 241   }
 242   if (imap_code (idata->cmd.buf))
 243   {
 244     /* flush the security context */
 245     dprint (2, (debugfile, "Releasing GSS credentials\n"));
 246     maj_stat = gss_delete_sec_context (&min_stat, &context, &send_token);
 247     if (maj_stat != GSS_S_COMPLETE)
 248       dprint (1, (debugfile, "Error releasing credentials\n"));
 249
 250     /* send_token may contain a notification to the server to flush
 251      * credentials. RFC 1731 doesn't specify what to do, and since this
 252      * support is only for authentication, we'll assume the server knows
 253      * enough to flush its own credentials */
 254     gss_release_buffer (&min_stat, &send_token);
 255
 256     return IMAP_AUTH_SUCCESS;
 257   }
 258   else
 259     goto bail;
 260
 261  err_abort_cmd:
 262   mutt_socket_write (idata->conn, "*\r\n");
 263   do
 264     rc = imap_cmd_step (idata);
 265   while (rc == IMAP_CMD_CONTINUE);
 266
 267  bail:
 268   mutt_error _("GSSAPI authentication failed.");
 269   mutt_sleep (2);
 270   return IMAP_AUTH_FAILURE;
 271 }