IMAP Authentication API

Authenticate an IMAP connection. More...

Functions
enum ImapAuthRes	imap_auth_anon (struct ImapAccountData *adata, const char *method)
	Authenticate anonymously - Implements ImapAuth::authenticate() -.
enum ImapAuthRes	imap_auth_cram_md5 (struct ImapAccountData *adata, const char *method)
	Authenticate using CRAM-MD5 - Implements ImapAuth::authenticate() -.
enum ImapAuthRes	imap_auth_gsasl (struct ImapAccountData *adata, const char *method)
	GNU SASL authenticator - Implements ImapAuth::authenticate() -.
enum ImapAuthRes	imap_auth_gss (struct ImapAccountData *adata, const char *method)
	GSS Authentication support - Implements ImapAuth::authenticate() -.
enum ImapAuthRes	imap_auth_login (struct ImapAccountData *adata, const char *method)
	Plain LOGIN support - Implements ImapAuth::authenticate() -.
enum ImapAuthRes	imap_auth_oauth (struct ImapAccountData *adata, const char *method)
	Authenticate an IMAP connection using OAUTHBEARER - Implements ImapAuth::authenticate() -.
enum ImapAuthRes	imap_auth_xoauth2 (struct ImapAccountData *adata, const char *method)
	Authenticate an IMAP connection using XOAUTH2 - Implements ImapAuth::authenticate() -.
enum ImapAuthRes	imap_auth_plain (struct ImapAccountData *adata, const char *method)
	SASL PLAIN support - Implements ImapAuth::authenticate() -.
enum ImapAuthRes	imap_auth_sasl (struct ImapAccountData *adata, const char *method)
	SASL authenticator - Implements ImapAuth::authenticate() -.

Detailed Description

Authenticate an IMAP connection.

Parameters

adata	Imap Account data
method	Use this named method, or any available method if NULL

Return values

ImapAuthRes

Result, e.g. IMAP_AUTH_SUCCESS

Function Documentation

imap_auth_anon()

enum ImapAuthRes imap_auth_anon	(	struct ImapAccountData *	adata,
		const char *	method )

Authenticate anonymously - Implements ImapAuth::authenticate() -.

This is basically a stripped-down version of the cram-md5 method.

Definition at line 42 of file auth_anon.c.

{
  int rc;
 
  if (!(adata->capabilities & IMAP_CAP_AUTH_ANONYMOUS))
    return IMAP_AUTH_UNAVAIL;
 
  if (mutt_account_getuser(&adata->conn->account) < 0)
    return IMAP_AUTH_FAILURE;
 
  if (adata->conn->account.user[0] != '\0')
    return IMAP_AUTH_UNAVAIL;
 
  // L10N: (%s) is the method name, e.g. Anonymous, CRAM-MD5, GSSAPI, SASL
  mutt_message(_("Authenticating (%s)..."), "anonymous");
 
  imap_cmd_start(adata, "AUTHENTICATE ANONYMOUS");
 
  do
  {
    rc = imap_cmd_step(adata);
  } while (rc == IMAP_RES_CONTINUE);
 
  if (rc != IMAP_RES_RESPOND)
  {
    mutt_debug(LL_DEBUG1, "Invalid response from server\n");
    goto bail;
  }
 
  mutt_socket_send(adata->conn, "ZHVtbXkK\r\n"); /* base64 ("dummy") */
 
  do
  {
    rc = imap_cmd_step(adata);
  } while (rc == IMAP_RES_CONTINUE);
 
  if (rc != IMAP_RES_OK)
  {
    mutt_debug(LL_DEBUG1, "Error receiving server response\n");
    goto bail;
  }
 
  if (imap_code(adata->buf))
    return IMAP_AUTH_SUCCESS;
 
bail:
  // L10N: %s is the method name, e.g. Anonymous, CRAM-MD5, GSSAPI, SASL
  mutt_error(_("%s authentication failed"), "anonymous");
  return IMAP_AUTH_FAILURE;
}

Here is the call graph for this function:

imap_auth_cram_md5()

enum ImapAuthRes imap_auth_cram_md5	(	struct ImapAccountData *	adata,
		const char *	method )

Authenticate using CRAM-MD5 - Implements ImapAuth::authenticate() -.

Definition at line 96 of file auth_cram.c.

{
  if (!(adata->capabilities & IMAP_CAP_AUTH_CRAM_MD5))
    return IMAP_AUTH_UNAVAIL;
 
  // L10N: (%s) is the method name, e.g. Anonymous, CRAM-MD5, GSSAPI, SASL
  mutt_message(_("Authenticating (%s)..."), "CRAM-MD5");
 
  /* get auth info */
  if (mutt_account_getlogin(&adata->conn->account) < 0)
    return IMAP_AUTH_FAILURE;
  if (mutt_account_getpass(&adata->conn->account) < 0)
    return IMAP_AUTH_FAILURE;
 
  imap_cmd_start(adata, "AUTHENTICATE CRAM-MD5");
 
  struct Buffer *ibuf = buf_pool_get();
  struct Buffer *obuf = buf_pool_get();
  unsigned char hmac_response[MD5_DIGEST_LEN];
  int rc_step;
  enum ImapAuthRes rc = IMAP_AUTH_FAILURE;
 
  /* From RFC2195:
   * The data encoded in the first ready response contains a presumptively
   * arbitrary string of random digits, a timestamp, and the fully-qualified
   * primary host name of the server. The syntax of the unencoded form must
   * correspond to that of an RFC822 'msg-id' [RFC822] as described in [POP3].  */
  do
  {
    rc_step = imap_cmd_step(adata);
  } while (rc_step == IMAP_RES_CONTINUE);
 
  if (rc_step != IMAP_RES_RESPOND)
  {
    mutt_debug(LL_DEBUG1, "Invalid response from server\n");
    goto bail;
  }
 
  int dlen = mutt_b64_decode(adata->buf + 2, obuf->data, obuf->dsize - 1);
  if (dlen == -1)
  {
    mutt_debug(LL_DEBUG1, "Error decoding base64 response\n");
    goto bail;
  }
  obuf->data[dlen] = '\0';
  buf_fix_dptr(obuf);
 
  mutt_debug(LL_DEBUG2, "CRAM challenge: %s\n", buf_string(obuf));
 
  /* The client makes note of the data and then responds with a string
   * consisting of the user name, a space, and a 'digest'. The latter is
   * computed by applying the keyed MD5 algorithm from [KEYED-MD5] where the
   * key is a shared secret and the digested text is the timestamp (including
   * angle-brackets).
   *
   * Note: The user name shouldn't be quoted. Since the digest can't contain
   *   spaces, there is no ambiguity. Some servers get this wrong, we'll work
   *   around them when the bug report comes in. Until then, we'll remain
   *   blissfully RFC-compliant.  */
  hmac_md5(adata->conn->account.pass, buf_string(obuf), hmac_response);
  /* dubious optimisation I saw elsewhere: make the whole string in one call */
  int off = buf_printf(obuf, "%s ", adata->conn->account.user);
  mutt_md5_toascii(hmac_response, obuf->data + off);
  buf_fix_dptr(obuf);
  mutt_debug(LL_DEBUG2, "CRAM response: %s\n", buf_string(obuf));
 
  /* ibuf must be long enough to store the base64 encoding of obuf,
   * plus the additional debris */
  mutt_b64_encode(obuf->data, buf_len(obuf), ibuf->data, ibuf->dsize - 2);
  buf_fix_dptr(ibuf);
  buf_addstr(ibuf, "\r\n");
  mutt_socket_send(adata->conn, buf_string(ibuf));
 
  do
  {
    rc_step = imap_cmd_step(adata);
  } while (rc_step == IMAP_RES_CONTINUE);
 
  if (rc_step != IMAP_RES_OK)
  {
    mutt_debug(LL_DEBUG1, "Error receiving server response\n");
    goto bail;
  }
 
  if (imap_code(adata->buf))
    rc = IMAP_AUTH_SUCCESS;
 
bail:
  if (rc != IMAP_AUTH_SUCCESS)
  {
    // L10N: %s is the method name, e.g. Anonymous, CRAM-MD5, GSSAPI, SASL
    mutt_error(_("%s authentication failed"), "CRAM-MD5");
  }
 
  buf_pool_release(&ibuf);
  buf_pool_release(&obuf);
  return rc;
}

Here is the call graph for this function:

imap_auth_gsasl()

enum ImapAuthRes imap_auth_gsasl	(	struct ImapAccountData *	adata,
		const char *	method )

GNU SASL authenticator - Implements ImapAuth::authenticate() -.

Definition at line 41 of file auth_gsasl.c.

{
  Gsasl_session *gsasl_session = NULL;
  struct Buffer *output_buf = NULL;
  char *imap_step_output = NULL;
  int rc = IMAP_AUTH_FAILURE;
  int gsasl_rc = GSASL_OK;
  int imap_step_rc = IMAP_RES_CONTINUE;
 
  const char *chosen_mech = mutt_gsasl_get_mech(method, adata->capstr);
  if (!chosen_mech)
  {
    mutt_debug(LL_DEBUG2, "mutt_gsasl_get_mech() returned no usable mech\n");
    return IMAP_AUTH_UNAVAIL;
  }
 
  mutt_debug(LL_DEBUG2, "using mech %s\n", chosen_mech);
 
  if (mutt_gsasl_client_new(adata->conn, chosen_mech, &gsasl_session) < 0)
  {
    mutt_debug(LL_DEBUG1, "Error allocating GSASL connection\n");
    return IMAP_AUTH_UNAVAIL;
  }
 
  mutt_message(_("Authenticating (%s)..."), chosen_mech);
 
  output_buf = buf_pool_get();
  buf_printf(output_buf, "AUTHENTICATE %s", chosen_mech);
  if (adata->capabilities & IMAP_CAP_SASL_IR)
  {
    char *gsasl_step_output = NULL;
    gsasl_rc = gsasl_step64(gsasl_session, "", &gsasl_step_output);
    if ((gsasl_rc != GSASL_NEEDS_MORE) && (gsasl_rc != GSASL_OK))
    {
      mutt_debug(LL_DEBUG1, "gsasl_step64() failed (%d): %s\n", gsasl_rc,
                 gsasl_strerror(gsasl_rc));
      rc = IMAP_AUTH_UNAVAIL;
      goto bail;
    }
 
    buf_addch(output_buf, ' ');
    buf_addstr(output_buf, gsasl_step_output);
    gsasl_free(gsasl_step_output);
  }
  imap_cmd_start(adata, buf_string(output_buf));
 
  do
  {
    do
    {
      imap_step_rc = imap_cmd_step(adata);
    } while (imap_step_rc == IMAP_RES_CONTINUE);
 
    if ((imap_step_rc == IMAP_RES_BAD) || (imap_step_rc == IMAP_RES_NO))
      goto bail;
 
    if (imap_step_rc != IMAP_RES_RESPOND)
      break;
 
    imap_step_output = imap_next_word(adata->buf);
 
    char *gsasl_step_output = NULL;
    gsasl_rc = gsasl_step64(gsasl_session, imap_step_output, &gsasl_step_output);
    if ((gsasl_rc == GSASL_NEEDS_MORE) || (gsasl_rc == GSASL_OK))
    {
      buf_strcpy(output_buf, gsasl_step_output);
      gsasl_free(gsasl_step_output);
    }
    else
    {
      // sasl error occurred, send an abort string
      mutt_debug(LL_DEBUG1, "gsasl_step64() failed (%d): %s\n", gsasl_rc,
                 gsasl_strerror(gsasl_rc));
      buf_strcpy(output_buf, "*");
    }
 
    buf_addstr(output_buf, "\r\n");
    mutt_socket_send(adata->conn, buf_string(output_buf));
  } while ((gsasl_rc == GSASL_NEEDS_MORE) || (gsasl_rc == GSASL_OK));
 
  if (imap_step_rc != IMAP_RES_OK)
  {
    do
      imap_step_rc = imap_cmd_step(adata);
    while (imap_step_rc == IMAP_RES_CONTINUE);
  }
 
  if (imap_step_rc == IMAP_RES_RESPOND)
  {
    mutt_socket_send(adata->conn, "*\r\n");
    goto bail;
  }
 
  if ((gsasl_rc != GSASL_OK) || (imap_step_rc != IMAP_RES_OK))
    goto bail;
 
  if (imap_code(adata->buf))
    rc = IMAP_AUTH_SUCCESS;
 
bail:
  buf_pool_release(&output_buf);
  mutt_gsasl_client_finish(&gsasl_session);
 
  if (rc == IMAP_AUTH_FAILURE)
  {
    mutt_debug(LL_DEBUG2, "%s failed\n", chosen_mech);
    mutt_error(_("SASL authentication failed"));
  }
 
  return rc;
}

Here is the call graph for this function:

imap_auth_gss()

enum ImapAuthRes imap_auth_gss	(	struct ImapAccountData *	adata,
		const char *	method )

GSS Authentication support - Implements ImapAuth::authenticate() -.

Definition at line 106 of file auth_gss.c.

{
  gss_buffer_desc request_buf = { 0 };
  gss_buffer_desc send_token = { 0 };
  gss_buffer_t sec_token = NULL;
  gss_name_t target_name = NULL;
  gss_ctx_id_t context = NULL;
  gss_OID mech_name = NULL;
  char server_conf_flags;
  gss_qop_t quality = 0;
  int cflags = 0;
  OM_uint32 maj_stat = 0;
  OM_uint32 min_stat = 0;
  unsigned long buf_size = 0;
  int rc2;
  int rc = IMAP_AUTH_FAILURE;
 
  if (!(adata->capabilities & IMAP_CAP_AUTH_GSSAPI))
    return IMAP_AUTH_UNAVAIL;
 
  if (mutt_account_getuser(&adata->conn->account) < 0)
    return IMAP_AUTH_FAILURE;
 
  struct Buffer *buf1 = buf_pool_get();
  struct Buffer *buf2 = buf_pool_get();
 
  /* get an IMAP service ticket for the server */
  buf_printf(buf1, "imap@%s", adata->conn->account.host);
  request_buf.value = buf1->data;
  request_buf.length = buf_len(buf1);
 
  const short c_debug_level = cs_subset_number(NeoMutt->sub, "debug_level");
  maj_stat = gss_import_name(&min_stat, &request_buf, gss_nt_service_name, &target_name);
  if (maj_stat != GSS_S_COMPLETE)
  {
    mutt_debug(LL_DEBUG2, "Couldn't get service name for [%s]\n", buf1->data);
    rc = IMAP_AUTH_UNAVAIL;
    goto cleanup;
  }
  else if (c_debug_level >= 2)
  {
    gss_display_name(&min_stat, target_name, &request_buf, &mech_name);
    mutt_debug(LL_DEBUG2, "Using service name [%s]\n", (char *) request_buf.value);
    gss_release_buffer(&min_stat, &request_buf);
  }
  /* Acquire initial credentials - without a TGT GSSAPI is UNAVAIL */
  sec_token = GSS_C_NO_BUFFER;
  context = GSS_C_NO_CONTEXT;
 
  /* build token */
  maj_stat = gss_init_sec_context(&min_stat, GSS_C_NO_CREDENTIAL, &context, target_name,
                                  GSS_C_NO_OID, GSS_C_MUTUAL_FLAG | GSS_C_SEQUENCE_FLAG,
                                  0, GSS_C_NO_CHANNEL_BINDINGS, sec_token, NULL,
                                  &send_token, (unsigned int *) &cflags, NULL);
  if ((maj_stat != GSS_S_COMPLETE) && (maj_stat != GSS_S_CONTINUE_NEEDED))
  {
    print_gss_error(maj_stat, min_stat);
    mutt_debug(LL_DEBUG1, "Error acquiring credentials - no TGT?\n");
    gss_release_name(&min_stat, &target_name);
 
    rc = IMAP_AUTH_UNAVAIL;
    goto cleanup;
  }
 
  /* now begin login */
  // L10N: (%s) is the method name, e.g. Anonymous, CRAM-MD5, GSSAPI, SASL
  mutt_message(_("Authenticating (%s)..."), "GSSAPI");
 
  imap_cmd_start(adata, "AUTHENTICATE GSSAPI");
 
  /* expect a null continuation response ("+") */
  do
  {
    rc2 = imap_cmd_step(adata);
  } while (rc2 == IMAP_RES_CONTINUE);
 
  if (rc2 != IMAP_RES_RESPOND)
  {
    mutt_debug(LL_DEBUG2, "Invalid response from server: %s\n", buf1->data);
    gss_release_name(&min_stat, &target_name);
    goto bail;
  }
 
  /* now start the security context initialisation loop... */
  mutt_debug(LL_DEBUG2, "Sending credentials\n");
  mutt_b64_buffer_encode(buf1, send_token.value, send_token.length);
  gss_release_buffer(&min_stat, &send_token);
  buf_addstr(buf1, "\r\n");
  mutt_socket_send(adata->conn, buf_string(buf1));
 
  while (maj_stat == GSS_S_CONTINUE_NEEDED)
  {
    /* Read server data */
    do
    {
      rc2 = imap_cmd_step(adata);
    } while (rc2 == IMAP_RES_CONTINUE);
 
    if (rc2 != IMAP_RES_RESPOND)
    {
      mutt_debug(LL_DEBUG1, "#1 Error receiving server response\n");
      gss_release_name(&min_stat, &target_name);
      goto bail;
    }
 
    if (mutt_b64_buffer_decode(buf2, adata->buf + 2) < 0)
    {
      mutt_debug(LL_DEBUG1, "Invalid base64 server response\n");
      gss_release_name(&min_stat, &target_name);
      goto err_abort_cmd;
    }
    request_buf.value = buf2->data;
    request_buf.length = buf_len(buf2);
    sec_token = &request_buf;
 
    /* Write client data */
    maj_stat = gss_init_sec_context(&min_stat, GSS_C_NO_CREDENTIAL, &context, target_name,
                                    GSS_C_NO_OID, GSS_C_MUTUAL_FLAG | GSS_C_SEQUENCE_FLAG,
                                    0, GSS_C_NO_CHANNEL_BINDINGS, sec_token, NULL,
                                    &send_token, (unsigned int *) &cflags, NULL);
    if ((maj_stat != GSS_S_COMPLETE) && (maj_stat != GSS_S_CONTINUE_NEEDED))
    {
      print_gss_error(maj_stat, min_stat);
      mutt_debug(LL_DEBUG1, "Error exchanging credentials\n");
      gss_release_name(&min_stat, &target_name);
 
      goto err_abort_cmd;
    }
    mutt_b64_buffer_encode(buf1, send_token.value, send_token.length);
    gss_release_buffer(&min_stat, &send_token);
    buf_addstr(buf1, "\r\n");
    mutt_socket_send(adata->conn, buf_string(buf1));
  }
 
  gss_release_name(&min_stat, &target_name);
 
  /* get security flags and buffer size */
  do
  {
    rc2 = imap_cmd_step(adata);
  } while (rc2 == IMAP_RES_CONTINUE);
 
  if (rc2 != IMAP_RES_RESPOND)
  {
    mutt_debug(LL_DEBUG1, "#2 Error receiving server response\n");
    goto bail;
  }
  if (mutt_b64_buffer_decode(buf2, adata->buf + 2) < 0)
  {
    mutt_debug(LL_DEBUG1, "Invalid base64 server response\n");
    goto err_abort_cmd;
  }
  request_buf.value = buf2->data;
  request_buf.length = buf_len(buf2);
 
  maj_stat = gss_unwrap(&min_stat, context, &request_buf, &send_token, &cflags, &quality);
  if (maj_stat != GSS_S_COMPLETE)
  {
    print_gss_error(maj_stat, min_stat);
    mutt_debug(LL_DEBUG2, "Couldn't unwrap security level data\n");
    gss_release_buffer(&min_stat, &send_token);
    goto err_abort_cmd;
  }
  mutt_debug(LL_DEBUG2, "Credential exchange complete\n");
 
  /* The unwrapped token must be at least 4 bytes: 1 byte of security flags
   * followed by 3 bytes of maximum buffer size.  Reject tokens that are
   * too short to prevent an out-of-bounds read. */
  if (send_token.length < 4)
  {
    mutt_debug(LL_DEBUG2, "Unwrapped security token too short (%zu bytes)\n",
               send_token.length);
    gss_release_buffer(&min_stat, &send_token);
    goto err_abort_cmd;
  }
 
  /* first byte is security levels supported. We want NONE */
  server_conf_flags = ((char *) send_token.value)[0];
  if (!(((char *) send_token.value)[0] & GSS_AUTH_P_NONE))
  {
    mutt_debug(LL_DEBUG2, "Server requires integrity or privacy\n");
    gss_release_buffer(&min_stat, &send_token);
    goto err_abort_cmd;
  }
 
  /* we don't care about buffer size if we don't wrap content. But here it is */
  ((char *) send_token.value)[0] = '\0';
  buf_size = ntohl(*((uint32_t *) send_token.value));
  gss_release_buffer(&min_stat, &send_token);
  mutt_debug(LL_DEBUG2, "Unwrapped security level flags: %c%c%c\n",
             (server_conf_flags & GSS_AUTH_P_NONE) ? 'N' : '-',
             (server_conf_flags & GSS_AUTH_P_INTEGRITY) ? 'I' : '-',
             (server_conf_flags & GSS_AUTH_P_PRIVACY) ? 'P' : '-');
  mutt_debug(LL_DEBUG2, "Maximum GSS token size is %ld\n", buf_size);
 
  /* agree to terms (hack!) */
  buf_size = htonl(buf_size); /* not relevant without integrity/privacy */
  buf_reset(buf1);
  buf_addch(buf1, GSS_AUTH_P_NONE);
  buf_addstr_n(buf1, ((char *) &buf_size) + 1, 3);
  /* server decides if principal can log in as user */
  buf_addstr(buf1, adata->conn->account.user);
  request_buf.value = buf1->data;
  request_buf.length = buf_len(buf1);
  maj_stat = gss_wrap(&min_stat, context, 0, GSS_C_QOP_DEFAULT, &request_buf,
                      &cflags, &send_token);
  if (maj_stat != GSS_S_COMPLETE)
  {
    mutt_debug(LL_DEBUG2, "Error creating login request\n");
    goto err_abort_cmd;
  }
 
  mutt_b64_buffer_encode(buf1, send_token.value, send_token.length);
  mutt_debug(LL_DEBUG2, "Requesting authorisation as %s\n", adata->conn->account.user);
  buf_addstr(buf1, "\r\n");
  mutt_socket_send(adata->conn, buf_string(buf1));
 
  /* Joy of victory or agony of defeat? */
  do
  {
    rc2 = imap_cmd_step(adata);
  } while (rc2 == IMAP_RES_CONTINUE);
  if (rc2 == IMAP_RES_RESPOND)
  {
    mutt_debug(LL_DEBUG1, "Unexpected server continuation request\n");
    goto err_abort_cmd;
  }
  if (imap_code(adata->buf))
  {
    /* flush the security context */
    mutt_debug(LL_DEBUG2, "Releasing GSS credentials\n");
    maj_stat = gss_delete_sec_context(&min_stat, &context, &send_token);
    if (maj_stat != GSS_S_COMPLETE)
      mutt_debug(LL_DEBUG1, "Error releasing credentials\n");
 
    /* send_token may contain a notification to the server to flush
     * credentials. RFC1731 doesn't specify what to do, and since this
     * support is only for authentication, we'll assume the server knows
     * enough to flush its own credentials */
    gss_release_buffer(&min_stat, &send_token);
 
    rc = IMAP_AUTH_SUCCESS;
    goto cleanup;
  }
  else
  {
    goto bail;
  }
 
err_abort_cmd:
  mutt_socket_send(adata->conn, "*\r\n");
  do
  {
    rc2 = imap_cmd_step(adata);
  } while (rc2 == IMAP_RES_CONTINUE);
 
bail:
  // L10N: %s is the method name, e.g. Anonymous, CRAM-MD5, GSSAPI, SASL
  mutt_error(_("%s authentication failed"), "GSSAPI");
  rc = IMAP_AUTH_FAILURE;
 
cleanup:
  buf_pool_release(&buf1);
  buf_pool_release(&buf2);
 
  return rc;
}

Here is the call graph for this function:

imap_auth_login()

enum ImapAuthRes imap_auth_login	(	struct ImapAccountData *	adata,
		const char *	method )

Plain LOGIN support - Implements ImapAuth::authenticate() -.

Definition at line 45 of file auth_login.c.

{
  char q_user[256] = { 0 };
  char q_pass[256] = { 0 };
  char buf[1024] = { 0 };
 
  if ((adata->capabilities & IMAP_CAP_LOGINDISABLED))
  {
    mutt_message(_("LOGIN disabled on this server"));
    return IMAP_AUTH_UNAVAIL;
  }
 
  if (mutt_account_getuser(&adata->conn->account) < 0)
    return IMAP_AUTH_FAILURE;
  if (mutt_account_getpass(&adata->conn->account) < 0)
    return IMAP_AUTH_FAILURE;
 
  mutt_message(_("Logging in..."));
 
  imap_quote_string(q_user, sizeof(q_user), adata->conn->account.user, false);
  imap_quote_string(q_pass, sizeof(q_pass), adata->conn->account.pass, false);
 
  /* don't print the password unless we're at the ungodly debugging level
   * of 5 or higher */
 
  const short c_debug_level = cs_subset_number(NeoMutt->sub, "debug_level");
  if (c_debug_level < IMAP_LOG_PASS)
    mutt_debug(LL_DEBUG2, "Sending LOGIN command for %s\n", adata->conn->account.user);
 
  snprintf(buf, sizeof(buf), "LOGIN %s %s", q_user, q_pass);
  if (imap_exec(adata, buf, IMAP_CMD_PASS) == IMAP_EXEC_SUCCESS)
  {
    mutt_clear_error();
    return IMAP_AUTH_SUCCESS;
  }
 
  mutt_error(_("Login failed"));
  return IMAP_AUTH_FAILURE;
}

Here is the call graph for this function:

imap_auth_oauth()

enum ImapAuthRes imap_auth_oauth	(	struct ImapAccountData *	adata,
		const char *	method )

Authenticate an IMAP connection using OAUTHBEARER - Implements ImapAuth::authenticate() -.

Definition at line 111 of file auth_oauth.c.

{
  return imap_auth_oauth_xoauth2(adata, method, false);
}

Here is the call graph for this function:

imap_auth_xoauth2()

enum ImapAuthRes imap_auth_xoauth2	(	struct ImapAccountData *	adata,
		const char *	method )

Authenticate an IMAP connection using XOAUTH2 - Implements ImapAuth::authenticate() -.

Definition at line 119 of file auth_oauth.c.

{
  return imap_auth_oauth_xoauth2(adata, method, true);
}

Here is the call graph for this function:

imap_auth_plain()

enum ImapAuthRes imap_auth_plain	(	struct ImapAccountData *	adata,
		const char *	method )

SASL PLAIN support - Implements ImapAuth::authenticate() -.

Definition at line 42 of file auth_plain.c.

{
  static const char auth_plain_cmd[] = "AUTHENTICATE PLAIN";
  // Subtract 1 (for the \0) to get the string length
  static const size_t apc_len = sizeof(auth_plain_cmd) - 1;
 
  struct ConnAccount *cac = &adata->conn->account;
 
  if (mutt_account_getuser(cac) < 0)
    return IMAP_AUTH_FAILURE;
  if (mutt_account_getpass(cac) < 0)
    return IMAP_AUTH_FAILURE;
 
  mutt_message(_("Logging in..."));
 
  int rc_step = IMAP_RES_CONTINUE;
  enum ImapAuthRes rc = IMAP_AUTH_SUCCESS;
  struct Buffer *buf = buf_pool_get();
 
  /* Prepare full AUTHENTICATE PLAIN message */
  mutt_sasl_plain_msg(buf, auth_plain_cmd, cac->user, cac->user, cac->pass);
 
  if (adata->capabilities & IMAP_CAP_SASL_IR)
  {
    imap_cmd_start(adata, buf_string(buf));
  }
  else
  {
    /* Split the message so we send AUTHENTICATE PLAIN first, and the
     * credentials after the first command continuation request */
    buf->data[apc_len] = '\0';
    imap_cmd_start(adata, buf_string(buf));
    while (rc_step == IMAP_RES_CONTINUE)
    {
      rc_step = imap_cmd_step(adata);
    }
    if (rc_step == IMAP_RES_RESPOND)
    {
      buf_addstr(buf, "\r\n");
      mutt_socket_send(adata->conn, buf->data + apc_len + 1);
      rc_step = IMAP_RES_CONTINUE;
    }
  }
 
  while (rc_step == IMAP_RES_CONTINUE)
  {
    rc_step = imap_cmd_step(adata);
  }
 
  if (rc_step == IMAP_RES_BAD)
  {
    rc = IMAP_AUTH_UNAVAIL;
  }
  else if (rc_step == IMAP_RES_NO)
  {
    mutt_error(_("Login failed"));
    rc = IMAP_AUTH_FAILURE;
  }
 
  mutt_clear_error();
  buf_pool_release(&buf);
  return rc;
}

Here is the call graph for this function:

imap_auth_sasl()

enum ImapAuthRes imap_auth_sasl	(	struct ImapAccountData *	adata,
		const char *	method )

SASL authenticator - Implements ImapAuth::authenticate() -.

Definition at line 46 of file auth_sasl.c.

{
  sasl_conn_t *saslconn = NULL;
  sasl_interact_t *interaction = NULL;
  int rc, irc;
  char *buf = NULL;
  size_t bufsize = 0;
  const char *mech = NULL;
  const char *pc = NULL;
  unsigned int len = 0, olen = 0;
  bool client_start;
 
  if (mutt_sasl_client_new(adata->conn, &saslconn) < 0)
  {
    mutt_debug(LL_DEBUG1, "Error allocating SASL connection\n");
    return IMAP_AUTH_FAILURE;
  }
 
  rc = SASL_FAIL;
 
  /* If the user hasn't specified a method, use any available */
  if (!method)
  {
    method = adata->capstr;
 
    /* hack for SASL ANONYMOUS support:
     * 1. Fetch username. If it's "" or "anonymous" then
     * 2. attempt sasl_client_start with only "AUTH=ANONYMOUS" capability
     * 3. if sasl_client_start fails, fall through... */
 
    if (mutt_account_getuser(&adata->conn->account) < 0)
    {
      sasl_dispose(&saslconn);
      return IMAP_AUTH_FAILURE;
    }
 
    if ((adata->capabilities & IMAP_CAP_AUTH_ANONYMOUS) &&
        (!adata->conn->account.user[0] ||
         mutt_str_startswith(adata->conn->account.user, "anonymous")))
    {
      rc = sasl_client_start(saslconn, "AUTH=ANONYMOUS", NULL, &pc, &olen, &mech);
    }
  }
  else if (mutt_istr_equal("login", method) && !strstr(NONULL(adata->capstr), "AUTH=LOGIN"))
  {
    /* do not use SASL login for regular IMAP login */
    sasl_dispose(&saslconn);
    return IMAP_AUTH_UNAVAIL;
  }
 
  if ((rc != SASL_OK) && (rc != SASL_CONTINUE))
  {
    do
    {
      rc = sasl_client_start(saslconn, method, &interaction, &pc, &olen, &mech);
      if (rc == SASL_INTERACT)
        mutt_sasl_interact(interaction);
    } while (rc == SASL_INTERACT);
  }
 
  client_start = (olen > 0);
 
  if ((rc != SASL_OK) && (rc != SASL_CONTINUE))
  {
    if (method)
    {
      mutt_debug(LL_DEBUG2, "%s unavailable\n", method);
    }
    else
    {
      mutt_debug(LL_DEBUG1, "Failure starting authentication exchange. No shared mechanisms?\n");
    }
    /* SASL doesn't support LOGIN, so fall back */
 
    sasl_dispose(&saslconn);
    return IMAP_AUTH_UNAVAIL;
  }
 
  // L10N: (%s) is the method name, e.g. Anonymous, CRAM-MD5, GSSAPI, SASL
  mutt_message(_("Authenticating (%s)..."), mech);
 
  bufsize = MAX((olen * 2), 1024);
  buf = MUTT_MEM_MALLOC(bufsize, char);
 
  snprintf(buf, bufsize, "AUTHENTICATE %s", mech);
  if ((adata->capabilities & IMAP_CAP_SASL_IR) && client_start)
  {
    len = mutt_str_len(buf);
    buf[len++] = ' ';
    if (sasl_encode64(pc, olen, buf + len, bufsize - len, &olen) != SASL_OK)
    {
      mutt_debug(LL_DEBUG1, "#1 error base64-encoding client response\n");
      goto bail;
    }
    client_start = false;
    olen = 0;
  }
  imap_cmd_start(adata, buf);
  irc = IMAP_RES_CONTINUE;
 
  /* looping protocol */
  while ((rc == SASL_CONTINUE) || (olen > 0))
  {
    do
    {
      irc = imap_cmd_step(adata);
    } while (irc == IMAP_RES_CONTINUE);
 
    if ((irc == IMAP_RES_BAD) || (irc == IMAP_RES_NO))
      goto bail;
 
    if (irc == IMAP_RES_RESPOND)
    {
      /* Exchange incorrectly returns +\r\n instead of + \r\n */
      if (adata->buf[1] == '\0')
      {
        buf[0] = '\0';
        len = 0;
      }
      else
      {
        len = strlen(adata->buf + 2);
        if (len > bufsize)
        {
          bufsize = len;
          MUTT_MEM_REALLOC(&buf, bufsize, char);
        }
        /* For sasl_decode64, the fourth parameter, outmax, doesn't
         * include space for the trailing null */
        if (sasl_decode64(adata->buf + 2, len, buf, bufsize - 1, &len) != SASL_OK)
        {
          mutt_debug(LL_DEBUG1, "error base64-decoding server response\n");
          goto bail;
        }
      }
    }
 
    /* client-start is only available with the SASL-IR extension, but
     * SASL 2.1 seems to want to use it regardless, at least for DIGEST
     * fast reauth. Override if the server sent an initial continuation */
    if (!client_start || buf[0])
    {
      do
      {
        rc = sasl_client_step(saslconn, buf, len, &interaction, &pc, &olen);
        if (rc == SASL_INTERACT)
          mutt_sasl_interact(interaction);
      } while (rc == SASL_INTERACT);
    }
    else
    {
      client_start = false;
    }
 
    /* send out response, or line break if none needed */
    if (olen)
    {
      if ((olen * 2) > bufsize)
      {
        bufsize = olen * 2;
        MUTT_MEM_REALLOC(&buf, bufsize, char);
      }
      if (sasl_encode64(pc, olen, buf, bufsize, &olen) != SASL_OK)
      {
        mutt_debug(LL_DEBUG1, "#2 error base64-encoding client response\n");
        goto bail;
      }
    }
 
    if (irc == IMAP_RES_RESPOND)
    {
      mutt_str_copy(buf + olen, "\r\n", bufsize - olen);
      mutt_socket_send(adata->conn, buf);
    }
 
    /* If SASL has errored out, send an abort string to the server */
    if (rc < 0)
    {
      mutt_socket_send(adata->conn, "*\r\n");
      mutt_debug(LL_DEBUG1, "sasl_client_step error %d\n", rc);
    }
 
    olen = 0;
  }
 
  while (irc != IMAP_RES_OK)
  {
    irc = imap_cmd_step(adata);
    if (irc != IMAP_RES_CONTINUE)
      break;
  }
 
  if (rc != SASL_OK)
    goto bail;
 
  if (imap_code(adata->buf))
  {
    mutt_sasl_setup_conn(adata->conn, saslconn);
    FREE(&buf);
    return IMAP_AUTH_SUCCESS;
  }
 
bail:
  sasl_dispose(&saslconn);
  FREE(&buf);
 
  if (method)
  {
    mutt_debug(LL_DEBUG2, "%s failed\n", method);
    return IMAP_AUTH_UNAVAIL;
  }
 
  // L10N: %s is the method name, e.g. Anonymous, CRAM-MD5, GSSAPI, SASL
  mutt_error(_("%s authentication failed"), "SASL ");
 
  return IMAP_AUTH_FAILURE;
}

Here is the call graph for this function: