src/src/auths/plaintext.c

   1 /* $Cambridge: exim/src/src/auths/plaintext.c,v 1.2 2005/01/04 10:00:43 ph10 Exp $ */
   2
   3 /*************************************************
   4 *     Exim - an Internet mail transport agent    *
   5 *************************************************/
   6
   7 /* Copyright (c) University of Cambridge 1995 - 2005 */
   8 /* See the file NOTICE for conditions of use and distribution. */
   9
  10 #include "../exim.h"
  11 #include "plaintext.h"
  12
  13
  14 /* Options specific to the plaintext authentication mechanism. */
  15
  16 optionlist auth_plaintext_options[] = {
  17   { "client_send",        opt_stringptr,
  18       (void *)(offsetof(auth_plaintext_options_block, client_send)) },
  19   { "server_condition",   opt_stringptr,
  20       (void *)(offsetof(auth_plaintext_options_block, server_condition)) },
  21   { "server_prompts",     opt_stringptr,
  22       (void *)(offsetof(auth_plaintext_options_block, server_prompts)) }
  23 };
  24
  25 /* Size of the options list. An extern variable has to be used so that its
  26 address can appear in the tables drtables.c. */
  27
  28 int auth_plaintext_options_count =
  29   sizeof(auth_plaintext_options)/sizeof(optionlist);
  30
  31 /* Default private options block for the plaintext authentication method. */
  32
  33 auth_plaintext_options_block auth_plaintext_option_defaults = {
  34   NULL,              /* server_condition */
  35   NULL,              /* server_prompts */
  36   NULL               /* client_send */
  37 };
  38
  39
  40 /*************************************************
  41 *          Initialization entry point            *
  42 *************************************************/
  43
  44 /* Called for each instance, after its options have been read, to
  45 enable consistency checks to be done, or anything else that needs
  46 to be set up. */
  47
  48 void
  49 auth_plaintext_init(auth_instance *ablock)
  50 {
  51 auth_plaintext_options_block *ob =
  52   (auth_plaintext_options_block *)(ablock->options_block);
  53 if (ablock->public_name == NULL) ablock->public_name = ablock->name;
  54 if (ob->server_condition != NULL) ablock->server = TRUE;
  55 if (ob->client_send != NULL) ablock->client = TRUE;
  56 }
  57
  58
  59
  60 /*************************************************
  61 *             Server entry point                 *
  62 *************************************************/
  63
  64 /* For interface, see auths/README */
  65
  66 int
  67 auth_plaintext_server(auth_instance *ablock, uschar *data)
  68 {
  69 auth_plaintext_options_block *ob =
  70   (auth_plaintext_options_block *)(ablock->options_block);
  71 uschar *prompts = ob->server_prompts;
  72 uschar *clear, *cond, *end, *s;
  73 int number = 1;
  74 int len, rc;
  75 int sep = 0;
  76
  77 /* Expand a non-empty list of prompt strings */
  78
  79 if (prompts != NULL)
  80   {
  81   prompts = expand_string(prompts);
  82   if (prompts == NULL)
  83     {
  84     auth_defer_msg = expand_string_message;
  85     return DEFER;
  86     }
  87   }
  88
  89 /* If data was supplied on the AUTH command, decode it, and split it up into
  90 multiple items at binary zeros. If the data consists of the string "=" it
  91 indicates a single, empty string. */
  92
  93 if (*data != 0)
  94   {
  95   if (Ustrcmp(data, "=") == 0)
  96     {
  97     expand_nstring[++expand_nmax] = US"";
  98     expand_nlength[expand_nmax] = 0;
  99     }
 100   else
 101     {
 102     if ((len = auth_b64decode(data, &clear)) < 0) return BAD64;
 103     end = clear + len;
 104     while (clear < end && expand_nmax < EXPAND_MAXN)
 105       {
 106       expand_nstring[++expand_nmax] = clear;
 107       while (*clear != 0) clear++;
 108       expand_nlength[expand_nmax] = clear++ - expand_nstring[expand_nmax];
 109       }
 110     }
 111   }
 112
 113 /* Now go through the list of prompt strings. Skip over any whose data has
 114 already been provided as part of the AUTH command. For the rest, send them
 115 out as prompts, and get a data item back. If the data item is "*", abandon the
 116 authentication attempt. Otherwise, split it into items as above. */
 117
 118 while ((s = string_nextinlist(&prompts, &sep, big_buffer, big_buffer_size))
 119         != NULL && expand_nmax < EXPAND_MAXN)
 120   {
 121   if (number++ <= expand_nmax) continue;
 122   if ((rc = auth_get_data(&data, s, Ustrlen(s))) != OK) return rc;
 123   if ((len = auth_b64decode(data, &clear)) < 0) return BAD64;
 124   end = clear + len;
 125
 126   /* This loop must run at least once, in case the length is zero */
 127   do
 128     {
 129     expand_nstring[++expand_nmax] = clear;
 130     while (*clear != 0) clear++;
 131     expand_nlength[expand_nmax] = clear++ - expand_nstring[expand_nmax];
 132     }
 133   while (clear < end && expand_nmax < EXPAND_MAXN);
 134   }
 135
 136 /* We now have a number of items of data in $1, $2, etc. Match against the
 137 decoded data by expanding the condition. Also expand the id to set if
 138 authentication succeeds. */
 139
 140 cond = expand_string(ob->server_condition);
 141
 142 HDEBUG(D_auth)
 143   {
 144   int i;
 145   debug_printf("%s authenticator:\n", ablock->name);
 146   for (i = 1; i <= expand_nmax; i++)
 147     debug_printf("  $%d = %.*s\n", i, expand_nlength[i], expand_nstring[i]);
 148   debug_print_string(ablock->server_debug_string);    /* customized debug */
 149   if (cond == NULL)
 150     debug_printf("expansion failed: %s\n", expand_string_message);
 151   else
 152     debug_printf("expanded string: %s\n", cond);
 153   }
 154
 155 /* A forced expansion failure causes authentication to fail. Other expansion
 156 failures yield DEFER, which will cause a temporary error code to be returned to
 157 the AUTH command. The problem is at the server end, so the client should try
 158 again later. */
 159
 160 if (cond == NULL)
 161   {
 162   if (expand_string_forcedfail) return FAIL;
 163   auth_defer_msg = expand_string_message;
 164   return DEFER;
 165   }
 166
 167 /* Return FAIL for empty string, "0", "no", and "false"; return OK for
 168 "1", "yes", and "true"; return DEFER for anything else, with the string
 169 available as an error text for the user. */
 170
 171 if (*cond == 0 ||
 172     Ustrcmp(cond, "0") == 0 ||
 173     strcmpic(cond, US"no") == 0 ||
 174     strcmpic(cond, US"false") == 0)
 175   return FAIL;
 176
 177 if (Ustrcmp(cond, "1") == 0 ||
 178     strcmpic(cond, US"yes") == 0 ||
 179     strcmpic(cond, US"true") == 0)
 180   return OK;
 181
 182 auth_defer_msg = cond;
 183 auth_defer_user_msg = string_sprintf(": %s", cond);
 184 return DEFER;
 185 }
 186
 187
 188
 189 /*************************************************
 190 *              Client entry point                *
 191 *************************************************/
 192
 193 /* For interface, see auths/README */
 194
 195 int
 196 auth_plaintext_client(
 197   auth_instance *ablock,                 /* authenticator block */
 198   smtp_inblock *inblock,                 /* connection inblock */
 199   smtp_outblock *outblock,               /* connection outblock */
 200   int timeout,                           /* command timeout */
 201   uschar *buffer,                        /* buffer for reading response */
 202   int buffsize)                          /* size of buffer */
 203 {
 204 auth_plaintext_options_block *ob =
 205   (auth_plaintext_options_block *)(ablock->options_block);
 206 uschar *text = ob->client_send;
 207 uschar *s;
 208 BOOL first = TRUE;
 209 int sep = 0;
 210
 211 /* The text is broken up into a number of different data items, which are
 212 sent one by one. The first one is sent with the AUTH command; the remainder are
 213 sent in response to subsequent prompts. Each is expanded before being sent. */
 214
 215 while ((s = string_nextinlist(&text, &sep, big_buffer, big_buffer_size)) != NULL)
 216   {
 217   int i, len;
 218   uschar *ss = expand_string(s);
 219
 220   /* Forced expansion failure is not an error; authentication is abandoned. On
 221   all but the first string, we have to abandon the authentication attempt by
 222   sending a line containing "*". Save the failed expansion string, because it
 223   is in big_buffer, and that gets used by the sending function. */
 224
 225   if (ss == NULL)
 226     {
 227     uschar *ssave = string_copy(s);
 228     if (!first)
 229       {
 230       if (smtp_write_command(outblock, FALSE, "*\r\n") >= 0)
 231         (void) smtp_read_response(inblock, US buffer, buffsize, '2', timeout);
 232       }
 233     if (expand_string_forcedfail) return CANCELLED;
 234     string_format(buffer, buffsize, "expansion of \"%s\" failed in %s "
 235       "authenticator: %s", ssave, ablock->name, expand_string_message);
 236     return ERROR;
 237     }
 238
 239   len = Ustrlen(ss);
 240
 241   /* The character ^ is used as an escape for a binary zero character, which is
 242   needed for the PLAIN mechanism. It must be doubled if really needed. */
 243
 244   for (i = 0; i < len; i++)
 245     {
 246     if (ss[i] == '^')
 247       {
 248       if (ss[i+1] != '^') ss[i] = 0; else
 249         {
 250         i++;
 251         len--;
 252         memmove(ss + i, ss + i + 1, len - i);
 253         }
 254       }
 255     }
 256
 257   /* The first string is attached to the AUTH command; others are sent
 258   unembelished. */
 259
 260   if (first)
 261     {
 262     first = FALSE;
 263     if (smtp_write_command(outblock, FALSE, "AUTH %s%s%s\r\n",
 264          ablock->public_name, (len == 0)? "" : " ",
 265          auth_b64encode(ss, len)) < 0)
 266       return FAIL_SEND;
 267     }
 268   else
 269     {
 270     if (smtp_write_command(outblock, FALSE, "%s\r\n",
 271           auth_b64encode(ss, len)) < 0)
 272       return FAIL_SEND;
 273     }
 274
 275   /* If we receive a success response from the server, authentication
 276   has succeeded. There may be more data to send, but is there any point
 277   in provoking an error here? */
 278
 279   if (smtp_read_response(inblock, US buffer, buffsize, '2', timeout)) return OK;
 280
 281   /* Not a success response. If errno != 0 there is some kind of transmission
 282   error. Otherwise, check the response code in the buffer. If it starts with
 283   '3', more data is expected. */
 284
 285   if (errno != 0 || buffer[0] != '3') return FAIL;
 286
 287   /* If there is no more data to send, we have to cancel the authentication
 288   exchange and return ERROR. */
 289
 290   if (text == NULL)
 291     {
 292     if (smtp_write_command(outblock, FALSE, "*\r\n") >= 0)
 293       (void)smtp_read_response(inblock, US buffer, buffsize, '2', timeout);
 294     string_format(buffer, buffsize, "Too few items in client_send in %s "
 295       "authenticator", ablock->name);
 296     return ERROR;
 297     }
 298   }
 299
 300 /* Control should never actually get here. */
 301
 302 return FAIL;
 303 }
 304
 305 /* End of plaintext.c */