Debian Codegraph @

deps/curl/lib/curl_sasl.c

raw
1 /***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) 2012 - 2020, Daniel Stenberg, <[email protected]>, et al.
9 *
10 * This software is licensed as described in the file COPYING, which
11 * you should have received as part of this distribution. The terms
12 * are also available at https://curl.haxx.se/docs/copyright.html.
13 *
14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15 * copies of the Software, and permit persons to whom the Software is
16 * furnished to do so, under the terms of the COPYING file.
17 *
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
20 *
21 * RFC2195 CRAM-MD5 authentication
22 * RFC2617 Basic and Digest Access Authentication
23 * RFC2831 DIGEST-MD5 authentication
24 * RFC4422 Simple Authentication and Security Layer (SASL)
25 * RFC4616 PLAIN authentication
26 * RFC6749 OAuth 2.0 Authorization Framework
27 * RFC7628 A Set of SASL Mechanisms for OAuth
28 * Draft LOGIN SASL Mechanism <draft-murchison-sasl-login-00.txt>
29 *
30 ***************************************************************************/
31
32 #include "curl_setup.h"
33
34 #if !defined(CURL_DISABLE_IMAP) || !defined(CURL_DISABLE_SMTP) || \
35 !defined(CURL_DISABLE_POP3)
36
37 #include <curl/curl.h>
38 #include "urldata.h"
39
40 #include "curl_base64.h"
41 #include "curl_md5.h"
42 #include "vauth/vauth.h"
43 #include "vtls/vtls.h"
44 #include "curl_hmac.h"
45 #include "curl_sasl.h"
46 #include "warnless.h"
47 #include "strtok.h"
48 #include "sendf.h"
49 #include "non-ascii.h" /* included for Curl_convert_... prototypes */
50 /* The last 3 #include files should be in this order */
51 #include "curl_printf.h"
52 #include "curl_memory.h"
53 #include "memdebug.h"
54
55 /* Supported mechanisms */
56 static const struct {
57 const char *name; /* Name */
58 size_t len; /* Name length */
59 unsigned int bit; /* Flag bit */
60 } mechtable[] = {
61 { "LOGIN", 5, SASL_MECH_LOGIN },
62 { "PLAIN", 5, SASL_MECH_PLAIN },
63 { "CRAM-MD5", 8, SASL_MECH_CRAM_MD5 },
64 { "DIGEST-MD5", 10, SASL_MECH_DIGEST_MD5 },
65 { "GSSAPI", 6, SASL_MECH_GSSAPI },
66 { "EXTERNAL", 8, SASL_MECH_EXTERNAL },
67 { "NTLM", 4, SASL_MECH_NTLM },
68 { "XOAUTH2", 7, SASL_MECH_XOAUTH2 },
69 { "OAUTHBEARER", 11, SASL_MECH_OAUTHBEARER },
70 { ZERO_NULL, 0, 0 }
71 };
72
73 /*
74 * Curl_sasl_cleanup()
75 *
76 * This is used to cleanup any libraries or curl modules used by the sasl
77 * functions.
78 *
79 * Parameters:
80 *
81 * conn [in] - The connection data.
82 * authused [in] - The authentication mechanism used.
83 */
84 void Curl_sasl_cleanup(struct connectdata *conn, unsigned int authused)
85 {
86 #if defined(USE_KERBEROS5)
87 /* Cleanup the gssapi structure */
88 if(authused == SASL_MECH_GSSAPI) {
89 Curl_auth_cleanup_gssapi(&conn->krb5);
90 }
91 #endif
92
93 #if defined(USE_NTLM)
94 /* Cleanup the NTLM structure */
95 if(authused == SASL_MECH_NTLM) {
96 Curl_auth_cleanup_ntlm(&conn->ntlm);
97 }
98 #endif
99
100 #if !defined(USE_KERBEROS5) && !defined(USE_NTLM)
101 /* Reserved for future use */
102 (void)conn;
103 (void)authused;
104 #endif
105 }
106
107 /*
108 * Curl_sasl_decode_mech()
109 *
110 * Convert a SASL mechanism name into a token.
111 *
112 * Parameters:
113 *
114 * ptr [in] - The mechanism string.
115 * maxlen [in] - Maximum mechanism string length.
116 * len [out] - If not NULL, effective name length.
117 *
118 * Returns the SASL mechanism token or 0 if no match.
119 */
120 unsigned int Curl_sasl_decode_mech(const char *ptr, size_t maxlen, size_t *len)
121 {
122 unsigned int i;
123 char c;
124
125 for(i = 0; mechtable[i].name; i++) {
126 if(maxlen >= mechtable[i].len &&
127 !memcmp(ptr, mechtable[i].name, mechtable[i].len)) {
128 if(len)
129 *len = mechtable[i].len;
130
131 if(maxlen == mechtable[i].len)
132 return mechtable[i].bit;
133
134 c = ptr[mechtable[i].len];
135 if(!ISUPPER(c) && !ISDIGIT(c) && c != '-' && c != '_')
136 return mechtable[i].bit;
137 }
138 }
139
140 return 0;
141 }
142
143 /*
144 * Curl_sasl_parse_url_auth_option()
145 *
146 * Parse the URL login options.
147 */
148 CURLcode Curl_sasl_parse_url_auth_option(struct SASL *sasl,
149 const char *value, size_t len)
150 {
151 CURLcode result = CURLE_OK;
152 size_t mechlen;
153
154 if(!len)
155 return CURLE_URL_MALFORMAT;
156
157 if(sasl->resetprefs) {
158 sasl->resetprefs = FALSE;
159 sasl->prefmech = SASL_AUTH_NONE;
160 }
161
162 if(!strncmp(value, "*", len))
163 sasl->prefmech = SASL_AUTH_DEFAULT;
164 else {
165 unsigned int mechbit = Curl_sasl_decode_mech(value, len, &mechlen);
166 if(mechbit && mechlen == len)
167 sasl->prefmech |= mechbit;
168 else
169 result = CURLE_URL_MALFORMAT;
170 }
171
172 return result;
173 }
174
175 /*
176 * Curl_sasl_init()
177 *
178 * Initializes the SASL structure.
179 */
180 void Curl_sasl_init(struct SASL *sasl, const struct SASLproto *params)
181 {
182 sasl->params = params; /* Set protocol dependent parameters */
183 sasl->state = SASL_STOP; /* Not yet running */
184 sasl->authmechs = SASL_AUTH_NONE; /* No known authentication mechanism yet */
185 sasl->prefmech = SASL_AUTH_DEFAULT; /* Prefer all mechanisms */
186 sasl->authused = SASL_AUTH_NONE; /* No the authentication mechanism used */
187 sasl->resetprefs = TRUE; /* Reset prefmech upon AUTH parsing. */
188 sasl->mutual_auth = FALSE; /* No mutual authentication (GSSAPI only) */
189 sasl->force_ir = FALSE; /* Respect external option */
190 }
191
192 /*
193 * state()
194 *
195 * This is the ONLY way to change SASL state!
196 */
197 static void state(struct SASL *sasl, struct connectdata *conn,
198 saslstate newstate)
199 {
200 #if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS)
201 /* for debug purposes */
202 static const char * const names[]={
203 "STOP",
204 "PLAIN",
205 "LOGIN",
206 "LOGIN_PASSWD",
207 "EXTERNAL",
208 "CRAMMD5",
209 "DIGESTMD5",
210 "DIGESTMD5_RESP",
211 "NTLM",
212 "NTLM_TYPE2MSG",
213 "GSSAPI",
214 "GSSAPI_TOKEN",
215 "GSSAPI_NO_DATA",
216 "OAUTH2",
217 "OAUTH2_RESP",
218 "CANCEL",
219 "FINAL",
220 /* LAST */
221 };
222
223 if(sasl->state != newstate)
224 infof(conn->data, "SASL %p state change from %s to %s\n",
225 (void *)sasl, names[sasl->state], names[newstate]);
226 #else
227 (void) conn;
228 #endif
229
230 sasl->state = newstate;
231 }
232
233 /*
234 * Curl_sasl_can_authenticate()
235 *
236 * Check if we have enough auth data and capabilities to authenticate.
237 */
238 bool Curl_sasl_can_authenticate(struct SASL *sasl, struct connectdata *conn)
239 {
240 /* Have credentials been provided? */
241 if(conn->bits.user_passwd)
242 return TRUE;
243
244 /* EXTERNAL can authenticate without a user name and/or password */
245 if(sasl->authmechs & sasl->prefmech & SASL_MECH_EXTERNAL)
246 return TRUE;
247
248 return FALSE;
249 }
250
251 /*
252 * Curl_sasl_start()
253 *
254 * Calculate the required login details for SASL authentication.
255 */
256 CURLcode Curl_sasl_start(struct SASL *sasl, struct connectdata *conn,
257 bool force_ir, saslprogress *progress)
258 {
259 CURLcode result = CURLE_OK;
260 struct Curl_easy *data = conn->data;
261 unsigned int enabledmechs;
262 const char *mech = NULL;
263 char *resp = NULL;
264 size_t len = 0;
265 saslstate state1 = SASL_STOP;
266 saslstate state2 = SASL_FINAL;
267 const char * const hostname = SSL_IS_PROXY() ? conn->http_proxy.host.name :
268 conn->host.name;
269 const long int port = SSL_IS_PROXY() ? conn->port : conn->remote_port;
270 #if defined(USE_KERBEROS5) || defined(USE_NTLM)
271 const char *service = data->set.str[STRING_SERVICE_NAME] ?
272 data->set.str[STRING_SERVICE_NAME] :
273 sasl->params->service;
274 #endif
275 const char *oauth_bearer = data->set.str[STRING_BEARER];
276
277 sasl->force_ir = force_ir; /* Latch for future use */
278 sasl->authused = 0; /* No mechanism used yet */
279 enabledmechs = sasl->authmechs & sasl->prefmech;
280 *progress = SASL_IDLE;
281
282 /* Calculate the supported authentication mechanism, by decreasing order of
283 security, as well as the initial response where appropriate */
284 if((enabledmechs & SASL_MECH_EXTERNAL) && !conn->passwd[0]) {
285 mech = SASL_MECH_STRING_EXTERNAL;
286 state1 = SASL_EXTERNAL;
287 sasl->authused = SASL_MECH_EXTERNAL;
288
289 if(force_ir || data->set.sasl_ir)
290 result = Curl_auth_create_external_message(data, conn->user, &resp,
291 &len);
292 }
293 else if(conn->bits.user_passwd) {
294 #if defined(USE_KERBEROS5)
295 if((enabledmechs & SASL_MECH_GSSAPI) && Curl_auth_is_gssapi_supported() &&
296 Curl_auth_user_contains_domain(conn->user)) {
297 sasl->mutual_auth = FALSE;
298 mech = SASL_MECH_STRING_GSSAPI;
299 state1 = SASL_GSSAPI;
300 state2 = SASL_GSSAPI_TOKEN;
301 sasl->authused = SASL_MECH_GSSAPI;
302
303 if(force_ir || data->set.sasl_ir)
304 result = Curl_auth_create_gssapi_user_message(data, conn->user,
305 conn->passwd,
306 service,
307 data->conn->host.name,
308 sasl->mutual_auth,
309 NULL, &conn->krb5,
310 &resp, &len);
311 }
312 else
313 #endif
314 #ifndef CURL_DISABLE_CRYPTO_AUTH
315 if((enabledmechs & SASL_MECH_DIGEST_MD5) &&
316 Curl_auth_is_digest_supported()) {
317 mech = SASL_MECH_STRING_DIGEST_MD5;
318 state1 = SASL_DIGESTMD5;
319 sasl->authused = SASL_MECH_DIGEST_MD5;
320 }
321 else if(enabledmechs & SASL_MECH_CRAM_MD5) {
322 mech = SASL_MECH_STRING_CRAM_MD5;
323 state1 = SASL_CRAMMD5;
324 sasl->authused = SASL_MECH_CRAM_MD5;
325 }
326 else
327 #endif
328 #ifdef USE_NTLM
329 if((enabledmechs & SASL_MECH_NTLM) && Curl_auth_is_ntlm_supported()) {
330 mech = SASL_MECH_STRING_NTLM;
331 state1 = SASL_NTLM;
332 state2 = SASL_NTLM_TYPE2MSG;
333 sasl->authused = SASL_MECH_NTLM;
334
335 if(force_ir || data->set.sasl_ir)
336 result = Curl_auth_create_ntlm_type1_message(data,
337 conn->user, conn->passwd,
338 service,
339 hostname,
340 &conn->ntlm, &resp,
341 &len);
342 }
343 else
344 #endif
345 if((enabledmechs & SASL_MECH_OAUTHBEARER) && oauth_bearer) {
346 mech = SASL_MECH_STRING_OAUTHBEARER;
347 state1 = SASL_OAUTH2;
348 state2 = SASL_OAUTH2_RESP;
349 sasl->authused = SASL_MECH_OAUTHBEARER;
350
351 if(force_ir || data->set.sasl_ir)
352 result = Curl_auth_create_oauth_bearer_message(data, conn->user,
353 hostname,
354 port,
355 oauth_bearer,
356 &resp, &len);
357 }
358 else if((enabledmechs & SASL_MECH_XOAUTH2) && oauth_bearer) {
359 mech = SASL_MECH_STRING_XOAUTH2;
360 state1 = SASL_OAUTH2;
361 sasl->authused = SASL_MECH_XOAUTH2;
362
363 if(force_ir || data->set.sasl_ir)
364 result = Curl_auth_create_xoauth_bearer_message(data, conn->user,
365 oauth_bearer,
366 &resp, &len);
367 }
368 else if(enabledmechs & SASL_MECH_PLAIN) {
369 mech = SASL_MECH_STRING_PLAIN;
370 state1 = SASL_PLAIN;
371 sasl->authused = SASL_MECH_PLAIN;
372
373 if(force_ir || data->set.sasl_ir)
374 result = Curl_auth_create_plain_message(data, conn->sasl_authzid,
375 conn->user, conn->passwd,
376 &resp, &len);
377 }
378 else if(enabledmechs & SASL_MECH_LOGIN) {
379 mech = SASL_MECH_STRING_LOGIN;
380 state1 = SASL_LOGIN;
381 state2 = SASL_LOGIN_PASSWD;
382 sasl->authused = SASL_MECH_LOGIN;
383
384 if(force_ir || data->set.sasl_ir)
385 result = Curl_auth_create_login_message(data, conn->user, &resp, &len);
386 }
387 }
388
389 if(!result && mech) {
390 if(resp && sasl->params->maxirlen &&
391 strlen(mech) + len > sasl->params->maxirlen) {
392 free(resp);
393 resp = NULL;
394 }
395
396 result = sasl->params->sendauth(conn, mech, resp);
397 if(!result) {
398 *progress = SASL_INPROGRESS;
399 state(sasl, conn, resp ? state2 : state1);
400 }
401 }
402
403 free(resp);
404
405 return result;
406 }
407
408 /*
409 * Curl_sasl_continue()
410 *
411 * Continue the authentication.
412 */
413 CURLcode Curl_sasl_continue(struct SASL *sasl, struct connectdata *conn,
414 int code, saslprogress *progress)
415 {
416 CURLcode result = CURLE_OK;
417 struct Curl_easy *data = conn->data;
418 saslstate newstate = SASL_FINAL;
419 char *resp = NULL;
420 const char * const hostname = SSL_IS_PROXY() ? conn->http_proxy.host.name :
421 conn->host.name;
422 const long int port = SSL_IS_PROXY() ? conn->port : conn->remote_port;
423 #if !defined(CURL_DISABLE_CRYPTO_AUTH)
424 char *chlg = NULL;
425 size_t chlglen = 0;
426 #endif
427 #if !defined(CURL_DISABLE_CRYPTO_AUTH) || defined(USE_KERBEROS5) || \
428 defined(USE_NTLM)
429 const char *service = data->set.str[STRING_SERVICE_NAME] ?
430 data->set.str[STRING_SERVICE_NAME] :
431 sasl->params->service;
432 char *serverdata;
433 #endif
434 size_t len = 0;
435 const char *oauth_bearer = data->set.str[STRING_BEARER];
436
437 *progress = SASL_INPROGRESS;
438
439 if(sasl->state == SASL_FINAL) {
440 if(code != sasl->params->finalcode)
441 result = CURLE_LOGIN_DENIED;
442 *progress = SASL_DONE;
443 state(sasl, conn, SASL_STOP);
444 return result;
445 }
446
447 if(sasl->state != SASL_CANCEL && sasl->state != SASL_OAUTH2_RESP &&
448 code != sasl->params->contcode) {
449 *progress = SASL_DONE;
450 state(sasl, conn, SASL_STOP);
451 return CURLE_LOGIN_DENIED;
452 }
453
454 switch(sasl->state) {
455 case SASL_STOP:
456 *progress = SASL_DONE;
457 return result;
458 case SASL_PLAIN:
459 result = Curl_auth_create_plain_message(data, conn->sasl_authzid,
460 conn->user, conn->passwd,
461 &resp, &len);
462 break;
463 case SASL_LOGIN:
464 result = Curl_auth_create_login_message(data, conn->user, &resp, &len);
465 newstate = SASL_LOGIN_PASSWD;
466 break;
467 case SASL_LOGIN_PASSWD:
468 result = Curl_auth_create_login_message(data, conn->passwd, &resp, &len);
469 break;
470 case SASL_EXTERNAL:
471 result = Curl_auth_create_external_message(data, conn->user, &resp, &len);
472 break;
473
474 #ifndef CURL_DISABLE_CRYPTO_AUTH
475 case SASL_CRAMMD5:
476 sasl->params->getmessage(data->state.buffer, &serverdata);
477 result = Curl_auth_decode_cram_md5_message(serverdata, &chlg, &chlglen);
478 if(!result)
479 result = Curl_auth_create_cram_md5_message(data, chlg, conn->user,
480 conn->passwd, &resp, &len);
481 free(chlg);
482 break;
483 case SASL_DIGESTMD5:
484 sasl->params->getmessage(data->state.buffer, &serverdata);
485 result = Curl_auth_create_digest_md5_message(data, serverdata,
486 conn->user, conn->passwd,
487 service,
488 &resp, &len);
489 newstate = SASL_DIGESTMD5_RESP;
490 break;
491 case SASL_DIGESTMD5_RESP:
492 resp = strdup("");
493 if(!resp)
494 result = CURLE_OUT_OF_MEMORY;
495 break;
496 #endif
497
498 #ifdef USE_NTLM
499 case SASL_NTLM:
500 /* Create the type-1 message */
501 result = Curl_auth_create_ntlm_type1_message(data,
502 conn->user, conn->passwd,
503 service, hostname,
504 &conn->ntlm, &resp, &len);
505 newstate = SASL_NTLM_TYPE2MSG;
506 break;
507 case SASL_NTLM_TYPE2MSG:
508 /* Decode the type-2 message */
509 sasl->params->getmessage(data->state.buffer, &serverdata);
510 result = Curl_auth_decode_ntlm_type2_message(data, serverdata,
511 &conn->ntlm);
512 if(!result)
513 result = Curl_auth_create_ntlm_type3_message(data, conn->user,
514 conn->passwd, &conn->ntlm,
515 &resp, &len);
516 break;
517 #endif
518
519 #if defined(USE_KERBEROS5)
520 case SASL_GSSAPI:
521 result = Curl_auth_create_gssapi_user_message(data, conn->user,
522 conn->passwd,
523 service,
524 data->conn->host.name,
525 sasl->mutual_auth, NULL,
526 &conn->krb5,
527 &resp, &len);
528 newstate = SASL_GSSAPI_TOKEN;
529 break;
530 case SASL_GSSAPI_TOKEN:
531 sasl->params->getmessage(data->state.buffer, &serverdata);
532 if(sasl->mutual_auth) {
533 /* Decode the user token challenge and create the optional response
534 message */
535 result = Curl_auth_create_gssapi_user_message(data, NULL, NULL,
536 NULL, NULL,
537 sasl->mutual_auth,
538 serverdata, &conn->krb5,
539 &resp, &len);
540 newstate = SASL_GSSAPI_NO_DATA;
541 }
542 else
543 /* Decode the security challenge and create the response message */
544 result = Curl_auth_create_gssapi_security_message(data, serverdata,
545 &conn->krb5,
546 &resp, &len);
547 break;
548 case SASL_GSSAPI_NO_DATA:
549 sasl->params->getmessage(data->state.buffer, &serverdata);
550 /* Decode the security challenge and create the response message */
551 result = Curl_auth_create_gssapi_security_message(data, serverdata,
552 &conn->krb5,
553 &resp, &len);
554 break;
555 #endif
556
557 case SASL_OAUTH2:
558 /* Create the authorisation message */
559 if(sasl->authused == SASL_MECH_OAUTHBEARER) {
560 result = Curl_auth_create_oauth_bearer_message(data, conn->user,
561 hostname,
562 port,
563 oauth_bearer,
564 &resp, &len);
565
566 /* Failures maybe sent by the server as continuations for OAUTHBEARER */
567 newstate = SASL_OAUTH2_RESP;
568 }
569 else
570 result = Curl_auth_create_xoauth_bearer_message(data, conn->user,
571 oauth_bearer,
572 &resp, &len);
573 break;
574
575 case SASL_OAUTH2_RESP:
576 /* The continuation is optional so check the response code */
577 if(code == sasl->params->finalcode) {
578 /* Final response was received so we are done */
579 *progress = SASL_DONE;
580 state(sasl, conn, SASL_STOP);
581 return result;
582 }
583 else if(code == sasl->params->contcode) {
584 /* Acknowledge the continuation by sending a 0x01 response base64
585 encoded */
586 resp = strdup("AQ==");
587 if(!resp)
588 result = CURLE_OUT_OF_MEMORY;
589 break;
590 }
591 else {
592 *progress = SASL_DONE;
593 state(sasl, conn, SASL_STOP);
594 return CURLE_LOGIN_DENIED;
595 }
596
597 case SASL_CANCEL:
598 /* Remove the offending mechanism from the supported list */
599 sasl->authmechs ^= sasl->authused;
600
601 /* Start an alternative SASL authentication */
602 result = Curl_sasl_start(sasl, conn, sasl->force_ir, progress);
603 newstate = sasl->state; /* Use state from Curl_sasl_start() */
604 break;
605 default:
606 failf(data, "Unsupported SASL authentication mechanism");
607 result = CURLE_UNSUPPORTED_PROTOCOL; /* Should not happen */
608 break;
609 }
610
611 switch(result) {
612 case CURLE_BAD_CONTENT_ENCODING:
613 /* Cancel dialog */
614 result = sasl->params->sendcont(conn, "*");
615 newstate = SASL_CANCEL;
616 break;
617 case CURLE_OK:
618 if(resp)
619 result = sasl->params->sendcont(conn, resp);
620 break;
621 default:
622 newstate = SASL_STOP; /* Stop on error */
623 *progress = SASL_DONE;
624 break;
625 }
626
627 free(resp);
628
629 state(sasl, conn, newstate);
630
631 return result;
632 }
633 #endif /* protocols are enabled that use SASL */