The FreeRADIUS server $Id: a4e7f8c94e8038b7627bcf52356b7ed15955c1d7 $
Loading...
Searching...
No Matches
rlm_mschap.c
Go to the documentation of this file.
1/*
2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; either version 2 of the License, or (at
5 * your option) any later version.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License
13 * along with this program; if not, write to the Free Software
14 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
15 */
16
17/**
18 * $Id: 4520ce49d325d2ae2458a63d4289313d8a43bdc3 $
19 * @file rlm_mschap.c
20 * @brief Implemented mschap authentication.
21 *
22 * @copyright 2000, 2001, 2006 The FreeRADIUS server project
23 */
24
25/* MPPE support from Takahiro Wagatsuma <waga@sic.shibaura-it.ac.jp> */
26RCSID("$Id: 4520ce49d325d2ae2458a63d4289313d8a43bdc3 $")
27
28#define LOG_PREFIX mctx->mi->name
29
30#include <freeradius-devel/server/base.h>
31#include <freeradius-devel/server/exec_legacy.h>
32#include <freeradius-devel/server/module_rlm.h>
33#include <freeradius-devel/tls/strerror.h>
34#include <freeradius-devel/util/debug.h>
35#include <freeradius-devel/radius/defs.h>
36
37#include <freeradius-devel/util/base16.h>
38#include <freeradius-devel/util/md4.h>
39#include <freeradius-devel/util/md5.h>
40#include <freeradius-devel/util/misc.h>
41#include <freeradius-devel/util/sha1.h>
42
43#include <freeradius-devel/unlang/function.h>
44#include <freeradius-devel/unlang/xlat_func.h>
45
46#include <sys/wait.h>
47
48#include "rlm_mschap.h"
49#include "smbdes.h"
50
51#ifdef WITH_AUTH_WINBIND
52#include "auth_wbclient.h"
53#endif
54
55#ifdef WITH_TLS
56USES_APPLE_DEPRECATED_API /* OpenSSL API has been deprecated by Apple */
57# include <openssl/rc4.h>
58#endif
59
60#ifdef __APPLE__
61unlang_action_t od_mschap_auth(unlang_result_t *p_result, request_t *request, fr_pair_t *challenge, fr_pair_t *usernamepair,
62 mschap_auth_call_env_t *env_data);
63#endif
64
65/* Allowable account control bits */
66#define ACB_DISABLED 0x00010000 //!< User account disabled.
67#define ACB_HOMDIRREQ 0x00020000 //!< Home directory required.
68#define ACB_PWNOTREQ 0x00040000 //!< User password not required.
69#define ACB_TEMPDUP 0x00080000 //!< Temporary duplicate account.
70#define ACB_NORMAL 0x00100000 //!< Normal user account.
71#define ACB_MNS 0x00200000 //!< MNS logon user account.
72#define ACB_DOMTRUST 0x00400000 //!< Interdomain trust account.
73#define ACB_WSTRUST 0x00800000 //!< Workstation trust account.
74#define ACB_SVRTRUST 0x01000000 //!< Server trust account.
75#define ACB_PWNOEXP 0x02000000 //!< User password does not expire.
76#define ACB_AUTOLOCK 0x04000000 //!< Account auto locked.
77#define ACB_FR_EXPIRED 0x00020000 //!< Password Expired.
78
83
84#ifdef WITH_AUTH_WINBIND
88};
89#endif
90
91static const conf_parser_t winbind_config[] = {
92 { FR_CONF_OFFSET("username", rlm_mschap_t, wb_username) },
93#ifdef WITH_AUTH_WINBIND
94 { FR_CONF_OFFSET("retry_with_normalised_username", rlm_mschap_t, wb_retry_with_normalised_username), .dflt = "no" },
96#endif
98};
99
100static const conf_parser_t module_config[] = {
101 { FR_CONF_OFFSET("normalise", rlm_mschap_t, normify), .dflt = "yes" },
102
103 /*
104 * Cache the password by default.
105 */
106 { FR_CONF_OFFSET("use_mppe", rlm_mschap_t, use_mppe), .dflt = "yes" },
107 { FR_CONF_OFFSET("require_encryption", rlm_mschap_t, require_encryption), .dflt = "no" },
108 { FR_CONF_OFFSET("require_strong", rlm_mschap_t, require_strong), .dflt = "no" },
109 { FR_CONF_OFFSET("with_ntdomain_hack", rlm_mschap_t, with_ntdomain_hack), .dflt = "yes" },
110 { FR_CONF_OFFSET_FLAGS("ntlm_auth", CONF_FLAG_XLAT, rlm_mschap_t, ntlm_auth) },
111 { FR_CONF_OFFSET("ntlm_auth_timeout", rlm_mschap_t, ntlm_auth_timeout) },
112
113 { FR_CONF_POINTER("passchange", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) passchange_config },
114 { FR_CONF_OFFSET("allow_retry", rlm_mschap_t, allow_retry), .dflt = "yes" },
115 { FR_CONF_OFFSET("retry_msg", rlm_mschap_t, retry_msg) },
116
117
118#ifdef __APPLE__
119 { FR_CONF_OFFSET("use_open_directory", rlm_mschap_t, open_directory), .dflt = "yes" },
120#endif
121
122 { FR_CONF_POINTER("winbind", 0, CONF_FLAG_SUBSECTION, NULL), .subcs = (void const *) winbind_config },
123
124 /*
125 * These are now in a subsection above.
126 */
127 { FR_CONF_V3_DEPRECATED("winbind_username", rlm_mschap_t, wb_username) },
128#ifdef WITH_AUTH_WINBIND
129 { FR_CONF_V3_DEPRECATED("winbind_retry_with_normalised_username", rlm_mschap_t, wb_retry_with_normalised_username) },
130#endif
132};
133
134#define MSCHAP_CALL_ENV(_x) \
135static const call_env_method_t mschap_ ## _x ## _method_env = { \
136 FR_CALL_ENV_METHOD_OUT(mschap_ ## _x ## _call_env_t), \
137 .env = (call_env_parser_t[]){ \
138 { FR_CALL_ENV_SUBSECTION("attributes", NULL, CALL_ENV_FLAG_REQUIRED, _x ## _call_env) }, \
139 CALL_ENV_TERMINATOR \
140 } \
141}
142
143#define MSCHAP_COMMON_CALL_ENV(_x) \
144{ FR_CALL_ENV_PARSE_ONLY_OFFSET("chap_challenge", FR_TYPE_OCTETS, CALL_ENV_FLAG_ATTRIBUTE | CALL_ENV_FLAG_REQUIRED, mschap_ ## _x ## _call_env_t, chap_challenge), \
145 .pair.dflt = "Vendor-Specific.Microsoft.CHAP-Challenge", .pair.dflt_quote = T_BARE_WORD }, \
146{ FR_CALL_ENV_PARSE_ONLY_OFFSET("chap_response", FR_TYPE_OCTETS, CALL_ENV_FLAG_ATTRIBUTE | CALL_ENV_FLAG_REQUIRED, mschap_ ## _x ## _call_env_t, chap_response), \
147 .pair.dflt = "Vendor-Specific.Microsoft.CHAP-Response", .pair.dflt_quote = T_BARE_WORD }, \
148{ FR_CALL_ENV_PARSE_ONLY_OFFSET("chap2_response", FR_TYPE_OCTETS, CALL_ENV_FLAG_ATTRIBUTE | CALL_ENV_FLAG_REQUIRED, mschap_ ## _x ## _call_env_t, chap2_response), \
149 .pair.dflt = "Vendor-Specific.Microsoft.CHAP2-Response", .pair.dflt_quote = T_BARE_WORD }
150
151#define MSCHAP_OPT_CALL_ENV(_opt, _x) \
152{ FR_CALL_ENV_PARSE_ONLY_OFFSET(STRINGIFY(_opt), FR_TYPE_OCTETS, CALL_ENV_FLAG_ATTRIBUTE, mschap_ ## _x ## _call_env_t, _opt) }
153
160
162 { FR_CALL_ENV_PARSE_ONLY_OFFSET("username", FR_TYPE_STRING, CALL_ENV_FLAG_ATTRIBUTE | CALL_ENV_FLAG_REQUIRED, mschap_xlat_call_env_t, username), .pair.dflt = "User-Name", .pair.dflt_quote = T_BARE_WORD },
165};
166
168
170 { FR_CALL_ENV_PARSE_ONLY_OFFSET("username", FR_TYPE_STRING, CALL_ENV_FLAG_ATTRIBUTE | CALL_ENV_FLAG_REQUIRED, mschap_auth_call_env_t, username), .pair.dflt = "User-Name", .pair.dflt_quote = T_BARE_WORD },
172 MSCHAP_OPT_CALL_ENV(chap2_success, auth),
173 MSCHAP_OPT_CALL_ENV(chap_error, auth),
174 MSCHAP_OPT_CALL_ENV(chap_mppe_keys, auth),
175 MSCHAP_OPT_CALL_ENV(mppe_encryption_policy, auth),
176 MSCHAP_OPT_CALL_ENV(mppe_recv_key, auth),
177 MSCHAP_OPT_CALL_ENV(mppe_send_key, auth),
178 MSCHAP_OPT_CALL_ENV(mppe_encryption_types, auth),
179 MSCHAP_OPT_CALL_ENV(chap2_cpw, auth),
180 MSCHAP_OPT_CALL_ENV(chap_nt_enc_pw, auth),
182};
183
204
211
214 MSCHAP_OPT_CALL_ENV(chap2_cpw, autz),
216};
217
219
221static fr_dict_t const *dict_radius;
222
225 { .out = &dict_freeradius, .proto = "freeradius" },
226 { .out = &dict_radius, .proto = "radius" },
228};
229
241
244 { .out = &attr_auth_type, .name = "Auth-Type", .type = FR_TYPE_UINT32, .dict = &dict_freeradius },
245 { .out = &attr_cleartext_password, .name = "Password.Cleartext", .type = FR_TYPE_STRING, .dict = &dict_freeradius },
246 { .out = &attr_eap_identity, .name = "EAP-Identity", .type = FR_TYPE_STRING, .dict = &dict_freeradius },
247 { .out = &attr_ms_chap_new_cleartext_password, .name = "MS-CHAP-New-Cleartext-Password", .type = FR_TYPE_STRING, .dict = &dict_freeradius },
248 { .out = &attr_ms_chap_new_nt_password, .name = "MS-CHAP-New-NT-Password", .type = FR_TYPE_OCTETS, .dict = &dict_freeradius },
249 { .out = &attr_ms_chap_peer_challenge, .name = "MS-CHAP-Peer-Challenge", .type = FR_TYPE_OCTETS, .dict = &dict_freeradius },
250 { .out = &attr_ms_chap_use_ntlm_auth, .name = "MS-CHAP-Use-NTLM-Auth", .type = FR_TYPE_UINT8, .dict = &dict_freeradius },
251 { .out = &attr_ms_chap_user_name, .name = "MS-CHAP-User-Name", .type = FR_TYPE_STRING, .dict = &dict_freeradius },
252 { .out = &attr_nt_password, .name = "Password.NT", .type = FR_TYPE_OCTETS, .dict = &dict_freeradius },
253 { .out = &attr_smb_account_ctrl_text, .name = "SMB-Account-Ctrl-Text", .type = FR_TYPE_STRING, .dict = &dict_freeradius },
254 { .out = &attr_smb_account_ctrl, .name = "SMB-Account-Ctrl", .type = FR_TYPE_UINT32, .dict = &dict_freeradius },
255
257};
258
260{
261 fr_pair_t *vp;
262
263 vp = fr_pair_find_by_da(&request->request_pairs, NULL, attr_user_name);
264 if (vp) return vp;
265
266 vp = fr_pair_find_by_da(&request->request_pairs, NULL, attr_eap_identity);
267 if (vp) return vp;
268
269 REDEBUG("No user identity found in current request");
270
271 return NULL;
272}
273
274static int pdb_decode_acct_ctrl(char const *p)
275{
276 int acct_ctrl = 0;
277 int done = 0;
278
279 /*
280 * Check if the account type bits have been encoded after the
281 * NT password (in the form [NDHTUWSLXI]).
282 */
283
284 if (*p != '[') return 0;
285
286 for (p++; *p && !done; p++) {
287 switch (*p) {
288 case 'N': /* 'N'o password. */
289 acct_ctrl |= ACB_PWNOTREQ;
290 break;
291
292 case 'D': /* 'D'isabled. */
293 acct_ctrl |= ACB_DISABLED ;
294 break;
295
296 case 'H': /* 'H'omedir required. */
297 acct_ctrl |= ACB_HOMDIRREQ;
298 break;
299
300 case 'T': /* 'T'emp account. */
301 acct_ctrl |= ACB_TEMPDUP;
302 break;
303
304 case 'U': /* 'U'ser account (normal). */
305 acct_ctrl |= ACB_NORMAL;
306 break;
307
308 case 'M': /* 'M'NS logon user account. What is this? */
309 acct_ctrl |= ACB_MNS;
310 break;
311
312 case 'W': /* 'W'orkstation account. */
313 acct_ctrl |= ACB_WSTRUST;
314 break;
315
316 case 'S': /* 'S'erver account. */
317 acct_ctrl |= ACB_SVRTRUST;
318 break;
319
320 case 'L': /* 'L'ocked account. */
321 acct_ctrl |= ACB_AUTOLOCK;
322 break;
323
324 case 'X': /* No 'X'piry on password */
325 acct_ctrl |= ACB_PWNOEXP;
326 break;
327
328 case 'I': /* 'I'nterdomain trust account. */
329 acct_ctrl |= ACB_DOMTRUST;
330 break;
331
332 case 'e': /* 'e'xpired, the password has */
333 acct_ctrl |= ACB_FR_EXPIRED;
334 break;
335
336 case ' ': /* ignore spaces */
337 break;
338
339 case ':':
340 case '\n':
341 case '\0':
342 case ']':
343 default:
344 done = 1;
345 break;
346 }
347 }
348
349 return acct_ctrl;
350}
351
353 { .required = true, .single = true, .type = FR_TYPE_STRING },
354 { .concat = true, .type = FR_TYPE_STRING },
356};
357
358/** Get data from MSCHAP attributes
359 *
360 * Pulls NT-Response, LM-Response, or Challenge from MSCHAP
361 * attributes.
362 *
363 * @ingroup xlat_functions
364 */
365static xlat_action_t mschap_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
366 xlat_ctx_t const *xctx,
367 request_t *request, fr_value_box_list_t *in)
368{
369 mschap_xlat_call_env_t *env_data = talloc_get_type_abort(xctx->env_data, mschap_xlat_call_env_t);
370 size_t data_len;
371 uint8_t const *data = NULL;
372 uint8_t buffer[32];
373 fr_pair_t *user_name;
374 fr_pair_t *chap_challenge, *response;
375 rlm_mschap_t const *inst = talloc_get_type_abort(xctx->mctx->mi->data, rlm_mschap_t);
376 fr_value_box_t *arg = fr_value_box_list_head(in);
377 fr_value_box_t *vb;
378 bool tainted = false;
379
380 response = NULL;
381
382 /*
383 * Challenge means MS-CHAPv1 challenge, or
384 * hash of MS-CHAPv2 challenge, and peer challenge.
385 */
386 if (strncasecmp(arg->vb_strvalue, "Challenge", 9) == 0) {
387 chap_challenge = fr_pair_find_by_da_nested(&request->request_pairs,
389 if (!chap_challenge) {
390 REDEBUG("No MS-CHAP-Challenge in the request");
391 return XLAT_ACTION_FAIL;
392 }
393 tainted = chap_challenge->vp_tainted;
394
395 /*
396 * MS-CHAP-Challenges are 8 octets,
397 * for MS-CHAPv1
398 */
399 if (chap_challenge->vp_length == 8) {
400 RDEBUG2("mschap1: %02x", chap_challenge->vp_octets[0]);
401 data = chap_challenge->vp_octets;
402 data_len = 8;
403
404 /*
405 * MS-CHAP-Challenges are 16 octets,
406 * for MS-CHAPv2.
407 */
408 } else if (chap_challenge->vp_length == 16) {
409 fr_pair_t *name_vp;
410 fr_pair_t *response_name;
411 char const *username_str;
412 size_t username_len;
413
414 response = fr_pair_find_by_da_nested(&request->request_pairs,
416 if (!response) {
417 REDEBUG("Vendor-Specific.Microsoft.CHAP2-Response is required to calculate MS-CHAPv1 challenge");
418 return XLAT_ACTION_FAIL;
419 }
420
421 /*
422 * FIXME: Much of this is copied from
423 * below. We should put it into a
424 * separate function.
425 */
426
427 /*
428 * Responses are 50 octets.
429 */
430 if (response->vp_length < 50) {
431 REDEBUG("Vendor-Specific.Microsoft.CHAP-Response has the wrong format");
432 return XLAT_ACTION_FAIL;
433 }
434
436 if (!user_name) return XLAT_ACTION_FAIL;
437
438 /*
439 * Check for MS-CHAP-User-Name and if found, use it
440 * to construct the MSCHAPv1 challenge. This is
441 * set by rlm_eap_mschap to the MS-CHAP Response
442 * packet Name field.
443 *
444 * We prefer this to the User-Name in the
445 * packet.
446 */
447 response_name = fr_pair_find_by_da(&request->request_pairs, NULL, attr_ms_chap_user_name);
448 name_vp = response_name ? response_name : user_name;
449
450 /*
451 * with_ntdomain_hack moved here, too.
452 */
453 username_str = memchr(name_vp->vp_strvalue, '\\', name_vp->vp_length);
454 if (username_str != NULL) {
455 if (inst->with_ntdomain_hack) {
456 username_str++;
457 } else {
458 RWDEBUG2("NT Domain delimiter found, should 'with_ntdomain_hack' be enabled?");
459 username_str = name_vp->vp_strvalue;
460 }
461 } else {
462 username_str = name_vp->vp_strvalue;
463 }
464 username_len = name_vp->vp_length - (username_str - name_vp->vp_strvalue);
465
466 if (response_name &&
467 ((user_name->vp_length != response_name->vp_length) ||
468 (memcmp(user_name->vp_strvalue, response_name->vp_strvalue, user_name->vp_length) != 0))) {
469 RWDEBUG2("%pP is not the same as %pP from EAP-MSCHAPv2", user_name, response_name);
470 }
471
472 /*
473 * Get the MS-CHAPv1 challenge
474 * from the MS-CHAPv2 peer challenge,
475 * our challenge, and the user name.
476 */
477 RDEBUG2("Creating challenge with username \"%pV\"",
478 fr_box_strvalue_len(username_str, username_len));
479 mschap_challenge_hash(buffer, response->vp_octets + 2, chap_challenge->vp_octets,
480 username_str, username_len);
481 data = buffer;
482 data_len = 8;
483 } else {
484 REDEBUG("Invalid MS-CHAP challenge length");
485 return XLAT_ACTION_FAIL;
486 }
487
488 /*
489 * Get the MS-CHAPv1 response, or the MS-CHAPv2
490 * response.
491 */
492 } else if (strncasecmp(arg->vb_strvalue, "NT-Response", 11) == 0) {
493 response = fr_pair_find_by_da_nested(&request->request_pairs,
495 if (!response) response = fr_pair_find_by_da_nested(&request->request_pairs,
497 if (!response) {
498 REDEBUG("No MS-CHAP-Response or MS-CHAP2-Response was found in the request");
499 return XLAT_ACTION_FAIL;
500 }
501 tainted = response->vp_tainted;
502
503 /*
504 * For MS-CHAPv1, the NT-Response exists only
505 * if the second octet says so.
506 */
507 if ((response->da == tmpl_attr_tail_da(env_data->chap_response)) && ((response->vp_octets[1] & 0x01) == 0)) {
508 REDEBUG("No NT-Response in MS-CHAP-Response");
509 return XLAT_ACTION_FAIL;
510 }
511
512 if (response->vp_length < 50) {
513 REDEBUG("Vendor-Specific.Microsoft.CHAP-Response has the wrong format");
514 return XLAT_ACTION_FAIL;
515 }
516
517 /*
518 * MS-CHAP-Response and MS-CHAP2-Response have
519 * the NT-Response at the same offset, and are
520 * the same length.
521 */
522 data = response->vp_octets + 26;
523 data_len = 24;
524
525 /*
526 * LM-Response is deprecated, and exists only
527 * in MS-CHAPv1, and not often there.
528 */
529 } else if (strncasecmp(arg->vb_strvalue, "LM-Response", 11) == 0) {
530 response = fr_pair_find_by_da_nested(&request->request_pairs,
532 if (!response) {
533 REDEBUG("No MS-CHAP-Response was found in the request");
534 return XLAT_ACTION_FAIL;
535 }
536 tainted = response->vp_tainted;
537
538 if (response->vp_length < 50) {
539 REDEBUG("Vendor-Specific.Microsoft.CHAP-Response has the wrong format");
540 return XLAT_ACTION_FAIL;
541 }
542 /*
543 * For MS-CHAPv1, the LM-Response exists only
544 * if the second octet says so.
545 */
546 if ((response->vp_octets[1] & 0x01) != 0) {
547 REDEBUG("No LM-Response in MS-CHAP-Response");
548 return XLAT_ACTION_FAIL;
549 }
550 data = response->vp_octets + 2;
551 data_len = 24;
552
553 /*
554 * Pull the domain name out of the User-Name, if it exists.
555 *
556 * This is the full domain name, not just the name after host/
557 */
558 } else if (strncasecmp(arg->vb_strvalue, "Domain-Name", 11) == 0) {
559 char const *p;
560
561 MEM(vb = fr_value_box_alloc_null(ctx));
562
564 if (!user_name) return XLAT_ACTION_FAIL;
565
566 /*
567 * First check to see if this is a host/ style User-Name
568 * (a la Kerberos host principal)
569 */
570 if (strncmp(user_name->vp_strvalue, "host/", 5) == 0) {
571 /*
572 * If we're getting a User-Name formatted in this way,
573 * it's likely due to PEAP. The Windows Domain will be
574 * the first domain component following the hostname,
575 * or the machine name itself if only a hostname is supplied
576 */
577 p = strchr(user_name->vp_strvalue, '.');
578 if (!p) {
579 RDEBUG2("setting Domain-Name to same as machine name");
580 fr_value_box_strdup(ctx, vb, NULL, user_name->vp_strvalue + 5, user_name->vp_tainted);
581 } else {
582 p++; /* skip the period */
583
584 fr_value_box_strdup(ctx, vb, NULL, p, user_name->vp_tainted);
585 }
586 } else {
587 p = strchr(user_name->vp_strvalue, '\\');
588 if (!p) {
589 REDEBUG("No domain name was found in the User-Name");
590 talloc_free(vb);
591 return XLAT_ACTION_FAIL;
592 }
593
594 fr_value_box_bstrndup(ctx, vb, NULL, user_name->vp_strvalue,
595 p - user_name->vp_strvalue, user_name->vp_tainted);
596 }
597
599 return XLAT_ACTION_DONE;
600
601 /*
602 * Pull the NT-Domain out of the User-Name, if it exists.
603 */
604 } else if (strncasecmp(arg->vb_strvalue, "NT-Domain", 9) == 0) {
605 char const *p, *q;
606
607 MEM(vb = fr_value_box_alloc_null(ctx));
608
610 if (!user_name) return XLAT_ACTION_FAIL;
611
612 /*
613 * First check to see if this is a host/ style User-Name
614 * (a la Kerberos host principal)
615 */
616 if (strncmp(user_name->vp_strvalue, "host/", 5) == 0) {
617 /*
618 * If we're getting a User-Name formatted in this way,
619 * it's likely due to PEAP. The Windows Domain will be
620 * the first domain component following the hostname,
621 * or the machine name itself if only a hostname is supplied
622 */
623 p = strchr(user_name->vp_strvalue, '.');
624 if (!p) {
625 RDEBUG2("setting NT-Domain to same as machine name");
626 fr_value_box_strdup(ctx, vb, NULL, user_name->vp_strvalue + 5, user_name->vp_tainted);
627 } else {
628 p++; /* skip the period */
629 q = strchr(p, '.');
630 if (q) {
631 fr_value_box_bstrndup(ctx, vb, NULL, p, q - p, user_name->vp_tainted);
632 } else {
633 fr_value_box_strdup(ctx, vb, NULL, p, user_name->vp_tainted);
634 }
635 }
636 } else {
637 p = strchr(user_name->vp_strvalue, '\\');
638 if (!p) {
639 REDEBUG("No NT-Domain was found in the User-Name");
640 talloc_free(vb);
641 return XLAT_ACTION_FAIL;
642 }
643
644 fr_value_box_bstrndup(ctx, vb, NULL, user_name->vp_strvalue,
645 p - user_name->vp_strvalue, user_name->vp_tainted);
646 }
647
649 return XLAT_ACTION_DONE;
650
651 /*
652 * Pull the User-Name out of the User-Name...
653 */
654 } else if (strncasecmp(arg->vb_strvalue, "User-Name", 9) == 0) {
655 char const *p, *q;
656
658 if (!user_name) return XLAT_ACTION_FAIL;
659
660 MEM(vb = fr_value_box_alloc_null(ctx));
661
662 /*
663 * First check to see if this is a host/ style User-Name
664 * (a la Kerberos host principal)
665 */
666 if (strncmp(user_name->vp_strvalue, "host/", 5) == 0) {
667 p = user_name->vp_strvalue + 5;
668 /*
669 * If we're getting a User-Name formatted in this way,
670 * it's likely due to PEAP. When authenticating this against
671 * a Domain, Windows will expect the User-Name to be in the
672 * format of hostname$, the SAM version of the name, so we
673 * have to convert it to that here. We do so by stripping
674 * off the first 5 characters (host/), and copying everything
675 * from that point to the first period into a string and appending
676 * a $ to the end.
677 */
678 q = strchr(p, '.');
679
680 /*
681 * use the same hack as above
682 * only if a period was found
683 */
684 if (q) {
685 fr_value_box_asprintf(ctx, vb, NULL, true, "%.*s$", (int) (q - p), p);
686 } else {
687 fr_value_box_asprintf(ctx, vb, NULL, true, "%s$", p);
688 }
689 } else {
690 p = strchr(user_name->vp_strvalue, '\\');
691 if (p) {
692 p++; /* skip the backslash */
693 } else {
694 p = user_name->vp_strvalue; /* use the whole User-Name */
695 }
696 fr_value_box_strdup(ctx, vb, NULL, p, user_name->vp_tainted);
697 }
698
700 return XLAT_ACTION_DONE;
701
702 /*
703 * Return the NT-Hash of the passed string
704 */
705 } else if (strncasecmp(arg->vb_strvalue, "NT-Hash", 7) == 0) {
706 arg = fr_value_box_list_next(in, arg);
707 if ((!arg) || (arg->vb_length == 0))
708 return XLAT_ACTION_FAIL;
709
710 if (mschap_nt_password_hash(buffer, arg->vb_strvalue) < 0) {
711 REDEBUG("Failed generating Password.NT");
712 *buffer = '\0';
713 return XLAT_ACTION_FAIL;
714 }
715
716 MEM(vb = fr_value_box_alloc_null(ctx));
717 fr_value_box_memdup(ctx, vb, NULL, buffer, NT_DIGEST_LENGTH, false);
718 RDEBUG2("NT-Hash of \"known-good\" password: %pV", vb);
720 return XLAT_ACTION_DONE;
721
722 /*
723 * Return the LM-Hash of the passed string
724 */
725 } else if (strncasecmp(arg->vb_strvalue, "LM-Hash", 7) == 0) {
726 arg = fr_value_box_list_next(in, arg);
727 if ((!arg) || (arg->vb_length == 0))
728 return XLAT_ACTION_FAIL;
729
730 smbdes_lmpwdhash(arg->vb_strvalue, buffer);
731
732 MEM(vb = fr_value_box_alloc_null(ctx));
733 fr_value_box_memdup(ctx, vb, NULL, buffer, LM_DIGEST_LENGTH, false);
734 RDEBUG2("LM-Hash of %s = %pV", arg->vb_strvalue, vb);
736 return XLAT_ACTION_DONE;
737 } else {
738 REDEBUG("Unknown expansion string '%pV'", arg);
739 return XLAT_ACTION_FAIL;
740 }
741
742 /*
743 * Didn't set anything: this is bad.
744 */
745 if (!data) {
746 RWDEBUG2("Failed to do anything intelligent");
747 return XLAT_ACTION_FAIL;
748 }
749
750 MEM(vb = fr_value_box_alloc_null(ctx));
751 fr_value_box_memdup(ctx, vb, NULL, data, data_len, tainted);
752
754 return XLAT_ACTION_DONE;
755}
756
757
758#ifdef WITH_AUTH_WINBIND
759/*
760 * Free winbind context
761 */
762static int _mod_ctx_free(winbind_ctx_t *wbctx)
763{
764 wbcCtxFree(wbctx->ctx);
765 return 0;
766}
767
768/*
769 * Create winbind context
770 */
771static int winbind_ctx_alloc(winbind_ctx_t *wbctx, UNUSED void *uctx)
772{
773 wbctx->ctx = wbcCtxCreate();
774 if (!wbctx->ctx) {
775 fr_strerror_printf("Unable to create winbind context");
776 return -1;
777 }
778 talloc_set_destructor(wbctx, _mod_ctx_free);
779 return 0;
780}
781#endif
782
783/*
784 * Add MPPE attributes to the reply.
785 */
787 request_t *request, fr_dict_attr_t const *da, uint8_t const *value, size_t len)
788{
789 fr_pair_t *vp;
790
791 MEM(pair_update_reply(&vp, da) >= 0);
793 RINDENT();
794 RDEBUG2("reply.%pP", vp);
795 REXDENT();
796}
797
798/*
799 * Write a string to an fd, followed by "\n"
800 */
801static int write_all(int fd, char const *buf, size_t len)
802{
803 char const *p = buf;
804 char const *end = buf + len;
805
806 while (p < end) {
807 ssize_t slen;
808
809 slen = write(fd, p, end - p);
810 if (slen <= 0) return -1;
811
812 fr_assert((size_t) slen <= (size_t) (end - p));
813
814 p += slen;
815 }
816
817 if (write(fd, "\n", 1) <= 0) return -1;
818
819 return 0;
820}
821
822/*
823 * Perform an MS-CHAP2 password change
824 */
825
827 uint8_t *new_nt_password, uint8_t *old_nt_hash)
828{
829 mschap_cpw_ctx_t *cpw_ctx = auth_ctx->cpw_ctx;
830 fr_value_box_t *vb;
831
832 if (inst->ntlm_cpw && auth_ctx->method != AUTH_INTERNAL) {
833 /*
834 * we're going to run ntlm_auth in helper-mode
835 * we're expecting to use the ntlm-change-password-1 protocol
836 * which needs the following on stdin:
837 *
838 * username: %mschap(User-Name)
839 * nt-domain: %mschap(NT-Domain)
840 * new-nt-password-blob: bin2hex(new_nt_password) - 1032 bytes encoded
841 * old-nt-hash-blob: bin2hex(old_nt_hash) - 32 bytes encoded
842 * new-lm-password-blob: 00000...0000 - 1032 bytes null
843 * old-lm-hash-blob: 000....000 - 32 bytes null
844 * .\n
845 *
846 * ...and it should then print out
847 *
848 * Password-Change: Yes
849 *
850 * or
851 *
852 * Password-Change: No
853 * Password-Change-Error: blah
854 */
855
856 size_t size;
857 int status, to_child=-1, from_child=-1;
858 ssize_t len;
859 pid_t pid, child_pid;
860 char buf[2048];
861 char *pmsg;
862 char const *emsg;
863
864 RDEBUG2("Doing MS-CHAPv2 password change via ntlm_auth helper");
865
866 /*
867 * Start up ntlm_auth with a pipe on stdin and stdout
868 */
869
870 pid = radius_start_program_legacy(&to_child, &from_child, NULL, inst->ntlm_cpw, request, true, NULL, false);
871 if (pid < 0) {
872 REDEBUG("could not exec ntlm_auth cpw command");
873 return -1;
874 }
875
876 /*
877 * write the stuff to the client
878 */
879
880 vb = fr_value_box_list_head(&cpw_ctx->cpw_user);
881 if (!vb) goto ntlm_auth_err;
882
883 if (write_all(to_child, vb->vb_strvalue, vb->vb_length) < 0) {
884 REDEBUG("Failed to write username to child");
885 goto ntlm_auth_err;
886 }
887
888 if (auth_ctx->env_data->ntlm_cpw_domain) {
889 vb = fr_value_box_list_head(&cpw_ctx->cpw_domain);
890 if (!vb) goto no_domain;
891
892 if (write_all(to_child, vb->vb_strvalue, vb->vb_length) < 0) {
893 REDEBUG("Failed to write domain to child");
894 goto ntlm_auth_err;
895 }
896 } else {
897 no_domain:
898 RWDEBUG2("No ntlm_auth domain set, username must be full-username to work");
899 }
900
901 /* now the password blobs */
902 size = snprintf(buf, sizeof(buf), "new-nt-password-blob: ");
903 fr_base16_encode(&FR_SBUFF_OUT(buf + size, sizeof(buf) - size), &FR_DBUFF_TMP(new_nt_password, 516));
904 size = strlen(buf);
905 if (write_all(to_child, buf, size) < 0) {
906 RDEBUG2("failed to write new password blob to child");
907 goto ntlm_auth_err;
908 }
909
910 size = snprintf(buf, sizeof(buf), "old-nt-hash-blob: ");
911 fr_base16_encode(&FR_SBUFF_OUT(buf + size, sizeof(buf) - size), &FR_DBUFF_TMP(old_nt_hash, NT_DIGEST_LENGTH));
912 size = strlen(buf);
913 if (write_all(to_child, buf, size) < 0) {
914 REDEBUG("Failed to write old hash blob to child");
915 goto ntlm_auth_err;
916 }
917
918 /*
919 * In current samba versions, failure to supply empty LM password/hash
920 * blobs causes the change to fail.
921 */
922 size = snprintf(buf, sizeof(buf), "new-lm-password-blob: %01032i", 0);
923 if (write_all(to_child, buf, size) < 0) {
924 REDEBUG("Failed to write dummy LM password to child");
925 goto ntlm_auth_err;
926 }
927 size = snprintf(buf, sizeof(buf), "old-lm-hash-blob: %032i", 0);
928 if (write_all(to_child, buf, size) < 0) {
929 REDEBUG("Failed to write dummy LM hash to child");
930 goto ntlm_auth_err;
931 }
932 if (write_all(to_child, ".", 1) < 0) {
933 REDEBUG("Failed to send finish to child");
934 goto ntlm_auth_err;
935 }
936 close(to_child);
937 to_child = -1;
938
939 /*
940 * Read from the child
941 */
942 len = radius_readfrom_program_legacy(from_child, pid, fr_time_delta_from_sec(10), buf, sizeof(buf) - 1);
943 if (len < 0) {
944 /* radius_readfrom_program_legacy will have closed from_child for us */
945 REDEBUG("Failure reading from child");
946 return -1;
947 }
948 close(from_child);
949 from_child = -1;
950
951 buf[len] = 0;
952 RDEBUG2("ntlm_auth said: %s", buf);
953
954 child_pid = waitpid(pid, &status, 0);
955 if (child_pid == 0) {
956 REDEBUG("Timeout waiting for child");
957 return -1;
958 }
959 if (child_pid != pid) {
960 REDEBUG("Abnormal exit status: %s", fr_syserror(errno));
961 return -1;
962 }
963
964 if (strstr(buf, "Password-Change: Yes")) {
965 RDEBUG2("ntlm_auth password change succeeded");
966 return 0;
967 }
968
969 pmsg = strstr(buf, "Password-Change-Error: ");
970 if (pmsg) {
971 emsg = strsep(&pmsg, "\n");
972 } else {
973 emsg = "could not find error";
974 }
975 REDEBUG("ntlm auth password change failed: %s", emsg);
976
977ntlm_auth_err:
978 /* safe because these either need closing or are == -1 */
979 close(to_child);
980 close(from_child);
981
982 return -1;
983
984 /*
985 * Decrypt the new password blob, add it as a temporary request
986 * variable, xlat the local_cpw string, then remove it
987 *
988 * this allows is to write e..g
989 *
990 * %sql(insert into ...)
991 *
992 * ...or...
993 *
994 * %exec('/path/to', %mschap(User-Name), %{MS-CHAP-New-Cleartext-Password})"
995 *
996 */
997#ifdef WITH_TLS
998 } else if (auth_ctx->env_data->local_cpw) {
999 RDEBUG2("Doing MS-CHAPv2 password change locally");
1000
1001 vb = fr_value_box_list_head(&cpw_ctx->local_cpw_result);
1002
1003 if (!vb){
1004 return -1;
1005 } else if (vb->vb_length == 0) {
1006 REDEBUG("Local MS-CHAPv2 password change - didn't give any result, assuming failure");
1007 return -1;
1008 }
1009
1010 RDEBUG2("MS-CHAPv2 password change succeeded: %pV", vb);
1011
1012 /*
1013 * Update the Password.NT attribute with the new hash this lets us
1014 * fall through to the authentication code using the new hash,
1015 * not the old one.
1016 */
1017 fr_pair_value_memdup(auth_ctx->nt_password, auth_ctx->cpw_ctx->new_hash->vp_octets,
1018 auth_ctx->cpw_ctx->new_hash->vp_length, false);
1019
1020 /*
1021 * Rock on! password change succeeded.
1022 */
1023 return 0;
1024#endif
1025 } else {
1026 REDEBUG("MS-CHAPv2 password change not configured");
1027 }
1028
1029 return -1;
1030}
1031
1032/*
1033 * Do the MS-CHAP stuff.
1034 *
1035 * This function is here so that all of the MS-CHAP related
1036 * authentication is in one place, and we can perhaps later replace
1037 * it with code to call winbindd, or something similar.
1038 */
1040 mschap_auth_ctx_t *auth_ctx,
1041 uint8_t const *challenge, uint8_t const *response,
1042 uint8_t nthashhash[static NT_DIGEST_LENGTH])
1043{
1044 uint8_t calculated[24];
1045 fr_pair_t *password = auth_ctx->nt_password;
1046
1047 memset(nthashhash, 0, NT_DIGEST_LENGTH);
1048
1049 switch (auth_ctx->method) {
1050 case AUTH_INTERNAL:
1051 case AUTH_AUTO:
1052 /*
1053 * Do normal authentication.
1054 */
1055 {
1056 /*
1057 * No password: can't do authentication.
1058 */
1059 if (!password) {
1060 if (auth_ctx->method == AUTH_AUTO) goto do_ntlm;
1061
1062 REDEBUG("FAILED: No Password.NT/LM. Cannot perform authentication");
1063 return -1;
1064 }
1065
1066 smbdes_mschap(password->vp_octets, challenge, calculated);
1067 if (fr_digest_cmp(response, calculated, 24) != 0) {
1068 return -1;
1069 }
1070
1071 /*
1072 * If the password exists, and is an NT-Password,
1073 * then calculate the hash of the NT hash. Doing this
1074 * here minimizes work for later.
1075 */
1076 if (password->da == attr_nt_password) fr_md4_calc(nthashhash, password->vp_octets, MD4_DIGEST_LENGTH);
1077 break;
1078 }
1079 case AUTH_NTLMAUTH_EXEC:
1080 do_ntlm:
1081 /*
1082 * Run ntlm_auth
1083 */
1084 {
1085 int result;
1086 char buffer[256];
1087 size_t len;
1088
1089 /*
1090 * Run the program, and expect that we get 16
1091 */
1092 result = radius_exec_program_legacy(buffer, sizeof(buffer), request, inst->ntlm_auth, NULL,
1093 true, true, inst->ntlm_auth_timeout);
1094 if (result != 0) {
1095 char *p;
1096
1097 /*
1098 * Do checks for numbers, which are
1099 * language neutral. They're also
1100 * faster.
1101 */
1102 p = strcasestr(buffer, "0xC0000");
1103 if (p) {
1104 result = 0;
1105
1106 p += 7;
1107 if (strcmp(p, "224") == 0) {
1108 result = -648;
1109
1110 } else if (strcmp(p, "234") == 0) {
1111 result = -647;
1112
1113 } else if (strcmp(p, "072") == 0) {
1114 result = -691;
1115
1116 } else if (strcasecmp(p, "05E") == 0) {
1117 result = -2;
1118 }
1119
1120 if (result != 0) {
1121 REDEBUG2("%s", buffer);
1122 return result;
1123 }
1124
1125 /*
1126 * Else fall through to more ridiculous checks.
1127 */
1128 }
1129
1130 /*
1131 * Look for variants of expire password.
1132 */
1133 if (strcasestr(buffer, "0xC0000224") ||
1134 strcasestr(buffer, "Password expired") ||
1135 strcasestr(buffer, "Password has expired") ||
1136 strcasestr(buffer, "Password must be changed") ||
1137 strcasestr(buffer, "Must change password")) {
1138 return -648;
1139 }
1140
1141 if (strcasestr(buffer, "0xC0000234") ||
1142 strcasestr(buffer, "Account locked out")) {
1143 REDEBUG2("%s", buffer);
1144 return -647;
1145 }
1146
1147 if (strcasestr(buffer, "0xC0000072") ||
1148 strcasestr(buffer, "Account disabled")) {
1149 REDEBUG2("%s", buffer);
1150 return -691;
1151 }
1152
1153 if (strcasestr(buffer, "0xC000005E") ||
1154 strcasestr(buffer, "No logon servers")) {
1155 REDEBUG2("%s", buffer);
1156 return -2;
1157 }
1158
1159 if (strcasestr(buffer, "could not obtain winbind separator") ||
1160 strcasestr(buffer, "Reading winbind reply failed")) {
1161 REDEBUG2("%s", buffer);
1162 return -2;
1163 }
1164
1165 RDEBUG2("External script failed");
1166 p = strchr(buffer, '\n');
1167 if (p) *p = '\0';
1168
1169 REDEBUG("External script says: %s", buffer);
1170 return -1;
1171 }
1172
1173 /*
1174 * Parse the answer as an nthashhash.
1175 *
1176 * ntlm_auth currently returns:
1177 * NT_KEY: 000102030405060708090a0b0c0d0e0f
1178 */
1179 if (memcmp(buffer, "NT_KEY: ", 8) != 0) {
1180 REDEBUG("Invalid output from ntlm_auth: expecting 'NT_KEY: ' prefix");
1181 return -1;
1182 }
1183
1184 /*
1185 * Check the length. It should be at least 32, with an LF at the end.
1186 */
1187 len = strlen(buffer + 8);
1188 if (len < 32) {
1189 REDEBUG2("Invalid output from ntlm_auth: NT_KEY too short, expected 32 bytes got %zu bytes",
1190 len);
1191
1192 return -1;
1193 }
1194
1195 /*
1196 * Update the NT hash hash, from the NT key.
1197 */
1198 if (fr_base16_decode(NULL, &FR_DBUFF_TMP(nthashhash, NT_DIGEST_LENGTH),
1199 &FR_SBUFF_IN(buffer + 8, len), false) != NT_DIGEST_LENGTH) {
1200 REDEBUG("Invalid output from ntlm_auth: NT_KEY has non-hex values");
1201 return -1;
1202 }
1203
1204 break;
1205 }
1206#ifdef WITH_AUTH_WINBIND
1207 case AUTH_WBCLIENT:
1208 /*
1209 * Process auth via the wbclient library
1210 */
1211 return do_auth_wbclient(inst, request, challenge, response, nthashhash, auth_ctx);
1212#endif
1213 default:
1214 /* We should never reach this line */
1215 RERROR("Internal error: Unknown mschap auth method (%u)", auth_ctx->method);
1216 return -1;
1217 }
1218
1219 return 0;
1220}
1221
1222
1223/*
1224 * Data for the hashes.
1225 */
1226static const uint8_t SHSpad1[40] =
1227 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1228 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1229 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1230 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
1231
1232static const uint8_t SHSpad2[40] =
1233 { 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2,
1234 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2,
1235 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2,
1236 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2 };
1237
1238static const uint8_t magic1[27] =
1239 { 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74,
1240 0x68, 0x65, 0x20, 0x4d, 0x50, 0x50, 0x45, 0x20, 0x4d,
1241 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x4b, 0x65, 0x79 };
1242
1243static const uint8_t magic2[84] =
1244 { 0x4f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69,
1245 0x65, 0x6e, 0x74, 0x20, 0x73, 0x69, 0x64, 0x65, 0x2c, 0x20,
1246 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
1247 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x20, 0x6b, 0x65, 0x79,
1248 0x3b, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73,
1249 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x73, 0x69, 0x64, 0x65,
1250 0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
1251 0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x20,
1252 0x6b, 0x65, 0x79, 0x2e };
1253
1254static const uint8_t magic3[84] =
1255 { 0x4f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69,
1256 0x65, 0x6e, 0x74, 0x20, 0x73, 0x69, 0x64, 0x65, 0x2c, 0x20,
1257 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68,
1258 0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x20,
1259 0x6b, 0x65, 0x79, 0x3b, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68,
1260 0x65, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x73,
1261 0x69, 0x64, 0x65, 0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73,
1262 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x20,
1263 0x6b, 0x65, 0x79, 0x2e };
1264
1265
1266static void mppe_GetMasterKey(uint8_t const *nt_hashhash, uint8_t const *nt_response,
1267 uint8_t *masterkey)
1268{
1269 uint8_t digest[20];
1270 fr_sha1_ctx Context;
1271
1272 fr_sha1_init(&Context);
1273 fr_sha1_update(&Context, nt_hashhash, NT_DIGEST_LENGTH);
1274 fr_sha1_update(&Context, nt_response, 24);
1275 fr_sha1_update(&Context, magic1, 27);
1276 fr_sha1_final(digest, &Context);
1277
1278 memcpy(masterkey, digest, 16); //-V512
1279}
1280
1281
1282static void mppe_GetAsymmetricStartKey(uint8_t *masterkey, uint8_t *sesskey,
1283 int keylen, int issend)
1284{
1285 uint8_t digest[20];
1286 const uint8_t *s;
1287 fr_sha1_ctx Context;
1288
1289 memset(digest, 0, 20);
1290
1291 if(issend) {
1292 s = magic3;
1293 } else {
1294 s = magic2;
1295 }
1296
1297 fr_sha1_init(&Context);
1298 fr_sha1_update(&Context, masterkey, 16);
1299 fr_sha1_update(&Context, SHSpad1, 40);
1300 fr_sha1_update(&Context, s, 84);
1301 fr_sha1_update(&Context, SHSpad2, 40);
1302 fr_sha1_final(digest, &Context);
1303
1304 memcpy(sesskey, digest, keylen);
1305}
1306
1307
1308static void mppe_chap2_get_keys128(uint8_t const *nt_hashhash, uint8_t const *nt_response,
1309 uint8_t *sendkey, uint8_t *recvkey)
1310{
1311 uint8_t masterkey[16];
1312
1313 mppe_GetMasterKey(nt_hashhash, nt_response, masterkey);
1314
1315 mppe_GetAsymmetricStartKey(masterkey, sendkey, 16, 1);
1316 mppe_GetAsymmetricStartKey(masterkey, recvkey, 16, 0);
1317}
1318
1319/*
1320 * Generate MPPE keys.
1321 */
1322static void mppe_chap2_gen_keys128(uint8_t const *nt_hashhash, uint8_t const *response,
1323 uint8_t *sendkey, uint8_t *recvkey)
1324{
1325 uint8_t enckey1[16];
1326 uint8_t enckey2[16];
1327
1328 mppe_chap2_get_keys128(nt_hashhash, response, enckey1, enckey2);
1329
1330 /*
1331 * dictionary.microsoft defines these attributes as
1332 * 'encrypt=Tunnel-Password'. The functions in src/lib/radius.c will
1333 * take care of encrypting/decrypting them as appropriate,
1334 * so that we don't have to.
1335 */
1336 memcpy (sendkey, enckey1, 16);
1337 memcpy (recvkey, enckey2, 16);
1338}
1339
1340
1341/*
1342 * mod_authorize() - authorize user if we can authenticate
1343 * it later. Add Auth-Type attribute if present in module
1344 * configuration (usually Auth-Type must be "MS-CHAP")
1345 */
1347{
1349 mschap_autz_call_env_t *env_data = talloc_get_type_abort(mctx->env_data, mschap_autz_call_env_t);
1350 fr_pair_t *challenge = NULL;
1352
1353 challenge = fr_pair_find_by_da_nested(&request->request_pairs, tmpl_attr_tail_da(env_data->chap_challenge));
1354 if (!challenge) RETURN_UNLANG_NOOP;
1355
1356 /*
1357 * The responses MUST be in the same group as the challenge.
1358 */
1359 parent = fr_pair_parent(challenge);
1360 fr_assert(parent != NULL);
1361
1362 if (!fr_pair_find_by_da(&parent->vp_group, NULL, tmpl_attr_tail_da(env_data->chap_response)) &&
1363 !fr_pair_find_by_da(&parent->vp_group, NULL, tmpl_attr_tail_da(env_data->chap2_response)) &&
1364 (env_data->chap2_cpw &&
1365 !fr_pair_find_by_da(&parent->vp_group, NULL, tmpl_attr_tail_da(env_data->chap2_cpw)))) {
1366 RDEBUG2("Found MS-CHAP-Challenge, but no MS-CHAP response or Change-Password");
1368 }
1369
1370 if (!inst->auth_type) {
1371 WARN("No 'authenticate %s {...}' section or 'Auth-Type = %s' set. Cannot setup MS-CHAP authentication",
1372 mctx->mi->name, mctx->mi->name);
1374 }
1375
1377
1379}
1380
1382 unsigned char ident, int mschap_result, int mschap_version, fr_pair_t *smb_ctrl,
1383 mschap_auth_call_env_t *env_data)
1384{
1385 rlm_rcode_t rcode = RLM_MODULE_OK;
1386 int error = 0;
1387 int retry = 0;
1388 char const *message = NULL;
1389
1390 int i;
1391 char new_challenge[33], buffer[128];
1392 char *p;
1393
1394 if ((mschap_result == -648) ||
1395 ((mschap_result == 0) &&
1396 (smb_ctrl && ((smb_ctrl->vp_uint32 & ACB_FR_EXPIRED) != 0)))) {
1397 REDEBUG("Password has expired. User should retry authentication");
1398 error = 648;
1399
1400 /*
1401 * A password change is NOT a retry! We MUST have retry=0 here.
1402 */
1403 retry = 0;
1404 message = "Password expired";
1405 rcode = RLM_MODULE_REJECT;
1406
1407 /*
1408 * Account is disabled.
1409 *
1410 * They're found, but they don't exist, so we
1411 * return 'not found'.
1412 */
1413 } else if ((mschap_result == -691) ||
1414 (smb_ctrl && (((smb_ctrl->vp_uint32 & ACB_DISABLED) != 0) ||
1415 ((smb_ctrl->vp_uint32 & (ACB_NORMAL|ACB_WSTRUST)) == 0)))) {
1416 REDEBUG("SMB-Account-Ctrl (or ntlm_auth) "
1417 "says that the account is disabled, "
1418 "or is not a normal or workstation trust account");
1419 error = 691;
1420 retry = 0;
1421 message = "Account disabled";
1422 rcode = RLM_MODULE_NOTFOUND;
1423
1424 /*
1425 * User is locked out.
1426 */
1427 } else if ((mschap_result == -647) ||
1428 (smb_ctrl && ((smb_ctrl->vp_uint32 & ACB_AUTOLOCK) != 0))) {
1429 REDEBUG("SMB-Account-Ctrl (or ntlm_auth) "
1430 "says that the account is locked out");
1431 error = 647;
1432 retry = 0;
1433 message = "Account locked out";
1434 rcode = RLM_MODULE_DISALLOW;
1435
1436 } else if (mschap_result < 0) {
1437 REDEBUG("%s is incorrect", mschap_version == 1 ? env_data->chap_response->name : env_data->chap2_response->name);
1438 error = 691;
1439 retry = inst->allow_retry;
1440 message = "Authentication failed";
1441 rcode = RLM_MODULE_REJECT;
1442 }
1443
1444 if (rcode == RLM_MODULE_OK) RETURN_UNLANG_OK;
1445
1446 switch (mschap_version) {
1447 case 1:
1448 for (p = new_challenge, i = 0; i < 2; i++) p += snprintf(p, 9, "%08x", fr_rand());
1449 snprintf(buffer, sizeof(buffer), "E=%i R=%i C=%s V=2",
1450 error, retry, new_challenge);
1451 break;
1452
1453 case 2:
1454 for (p = new_challenge, i = 0; i < 4; i++) p += snprintf(p, 9, "%08x", fr_rand());
1455 snprintf(buffer, sizeof(buffer), "E=%i R=%i C=%s V=3 M=%s",
1456 error, retry, new_challenge, message);
1457 break;
1458
1459 default:
1461 }
1462 if (env_data->chap_error) mschap_add_reply(request, ident, tmpl_attr_tail_da(env_data->chap_error),
1463 buffer, strlen(buffer));
1464
1465 RETURN_UNLANG_RCODE(rcode);
1466}
1467
1468
1469/** Find a Password.NT value, or create one from a Password.Cleartext, or Password.With-Header attribute
1470 *
1471 * @param[in] ctx to allocate ephemeral passwords in.
1472 * @param[out] out Our new Password.NT.
1473 * @param[in] inst Module configuration.
1474 * @param[in] request The current request.
1475 * @return
1476 * - 0 on success.
1477 * - -1 on failure.
1478 */
1479static int CC_HINT(nonnull(1, 2, 3)) nt_password_find(TALLOC_CTX *ctx, fr_pair_t **out,
1481{
1482 fr_pair_t *password;
1483 fr_dict_attr_t const *allowed_passwords[] = { attr_cleartext_password, attr_nt_password };
1484 bool ephemeral;
1485
1486 *out = NULL; /* Init output pointer */
1487
1488 password = password_find(&ephemeral, ctx, request,
1489 allowed_passwords, NUM_ELEMENTS(allowed_passwords), inst->normify);
1490 if (!password) {
1491 if (inst->method == AUTH_INTERNAL) {
1492 /*
1493 * Search for passwords in the parent
1494 * FIXME: This is a hack and should be removed
1495 * When EAP-MSCHAPv2 supports sections.
1496 */
1497 if (request->parent) {
1498 password = password_find(&ephemeral, ctx, request->parent,
1499 allowed_passwords,
1500 NUM_ELEMENTS(allowed_passwords), inst->normify);
1501 if (password) goto found_password;
1502 }
1503
1504 /*
1505 * If we're doing internal auth, then this is an issue
1506 */
1507 REDEBUG2("No control.%s.%s or control.%s.%s found. Cannot create Password.NT",
1509 attr_nt_password->parent->name, attr_nt_password->name);
1510 return -1;
1511
1512 /*
1513 * ..if we're not, then we can call out to external sources.
1514 */
1515 } else {
1516 return 0;
1517 }
1518 }
1519
1520found_password:
1521 if (password->da == attr_cleartext_password) {
1522 uint8_t *p;
1523 int ret;
1524 fr_pair_t *nt_password;
1525
1526 MEM(nt_password = fr_pair_afrom_da(ctx, attr_nt_password));
1527 MEM(fr_pair_value_mem_alloc(nt_password, &p, NT_DIGEST_LENGTH, false) == 0);
1528 ret = mschap_nt_password_hash(p, password->vp_strvalue);
1529
1530 if (ret < 0) {
1531 RERROR("Failed generating Password.NT");
1532 talloc_free(nt_password);
1533 if (ephemeral) TALLOC_FREE(password);
1534 return -1;
1535 }
1536
1537 if (RDEBUG_ENABLED3) {
1538 RDEBUG3("Hashed control.%pP to create %s = %pV",
1539 password, attr_nt_password->name, fr_box_octets(p, NT_DIGEST_LENGTH));
1540 } else {
1541 RDEBUG2("Hashed control.%s to create %s", attr_nt_password->name, password->da->name);
1542 }
1543
1544 if (ephemeral) TALLOC_FREE(password);
1545
1546 *out = nt_password;
1547
1548 return 0;
1549 }
1550
1551 fr_assert(password->da == attr_nt_password);
1552
1553 if (RDEBUG_ENABLED3) {
1554 RDEBUG3("Found control.%pP", password);
1555 } else {
1556 RDEBUG2("Found control.%s", attr_nt_password->name);
1557 }
1558 *out = password;
1559
1560 return 0;
1561}
1562
1563/*
1564 * mschap_cpw_request_process() - do the work to handle an MS-CHAP password
1565 * change request.
1566 */
1568 rlm_mschap_t const *inst,
1570 mschap_auth_ctx_t *auth_ctx)
1571{
1572 mschap_auth_call_env_t *env_data = auth_ctx->env_data;
1573 mschap_cpw_ctx_t *cpw_ctx = auth_ctx->cpw_ctx;
1574
1575 /*
1576 * Perform the actual password change
1577 */
1578 if (do_mschap_cpw(inst, request, auth_ctx, cpw_ctx->new_nt_encrypted, cpw_ctx->old_nt_hash) < 0) {
1579 char buffer[128];
1580
1581 REDEBUG("Password change failed");
1582
1583 if (env_data->chap_error) {
1584 snprintf(buffer, sizeof(buffer), "E=709 R=0 M=Password change failed");
1585 mschap_add_reply(request, auth_ctx->cpw->vp_octets[1],
1586 tmpl_attr_tail_da(env_data->chap_error), buffer, strlen(buffer));
1587 }
1588
1590 }
1591
1592 RDEBUG2("Password change successful");
1593
1595}
1596
1597/** Validate data required for change password requests.
1598 *
1599 */
1601{
1602 mschap_auth_call_env_t *env_data = auth_ctx->env_data;
1603 mschap_cpw_ctx_t *cpw_ctx;
1604 fr_dict_attr_t const *da;
1605 fr_pair_t *nt_enc = NULL;
1606 fr_pair_list_t *list;
1607 int seq, new_nt_enc_len;
1608
1609 /*
1610 * mschap2 password change request.
1611 *
1612 * We cheat - first decode and execute the passchange.
1613 * Then extract the response, add it into the request
1614 * and then jump into mschap2 auth with the challenge/
1615 * response.
1616 */
1617 RDEBUG2("MS-CHAPv2 password change request received");
1618
1619 if (auth_ctx->cpw->vp_length != 68) {
1620 REDEBUG("%s has the wrong format: length %zu != 68", env_data->chap2_cpw->name, auth_ctx->cpw->vp_length);
1621 return -1;
1622 }
1623
1624 if (auth_ctx->cpw->vp_octets[0] != 7) {
1625 REDEBUG("%s has the wrong format: code %d != 7", env_data->chap2_cpw->name, auth_ctx->cpw->vp_octets[0]);
1626 return -1;
1627 }
1628
1629 MEM(auth_ctx->cpw_ctx = talloc_zero(auth_ctx, mschap_cpw_ctx_t));
1630 cpw_ctx = auth_ctx->cpw_ctx;
1631
1632 da = tmpl_attr_tail_da(env_data->chap_nt_enc_pw);
1633 nt_enc = fr_pair_find_by_da_nested(&request->request_pairs, da);
1634 if (!nt_enc) {
1635 REDEBUG("%s is missing", env_data->chap_nt_enc_pw->name);
1636 return -1;
1637 }
1638 list = fr_pair_parent_list(nt_enc);
1639 fr_assert(list != NULL);
1640
1641 /*
1642 * Look for the new (encrypted) password.
1643 *
1644 * Bah, stupid composite attributes...
1645 * we're expecting 3 attributes with the leading bytes -
1646 * 06:<mschapid>:00:01:<1st chunk>
1647 * 06:<mschapid>:00:02:<2nd chunk>
1648 * 06:<mschapid>:00:03:<3rd chunk>
1649 */
1650 new_nt_enc_len = 0;
1651 for (seq = 1; seq < 4; seq++) {
1652 int found = 0;
1653
1654 do {
1655 if (nt_enc->vp_length < 4) {
1656 REDEBUG("%s with invalid format", env_data->chap_nt_enc_pw->name);
1657 return -1;
1658 }
1659
1660 if (nt_enc->vp_octets[0] != 6) {
1661 REDEBUG("%s with invalid format", env_data->chap_nt_enc_pw->name);
1662 return -1;
1663 }
1664
1665 if ((nt_enc->vp_octets[2] == 0) && (nt_enc->vp_octets[3] == seq)) {
1666 found = 1;
1667 break;
1668 }
1669 } while ((nt_enc = fr_pair_find_by_da(list, nt_enc, da)) != NULL);
1670
1671 if (!found) {
1672 REDEBUG("Could not find %s with sequence number %d", env_data->chap_nt_enc_pw->name, seq);
1673 return -1;
1674 }
1675
1676 if ((new_nt_enc_len + nt_enc->vp_length - 4) > sizeof(cpw_ctx->new_nt_encrypted)) {
1677 REDEBUG("Unpacked %s length > 516", env_data->chap_nt_enc_pw->name);
1678 return -1;
1679 }
1680
1681 memcpy(cpw_ctx->new_nt_encrypted + new_nt_enc_len, nt_enc->vp_octets + 4, nt_enc->vp_length - 4);
1682 new_nt_enc_len += nt_enc->vp_length - 4;
1683 }
1684
1685 if (new_nt_enc_len != 516) {
1686 REDEBUG("Unpacked %s length is %d - should be 516", env_data->chap_nt_enc_pw->name, new_nt_enc_len);
1687 return -1;
1688 }
1689
1690 /*
1691 * RFC 2548 is confusing here. It claims:
1692 *
1693 * 1 byte code
1694 * 1 byte ident
1695 * 16 octets - old hash encrypted with new hash
1696 * 24 octets - peer challenge
1697 * this is actually:
1698 * 16 octets - peer challenge
1699 * 8 octets - reserved
1700 * 24 octets - nt response
1701 * 2 octets - flags (ignored)
1702 */
1703
1704 memcpy(cpw_ctx->old_nt_hash, auth_ctx->cpw->vp_octets + 2, sizeof(cpw_ctx->old_nt_hash));
1705
1706 RDEBUG2("Password change payload valid");
1707 return 0;
1708}
1709
1710static CC_HINT(nonnull) unlang_action_t mschap_process_response(unlang_result_t *p_result, int *mschap_version,
1711 uint8_t nthashhash[static NT_DIGEST_LENGTH],
1713 mschap_auth_ctx_t *auth_ctx,
1714 fr_pair_t *challenge, fr_pair_t *response)
1715{
1716 int offset;
1717 int mschap_result;
1718 mschap_auth_call_env_t *env_data = auth_ctx->env_data;
1719
1720 *mschap_version = 1;
1721
1722 RDEBUG2("Processing MS-CHAPv1 response");
1723
1724 /*
1725 * MS-CHAPv1 challenges are 8 octets.
1726 */
1727 if (challenge->vp_length < 8) {
1728 REDEBUG("%s has the wrong format", env_data->chap_challenge->name);
1730 }
1731
1732 /*
1733 * Responses are 50 octets.
1734 */
1735 if (response->vp_length < 50) {
1736 REDEBUG("%s has the wrong format", env_data->chap_response->name);
1738 }
1739
1740 /*
1741 * We are doing MS-CHAP. Calculate the MS-CHAP
1742 * response
1743 */
1744 if (!(response->vp_octets[1] & 0x01)) {
1745 REDEBUG2("Client used unsupported method LM-Password");
1747 }
1748
1749 offset = 26;
1750
1751 /*
1752 * Do the MS-CHAP authentication.
1753 */
1754 mschap_result = do_mschap(inst, request, auth_ctx, challenge->vp_octets, response->vp_octets + offset, nthashhash);
1755
1756 /*
1757 * Check for errors, and add MSCHAP-Error if necessary.
1758 */
1759 return mschap_error(p_result, inst, request, *response->vp_octets, mschap_result, *mschap_version, auth_ctx->smb_ctrl, env_data);
1760}
1761
1762static unlang_action_t CC_HINT(nonnull) mschap_process_v2_response(unlang_result_t *p_result, int *mschap_version,
1763 uint8_t nthashhash[static NT_DIGEST_LENGTH],
1765 mschap_auth_ctx_t *auth_ctx,
1766 fr_pair_t *challenge, fr_pair_t *response)
1767{
1768 uint8_t mschap_challenge[16];
1769 fr_pair_t *user_name, *name_vp, *response_name, *peer_challenge_attr;
1770 uint8_t const *peer_challenge;
1771 char const *username_str;
1772 size_t username_len;
1773 int mschap_result;
1774 char msch2resp[42];
1775 mschap_auth_call_env_t *env_data = auth_ctx->env_data;
1776
1777 *mschap_version = 2;
1778
1779 RDEBUG2("Processing MS-CHAPv2 response");
1780
1781 /*
1782 * MS-CHAPv2 challenges are 16 octets.
1783 */
1784 if (challenge->vp_length < 16) {
1785 REDEBUG("%s has the wrong format", env_data->chap_challenge->name);
1787 }
1788
1789 /*
1790 * Responses are 50 octets.
1791 */
1792 if (response->vp_length < 50) {
1793 REDEBUG("%s has the wrong format", env_data->chap2_response->name);
1795 }
1796
1797 /*
1798 * We also require a User-Name
1799 */
1800 user_name = mschap_identity_find(request, tmpl_attr_tail_da(env_data->username));
1801 if (!user_name) RETURN_UNLANG_FAIL;
1802
1803 /*
1804 * Check for MS-CHAP-User-Name and if found, use it
1805 * to construct the MSCHAPv1 challenge. This is
1806 * set by rlm_eap_mschap to the MS-CHAP Response
1807 * packet Name field.
1808 *
1809 * We prefer this to the User-Name in the
1810 * packet.
1811 */
1812 response_name = fr_pair_find_by_da(&request->request_pairs, NULL, attr_ms_chap_user_name);
1813 name_vp = response_name ? response_name : user_name;
1814
1815 /*
1816 * with_ntdomain_hack moved here, too.
1817 */
1818 if ((username_str = strchr(name_vp->vp_strvalue, '\\')) != NULL) {
1819 if (inst->with_ntdomain_hack) {
1820 username_str++;
1821 } else {
1822 RWDEBUG2("NT Domain delimiter found, should 'with_ntdomain_hack' be enabled?");
1823 username_str = name_vp->vp_strvalue;
1824 }
1825 } else {
1826 username_str = name_vp->vp_strvalue;
1827 }
1828 username_len = name_vp->vp_length - (username_str - name_vp->vp_strvalue);
1829
1830 if (response_name && ((user_name->vp_length != response_name->vp_length) ||
1831 (strncasecmp(user_name->vp_strvalue, response_name->vp_strvalue, user_name->vp_length) != 0))) {
1832 RWDEBUG("%pP is not the same as %pP from EAP-MSCHAPv2", user_name, response_name);
1833 }
1834
1835#ifdef __APPLE__
1836 /*
1837 * No "known good" Password.NT attribute. Try to do
1838 * OpenDirectory authentication.
1839 *
1840 * If OD determines the user is an AD user it will return noop, which
1841 * indicates the auth process should continue directly to AD.
1842 * Otherwise OD will determine auth success/fail.
1843 */
1844 if (!auth_ctx->nt_password && inst->open_directory) {
1845 RDEBUG2("No Password.NT available. Trying OpenDirectory Authentication");
1846 od_mschap_auth(p_result, request, challenge, user_name, env_data);
1847 if (p_result->rcode != RLM_MODULE_NOOP) return UNLANG_ACTION_CALCULATE_RESULT;
1848 }
1849#endif
1850 peer_challenge = response->vp_octets + 2;
1851
1852 peer_challenge_attr = fr_pair_find_by_da(&request->control_pairs, NULL, attr_ms_chap_peer_challenge);
1853 if (peer_challenge_attr) {
1854 RDEBUG2("Overriding peer challenge");
1855 peer_challenge = peer_challenge_attr->vp_octets;
1856 }
1857
1858 /*
1859 * The old "mschapv2" function has been moved to
1860 * here.
1861 *
1862 * MS-CHAPv2 takes some additional data to create an
1863 * MS-CHAPv1 challenge, and then does MS-CHAPv1.
1864 */
1865 RDEBUG2("Creating challenge with username \"%pV\"",
1866 fr_box_strvalue_len(username_str, username_len));
1867 mschap_challenge_hash(mschap_challenge, /* resulting challenge */
1868 peer_challenge, /* peer challenge */
1869 challenge->vp_octets, /* our challenge */
1870 username_str, username_len); /* user name */
1871
1872 mschap_result = do_mschap(inst, request, auth_ctx, mschap_challenge, response->vp_octets + 26, nthashhash);
1873
1874 /*
1875 * Check for errors, and add MSCHAP-Error if necessary.
1876 */
1877 mschap_error(p_result, inst, request, *response->vp_octets,
1878 mschap_result, *mschap_version, auth_ctx->smb_ctrl, env_data);
1879 if (p_result->rcode != RLM_MODULE_OK) return UNLANG_ACTION_CALCULATE_RESULT;
1880
1881#ifdef WITH_AUTH_WINBIND
1882 if (inst->wb_retry_with_normalised_username) {
1883 response_name = fr_pair_find_by_da(&request->request_pairs, NULL, attr_ms_chap_user_name);
1884 if (response_name) {
1885 if (strcmp(username_str, response_name->vp_strvalue)) {
1886 RDEBUG2("Normalising username %pV -> %pV",
1887 fr_box_strvalue_len(username_str, username_len),
1888 &response_name->data);
1889 username_str = response_name->vp_strvalue;
1890 }
1891 }
1892 }
1893#endif
1894
1895 mschap_auth_response(username_str, /* without the domain */
1896 username_len, /* Length of username str */
1897 nthashhash, /* nt-hash-hash */
1898 response->vp_octets + 26, /* peer response */
1899 peer_challenge, /* peer challenge */
1900 challenge->vp_octets, /* our challenge */
1901 msch2resp); /* calculated MPPE key */
1902 if (env_data->chap2_success) mschap_add_reply(request, *response->vp_octets,
1903 tmpl_attr_tail_da(env_data->chap2_success), msch2resp, 42);
1904
1906}
1907
1908/** Complete mschap authentication after any tmpls have been expanded.
1909 *
1910 */
1912{
1913 mschap_auth_ctx_t *auth_ctx = talloc_get_type_abort(mctx->rctx, mschap_auth_ctx_t);
1914 mschap_auth_call_env_t *env_data = talloc_get_type_abort(auth_ctx->env_data, mschap_auth_call_env_t);
1916 fr_pair_t *challenge = NULL;
1917 fr_pair_t *response = NULL;
1919 uint8_t nthashhash[NT_DIGEST_LENGTH];
1920 int mschap_version = 0;
1921
1922 p_result->rcode = RLM_MODULE_OK;
1923
1924 if (auth_ctx->cpw) {
1925 uint8_t *p;
1926
1927 /*
1928 * Password change does require the NT password
1929 */
1930 if (!auth_ctx->nt_password) {
1931 REDEBUG("Missing Password.NT - required for change password request");
1933 }
1934 if (!env_data->chap_nt_enc_pw) {
1935 REDEBUG("chap_nt_enc_pw option is not set - required for change password request");
1937 }
1938
1939 mschap_process_cpw_request(p_result, inst, request, auth_ctx);
1940 if (p_result->rcode != RLM_MODULE_OK) goto finish;
1941
1942 /*
1943 * Clear any expiry bit so the user can now login;
1944 * obviously the password change action will need
1945 * to have cleared this bit in the config/SQL/wherever.
1946 */
1947 if (auth_ctx->smb_ctrl && auth_ctx->smb_ctrl->vp_uint32 & ACB_FR_EXPIRED) {
1948 RDEBUG2("Clearing expiry bit in SMB-Acct-Ctrl to allow authentication");
1949 auth_ctx->smb_ctrl->vp_uint32 &= ~ACB_FR_EXPIRED;
1950 }
1951
1952 /*
1953 * Extract the challenge & response from the end of the
1954 * password change, add them into the request and then
1955 * continue with the authentication.
1956 */
1957 MEM(pair_update_request(&response, tmpl_attr_tail_da(env_data->chap2_response)) >= 0);
1958 MEM(fr_pair_value_mem_alloc(response, &p, 50, auth_ctx->cpw->vp_tainted) == 0);
1959
1960 /* ident & flags */
1961 p[0] = auth_ctx->cpw->vp_octets[1];
1962 p[1] = 0;
1963 /* peer challenge and client NT response */
1964 memcpy(p + 2, auth_ctx->cpw->vp_octets + 18, 48);
1965 }
1966
1967 challenge = fr_pair_find_by_da_nested(&request->request_pairs, tmpl_attr_tail_da(env_data->chap_challenge));
1968 if (!challenge) {
1969 REDEBUG("control.Auth-Type = %s set for a request that does not contain %s",
1970 auth_ctx->name, env_data->chap_challenge->name);
1971 p_result->rcode = RLM_MODULE_INVALID;
1972 goto finish;
1973 }
1974
1975 /*
1976 * The responses MUST be in the same group as the challenge.
1977 */
1978 parent = fr_pair_parent(challenge);
1979 fr_assert(parent != NULL);
1980
1981 /*
1982 * We also require an MS-CHAP-Response.
1983 */
1984 if ((response = fr_pair_find_by_da(&parent->vp_group, NULL, tmpl_attr_tail_da(env_data->chap_response)))) {
1985 mschap_process_response(p_result,
1986 &mschap_version, nthashhash,
1987 inst, request,
1988 auth_ctx,
1989 challenge, response);
1990 if (p_result->rcode != RLM_MODULE_OK) goto finish;
1991 } else if ((response = fr_pair_find_by_da_nested(&parent->vp_group, tmpl_attr_tail_da(env_data->chap2_response)))) {
1993 &mschap_version, nthashhash,
1994 inst, request,
1995 auth_ctx,
1996 challenge, response);
1997 if (p_result->rcode != RLM_MODULE_OK) goto finish;
1998 } else { /* Neither CHAPv1 or CHAPv2 response: die */
1999 REDEBUG("control.Auth-Type = %s set for a request that does not contain %s or %s attributes",
2000 auth_ctx->name, env_data->chap_response->name, env_data->chap2_response->name);
2001 p_result->rcode = RLM_MODULE_INVALID;
2002 goto finish;
2003 }
2004
2005 /* now create MPPE attributes */
2006 if (inst->use_mppe) {
2007 fr_pair_t *vp;
2008 uint8_t mppe_sendkey[34];
2009 uint8_t mppe_recvkey[34];
2010
2011 switch (mschap_version) {
2012 case 1:
2013 RDEBUG2("Generating MS-CHAPv1 MPPE keys");
2014 memset(mppe_sendkey, 0, 32);
2015
2016 /*
2017 * According to RFC 2548 we
2018 * should send NT hash. But in
2019 * practice it doesn't work.
2020 * Instead, we should send nthashhash
2021 *
2022 * This is an error in RFC 2548.
2023 */
2024 /*
2025 * do_mschap cares to zero nthashhash if NT hash
2026 * is not available.
2027 */
2028 memcpy(mppe_sendkey + 8, nthashhash, NT_DIGEST_LENGTH);
2029 mppe_add_reply(inst, request, tmpl_attr_tail_da(env_data->chap_mppe_keys), mppe_sendkey, 24); //-V666
2030 break;
2031
2032 case 2:
2033 RDEBUG2("Generating MS-CHAPv2 MPPE keys");
2034 mppe_chap2_gen_keys128(nthashhash, response->vp_octets + 26, mppe_sendkey, mppe_recvkey);
2035
2036 mppe_add_reply(inst, request, tmpl_attr_tail_da(env_data->mppe_recv_key), mppe_recvkey, 16);
2037 mppe_add_reply(inst, request, tmpl_attr_tail_da(env_data->mppe_send_key), mppe_sendkey, 16);
2038 break;
2039
2040 default:
2041 fr_assert(0);
2042 break;
2043 }
2044
2046 vp->vp_uint32 = inst->require_encryption ? 2 : 1;
2047
2049 vp->vp_uint32 = inst->require_strong ? 4 : 6;
2050 } /* else we weren't asked to use MPPE */
2051
2052finish:
2054}
2055
2056#ifdef WITH_TLS
2057/** Decrypt the new cleartext password when handling change password requests
2058 *
2059 */
2060static int mschap_new_pass_decrypt(request_t *request, mschap_auth_ctx_t *auth_ctx)
2061{
2062 EVP_CIPHER_CTX *evp_ctx;
2063 uint8_t nt_pass_decrypted[516], old_nt_hash_expected[NT_DIGEST_LENGTH];
2064 int c, ntlen = sizeof(nt_pass_decrypted);
2065 size_t passlen, i = 0, len = 0;
2066 char *x;
2067 uint8_t *p, *q;
2068 fr_pair_t *new_pass;
2069
2070 MEM(evp_ctx = EVP_CIPHER_CTX_new());
2071
2072 if (unlikely(EVP_EncryptInit_ex(evp_ctx, EVP_rc4(), NULL, auth_ctx->nt_password->vp_octets, NULL) != 1)) {
2073 EVP_CIPHER_CTX_free(evp_ctx);
2074 fr_tls_strerror_printf(NULL);
2075 RPERROR("Failed initialising RC4 ctx");
2076 return -1;
2077 }
2078
2079 if (unlikely(EVP_CIPHER_CTX_set_key_length(evp_ctx, (int)auth_ctx->nt_password->vp_length) != 1)) {
2080 EVP_CIPHER_CTX_free(evp_ctx);
2081 fr_tls_strerror_printf(NULL);
2082 RPERROR("Failed setting key length");
2083 return -1;
2084 }
2085
2086 if (unlikely(EVP_EncryptUpdate(evp_ctx, nt_pass_decrypted, &ntlen, auth_ctx->cpw_ctx->new_nt_encrypted, ntlen) != 1)) {
2087 EVP_CIPHER_CTX_free(evp_ctx);
2088 fr_tls_strerror_printf(NULL);
2089 RPERROR("Failed ingesting new password");
2090 return -1;
2091 }
2092
2093 EVP_CIPHER_CTX_free(evp_ctx);
2094
2095 /*
2096 * pwblock is
2097 * 512-N bytes random pad
2098 * N bytes password as utf-16-le
2099 * 4 bytes - N as big-endian int
2100 */
2101 passlen = nt_pass_decrypted[512];
2102 passlen += nt_pass_decrypted[513] << 8;
2103 if ((nt_pass_decrypted[514] != 0) ||
2104 (nt_pass_decrypted[515] != 0)) {
2105 REDEBUG("Decrypted new password blob claims length > 65536, probably an invalid Password.NT");
2106 return -1;
2107 }
2108
2109 /*
2110 * Sanity check - passlen positive and <= 512 if not, crypto has probably gone wrong
2111 */
2112 if (passlen > 512) {
2113 REDEBUG("Decrypted new password blob claims length %zu > 512, "
2114 "probably an invalid Password.NT", passlen);
2115 return -1;
2116 }
2117
2118 p = nt_pass_decrypted + 512 - passlen;
2119
2120 /*
2121 * The new NT hash - this should be preferred over the
2122 * cleartext password as it avoids unicode hassles.
2123 */
2125 MEM(fr_pair_value_mem_alloc(auth_ctx->cpw_ctx->new_hash, &q, NT_DIGEST_LENGTH, false) == 0);
2126 fr_md4_calc(q, p, passlen);
2127
2128 /*
2129 * Check that nt_password encrypted with new_hash
2130 * matches the old_hash value from the client.
2131 */
2132 smbhash(old_nt_hash_expected, auth_ctx->nt_password->vp_octets, q);
2133 smbhash(old_nt_hash_expected + 8, auth_ctx->nt_password->vp_octets + 8, q + 7);
2134 if (fr_digest_cmp(old_nt_hash_expected, auth_ctx->cpw_ctx->old_nt_hash, NT_DIGEST_LENGTH)!=0) {
2135 REDEBUG("Old NT hash value from client does not match our value");
2136 RHEXDUMP1(old_nt_hash_expected, NT_DIGEST_LENGTH, "expected");
2137 RHEXDUMP1(auth_ctx->cpw_ctx->old_nt_hash, NT_DIGEST_LENGTH, "got");
2138 return -1;
2139 }
2140
2141 /*
2142 * The new cleartext password, which is utf-16 do some unpleasant vileness
2143 * to turn it into utf8 without pulling in libraries like iconv.
2144 *
2145 * First pass: get the length of the converted string.
2146 */
2148 new_pass->vp_length = 0;
2149
2150 while (i < passlen) {
2151 c = p[i++];
2152 c += p[i++] << 8;
2153
2154 /*
2155 * Gah. nasty. maybe we should just pull in iconv?
2156 */
2157 if (c <= 0x7f) {
2158 len++;
2159 } else if (c <= 0x7ff) {
2160 len += 2;
2161 } else {
2162 len += 3;
2163 }
2164 }
2165
2166 MEM(fr_pair_value_bstr_alloc(new_pass, &x, len, true) == 0);
2167
2168 /*
2169 * Second pass: convert the characters from UTF-16 to UTF-8.
2170 */
2171 i = 0;
2172 while (i < passlen) {
2173 c = p[i++];
2174 c += p[i++] << 8;
2175
2176 /*
2177 * Gah. nasty. maybe we should just pull in iconv?
2178 */
2179 if (c <= 0x7f) {
2180 *x++ = c;
2181
2182 } else if (c <= 0x7ff) {
2183 *x++ = 0xc0 + (c >> 6);
2184 *x++ = 0x80 + (c & 0x3f);
2185
2186 } else {
2187 *x++ = 0xe0 + (c >> 12);
2188 *x++ = 0x80 + ((c>>6) & 0x3f);
2189 *x++ = 0x80 + (c & 0x3f);
2190 }
2191 }
2192
2193 *x = '\0';
2194 return 0;
2195}
2196#endif
2197
2198/*
2199 * mod_authenticate() - authenticate user based on given
2200 * attributes and configuration.
2201 * We will try to find out password in configuration
2202 * or in configured passwd file.
2203 * If one is found we will check paraneters given by NAS.
2204 *
2205 * If SMB-Account-Ctrl is not set to ACB_PWNOTREQ we must have
2206 * one of:
2207 * PAP: User-Password or
2208 * MS-CHAP: MS-CHAP-Challenge and MS-CHAP-Response or
2209 * MS-CHAP2: MS-CHAP-Challenge and MS-CHAP2-Response
2210 * In case of password mismatch or locked account we MAY return
2211 * MS-CHAP-Error for MS-CHAP or MS-CHAP v2
2212 * If MS-CHAP2 succeeds we MUST return MS-CHAP2-Success
2213 */
2215{
2217#ifdef WITH_AUTH_WINBIND
2218 rlm_mschap_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_mschap_thread_t);
2219#endif
2220 mschap_auth_call_env_t *env_data = talloc_get_type_abort(mctx->env_data, mschap_auth_call_env_t);
2221 mschap_auth_ctx_t *auth_ctx;
2222
2224
2225 /*
2226 * If we have ntlm_auth configured, use it unless told
2227 * otherwise
2228 */
2229 *auth_ctx = (mschap_auth_ctx_t) {
2230 .name = mctx->mi->name,
2231 .inst = inst,
2232 .method = inst->method,
2233 .env_data = env_data,
2234#ifdef WITH_AUTH_WINBIND
2235 .t = t,
2236#endif
2237 };
2238
2239 /*
2240 * If we have an ntlm_auth configuration, then we may
2241 * want to suppress it.
2242 */
2243 if (auth_ctx->method != AUTH_INTERNAL) {
2245 if (vp && (vp->vp_uint8 <= AUTH_AUTO)) auth_ctx->method = (MSCHAP_AUTH_METHOD)vp->vp_uint8;
2246 }
2247
2248 /*
2249 * Find the SMB-Account-Ctrl attribute, or the
2250 * SMB-Account-Ctrl-Text attribute.
2251 */
2252 auth_ctx->smb_ctrl = fr_pair_find_by_da(&request->control_pairs, NULL, attr_smb_account_ctrl);
2253 if (!auth_ctx->smb_ctrl) {
2254 fr_pair_t *smb_account_ctrl_text;
2255
2256 smb_account_ctrl_text = fr_pair_find_by_da(&request->control_pairs, NULL, attr_smb_account_ctrl_text);
2257 if (smb_account_ctrl_text) {
2259 auth_ctx->smb_ctrl->vp_uint32 = pdb_decode_acct_ctrl(smb_account_ctrl_text->vp_strvalue);
2260 }
2261 }
2262
2263 /*
2264 * We're configured to do MS-CHAP authentication.
2265 * and account control information exists. Enforce it.
2266 */
2267 if (auth_ctx->smb_ctrl) {
2268 /*
2269 * Password is not required.
2270 */
2271 if ((auth_ctx->smb_ctrl->vp_uint32 & ACB_PWNOTREQ) != 0) {
2272 RDEBUG2("SMB-Account-Ctrl says no password is required");
2274 }
2275 }
2276
2277 /*
2278 * Look for or create an Password.NT
2279 *
2280 * Password.NT can be NULL here if we didn't find an
2281 * input attribute, and we're calling out to an
2282 * external password store.
2283 */
2284 if (nt_password_find(auth_ctx, &auth_ctx->nt_password, mctx->mi->data, request) < 0) RETURN_UNLANG_FAIL;
2285
2286 /*
2287 * Check to see if this is a change password request, and process
2288 * it accordingly if so.
2289 */
2290 if (env_data->chap2_cpw) auth_ctx->cpw = fr_pair_find_by_da_nested(&request->request_pairs,
2291 tmpl_attr_tail_da(env_data->chap2_cpw));
2292 if (auth_ctx->cpw) {
2293 /*
2294 * Password change does require the NT password
2295 */
2296 if (!auth_ctx->nt_password) {
2297 REDEBUG("Missing Password.NT - required for change password request");
2299 }
2300
2301 if (mschap_cpw_prepare(request, auth_ctx) < 0) RETURN_UNLANG_FAIL;
2302
2303 switch (auth_ctx->method) {
2304 case AUTH_INTERNAL:
2305#ifdef WITH_TLS
2306 if (mschap_new_pass_decrypt(request, auth_ctx) < 0) RETURN_UNLANG_FAIL;
2307
2310 }
2311
2312 fr_value_box_list_init(&auth_ctx->cpw_ctx->local_cpw_result);
2313 if (unlang_tmpl_push(auth_ctx, NULL, &auth_ctx->cpw_ctx->local_cpw_result, request,
2314 env_data->local_cpw, NULL, UNLANG_SUB_FRAME) < 0) RETURN_UNLANG_FAIL;
2315 break;
2316#else
2317 REDEBUG("Local MS-CHAPv2 password changes require OpenSSL support");
2319#endif
2320
2321 default:
2322 if (!env_data->ntlm_cpw_username) {
2323 REDEBUG("No ntlm_auth username set, passchange will definitely fail!");
2325 }
2326
2327 /*
2328 * Run the resumption function where we're done with:
2329 */
2332 }
2333
2334 /*
2335 * a) Expanding the domain, if specified
2336 */
2337 if (env_data->ntlm_cpw_domain) {
2338 fr_value_box_list_init(&auth_ctx->cpw_ctx->cpw_domain);
2339 if (unlang_tmpl_push(auth_ctx, NULL, &auth_ctx->cpw_ctx->cpw_domain, request,
2341 }
2342
2343 fr_value_box_list_init(&auth_ctx->cpw_ctx->cpw_user);
2344
2345 /*
2346 * b) Expanding the username
2347 */
2348 if (unlang_tmpl_push(auth_ctx, NULL, &auth_ctx->cpw_ctx->cpw_user, request,
2350 break;
2351 }
2352
2354 }
2355
2356 /*
2357 * Not doing password change, just jump straight to the resumption function...
2358 */
2359 {
2360 module_ctx_t our_mctx = *mctx;
2361 our_mctx.rctx = auth_ctx;
2362
2363 return mod_authenticate_resume(p_result, &our_mctx, request);
2364 }
2365}
2366
2367/*
2368 * Create instance for our module. Allocate space for
2369 * instance structure and read configuration parameters
2370 */
2371static int mod_instantiate(module_inst_ctx_t const *mctx)
2372{
2373 rlm_mschap_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_mschap_t);
2374 CONF_SECTION *conf = mctx->mi->conf;
2375
2376 inst->auth_type = fr_dict_enum_by_name(attr_auth_type, mctx->mi->name, -1);
2377 if (!inst->auth_type) {
2378 WARN("Failed to find 'authenticate %s {...}' section. MS-CHAP authentication will likely not work",
2379 mctx->mi->name);
2380 }
2381
2382 /*
2383 * Set auth method
2384 */
2385 inst->method = AUTH_INTERNAL;
2386
2387 if (inst->wb_username) {
2388#ifdef WITH_AUTH_WINBIND
2389 inst->method = AUTH_WBCLIENT;
2390#else
2391 cf_log_err(conf, "'winbind' auth not enabled at compiled time");
2392 return -1;
2393#endif
2394 }
2395
2396 /* preserve existing behaviour: this option overrides all */
2397 if (inst->ntlm_auth) {
2398 inst->method = AUTH_NTLMAUTH_EXEC;
2399 }
2400
2401 switch (inst->method) {
2402 case AUTH_INTERNAL:
2403 DEBUG("Using internal authentication");
2404 break;
2405 case AUTH_AUTO:
2406 DEBUG("Using auto password or ntlm_auth");
2407 break;
2408 case AUTH_NTLMAUTH_EXEC:
2409 DEBUG("Authenticating by calling 'ntlm_auth'");
2410 break;
2411#ifdef WITH_AUTH_WINBIND
2412 case AUTH_WBCLIENT:
2413 DEBUG("Authenticating directly to winbind");
2414 break;
2415#endif
2416 }
2417
2418 /*
2419 * Check ntlm_auth_timeout is sane
2420 */
2421 if (!fr_time_delta_ispos(inst->ntlm_auth_timeout)) {
2422 inst->ntlm_auth_timeout = fr_time_delta_from_sec(EXEC_TIMEOUT);
2423 }
2424 if (fr_time_delta_lt(inst->ntlm_auth_timeout, fr_time_delta_from_sec(1))) {
2425 cf_log_err(conf, "ntml_auth_timeout '%pVs' is too small (minimum: 1s)",
2426 fr_box_time_delta(inst->ntlm_auth_timeout));
2427 return -1;
2428 }
2429 if (fr_time_delta_gt(inst->ntlm_auth_timeout, fr_time_delta_from_sec(10))) {
2430 cf_log_err(conf, "ntlm_auth_timeout '%pVs' is too large (maximum: 10s)",
2431 fr_box_time_delta(inst->ntlm_auth_timeout));
2432 return -1;
2433 }
2434
2435#define CHECK_OPTION(_option) cp = cf_pair_find(attrs, STRINGIFY(_option)); \
2436if (!cp) { \
2437 WARN("Missing option \"" STRINGIFY(_option) "\", setting use_mppe to \"no\""); \
2438 inst->use_mppe = false; \
2439 goto done_mppe_check; \
2440}
2441
2442 /*
2443 * Check that MPPE attributes are in the module config, if the option is enabled.
2444 * Validity of them will be checked when the module is compiled.
2445 */
2446 if (inst->use_mppe) {
2447 CONF_SECTION *attrs = cf_section_find(conf, "attributes", NULL);
2448 CONF_PAIR *cp;
2449
2450 if (!attrs) {
2451 cf_log_err(conf, "Missing required \"attributes\" section");
2452 return -1;
2453 }
2454 CHECK_OPTION(chap_mppe_keys)
2455 CHECK_OPTION(mppe_encryption_policy)
2456 CHECK_OPTION(mppe_recv_key)
2457 CHECK_OPTION(mppe_send_key)
2458 CHECK_OPTION(mppe_encryption_types)
2459 }
2460done_mppe_check:
2461
2462 return 0;
2463}
2464
2465static int mod_bootstrap(module_inst_ctx_t const *mctx)
2466{
2467 xlat_t *xlat;
2468
2469 xlat = module_rlm_xlat_register(mctx->mi->boot, mctx, NULL, mschap_xlat, FR_TYPE_VOID);
2471 xlat_func_call_env_set(xlat, &mschap_xlat_method_env);
2472
2473 return 0;
2474}
2475
2476#ifdef WITH_AUTH_WINBIND
2478{
2479 rlm_mschap_t const *inst = talloc_get_type_abort(mctx->mi->data, rlm_mschap_t);
2480 rlm_mschap_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_mschap_thread_t);
2481
2482 t->inst = inst;
2483 if (!(t->slab = mschap_slab_list_alloc(t, mctx->el, &inst->reuse, winbind_ctx_alloc, NULL, NULL, false, false))) {
2484 ERROR("Connection handle pool instantiation failed");
2485 return -1;
2486 }
2487
2488 return 0;
2489}
2490
2491static int mod_thread_detach(module_thread_inst_ctx_t const *mctx)
2492{
2493 rlm_mschap_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_mschap_thread_t);
2494 talloc_free(t->slab);
2495 return 0;
2496}
2497#endif
2498
2501 .common = {
2502 .magic = MODULE_MAGIC_INIT,
2503 .name = "mschap",
2504 .inst_size = sizeof(rlm_mschap_t),
2506 .bootstrap = mod_bootstrap,
2507 .instantiate = mod_instantiate,
2508#ifdef WITH_AUTH_WINBIND
2509 .thread_inst_size = sizeof(rlm_mschap_thread_t),
2510 .thread_instantiate = mod_thread_instantiate,
2511 .thread_detach = mod_thread_detach
2512#endif
2513 },
2514 .method_group = {
2515 .bindings = (module_method_binding_t[]){
2516 { .section = SECTION_NAME("authenticate", CF_IDENT_ANY), .method = mod_authenticate, .method_env = &mschap_auth_method_env },
2517 { .section = SECTION_NAME("recv", CF_IDENT_ANY), .method = mod_authorize, .method_env = &mschap_autz_method_env },
2519 }
2520 }
2521};
unlang_action_t
Returned by unlang_op_t calls, determine the next action of the interpreter.
Definition action.h:35
@ UNLANG_ACTION_PUSHED_CHILD
unlang_t pushed a new child onto the stack, execute it instead of continuing.
Definition action.h:40
@ UNLANG_ACTION_FAIL
Encountered an unexpected error.
Definition action.h:36
@ UNLANG_ACTION_CALCULATE_RESULT
Calculate a new section rlm_rcode_t value.
Definition action.h:38
static int const char char buffer[256]
Definition acutest.h:641
int do_auth_wbclient(rlm_mschap_t const *inst, request_t *request, uint8_t const *challenge, uint8_t const *response, uint8_t nthashhash[NT_DIGEST_LENGTH], mschap_auth_ctx_t *auth_ctx)
Check NTLM authentication direct to winbind via Samba's libwbclient library.
#define fr_base16_encode(_out, _in)
Definition base16.h:71
#define fr_base16_decode(_err, _out, _in, _no_trailing)
Definition base16.h:109
static uint8_t request[4]
#define USES_APPLE_DEPRECATED_API
Definition build.h:590
#define RCSID(id)
Definition build.h:603
#define unlikely(_x)
Definition build.h:486
#define UNUSED
Definition build.h:415
#define NUM_ELEMENTS(_t)
Definition build.h:437
#define CALL_ENV_TERMINATOR
Definition call_env.h:236
#define FR_CALL_ENV_METHOD_OUT(_inst)
Helper macro for populating the size/type fields of a call_env_method_t from the output structure typ...
Definition call_env.h:240
@ CALL_ENV_FLAG_SUBSECTION
This is a subsection.
Definition call_env.h:87
@ CALL_ENV_FLAG_ATTRIBUTE
Tmpl MUST contain an attribute reference.
Definition call_env.h:86
@ CALL_ENV_FLAG_NONE
Definition call_env.h:74
@ CALL_ENV_FLAG_REQUIRED
Associated conf pair or section is required.
Definition call_env.h:75
@ CALL_ENV_FLAG_NULLABLE
Tmpl expansions are allowed to produce no output.
Definition call_env.h:80
call_env_parser_t const * env
Parsing rules for call method env.
Definition call_env.h:247
#define FR_CALL_ENV_SUBSECTION(_name, _name2, _flags, _subcs)
Specify a call_env_parser_t which defines a nested subsection.
Definition call_env.h:402
#define FR_CALL_ENV_OFFSET(_name, _cast_type, _flags, _struct, _field)
Specify a call_env_parser_t which writes out runtime results to the specified field.
Definition call_env.h:340
#define FR_CALL_ENV_PARSE_ONLY_OFFSET(_name, _cast_type, _flags, _struct, _parse_field)
Specify a call_env_parser_t which writes out the result of the parsing phase to the field specified.
Definition call_env.h:389
Per method call config.
Definition call_env.h:180
#define CONF_PARSER_TERMINATOR
Definition cf_parse.h:722
#define FR_CONF_V3_DEPRECATED(_name, _struct, _field)
conf_parser_t entry which raises an error if a deprecated v3 item is found
Definition cf_parse.h:446
#define FR_CONF_OFFSET(_name, _struct, _field)
conf_parser_t which parses a single CONF_PAIR, writing the result to a field in a struct
Definition cf_parse.h:280
@ CONF_FLAG_XLAT
string will be dynamically expanded.
Definition cf_parse.h:480
@ CONF_FLAG_SUBSECTION
Instead of putting the information into a configuration structure, the configuration file routines MA...
Definition cf_parse.h:460
#define FR_CONF_POINTER(_name, _type, _flags, _res_p)
conf_parser_t which parses a single CONF_PAIR producing a single global result
Definition cf_parse.h:350
#define FR_CONF_OFFSET_FLAGS(_name, _flags, _struct, _field)
conf_parser_t which parses a single CONF_PAIR, writing the result to a field in a struct
Definition cf_parse.h:268
#define FR_CONF_OFFSET_SUBSECTION(_name, _flags, _struct, _field, _subcs)
conf_parser_t which populates a sub-struct using a CONF_SECTION
Definition cf_parse.h:309
Defines a CONF_PAIR to C data type mapping.
Definition cf_parse.h:649
Configuration AVP similar to a fr_pair_t.
Definition cf_priv.h:77
A section grouping multiple CONF_PAIR.
Definition cf_priv.h:106
CONF_SECTION * cf_section_find(CONF_SECTION const *cs, char const *name1, char const *name2)
Find a CONF_SECTION with name1 and optionally name2.
Definition cf_util.c:1247
#define cf_log_err(_cf, _fmt,...)
Definition cf_util.h:340
#define CF_IDENT_ANY
Definition cf_util.h:80
#define FR_DBUFF_TMP(_start, _len_or_end)
Creates a compound literal to pass into functions which accept a dbuff.
Definition dbuff.h:556
static int fr_dcursor_append(fr_dcursor_t *cursor, void *v)
Insert a single item at the end of the list.
Definition dcursor.h:406
#define MEM(x)
Definition debug.h:38
#define ERROR(fmt,...)
Definition dhcpclient.c:40
#define DEBUG(fmt,...)
Definition dhcpclient.c:38
fr_dict_attr_t const ** out
Where to write a pointer to the resolved fr_dict_attr_t.
Definition dict.h:316
fr_dict_t const ** out
Where to write a pointer to the loaded/resolved fr_dict_t.
Definition dict.h:329
#define DICT_AUTOLOAD_TERMINATOR
Definition dict.h:335
fr_dict_enum_value_t const * fr_dict_enum_by_name(fr_dict_attr_t const *da, char const *name, ssize_t len)
Definition dict_util.c:3786
Specifies an attribute which must be present for the module to function.
Definition dict.h:315
Specifies a dictionary which must be loaded/loadable for the module to function.
Definition dict.h:328
Test enumeration values.
Definition dict_test.h:92
#define MODULE_MAGIC_INIT
Stop people using different module/library/server versions together.
Definition dl_module.h:63
#define EXEC_TIMEOUT
Default wait time for exec calls (in seconds).
Definition exec.h:32
ssize_t radius_readfrom_program_legacy(int fd, pid_t pid, fr_time_delta_t timeout, char *answer, size_t left)
Read from the child process.
int radius_exec_program_legacy(char *out, size_t outlen, request_t *request, char const *cmd, fr_pair_list_t *input_pairs, bool exec_wait, bool shell_escape, fr_time_delta_t timeout)
Execute a program.
pid_t radius_start_program_legacy(int *stdin_fd, int *stdout_fd, int *stderr_fd, char const *cmd, request_t *request, bool exec_wait, fr_pair_list_t *input_pairs, bool shell_escape)
Start a process.
static xlat_action_t mschap_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out, xlat_ctx_t const *xctx, request_t *request, fr_value_box_list_t *in)
Get data from MSCHAP attributes.
Definition rlm_mschap.c:365
talloc_free(hp)
TALLOC_CTX * unlang_interpret_frame_talloc_ctx(request_t *request)
Get a talloc_ctx which is valid only for this frame.
Definition interpret.c:2067
#define UNLANG_SUB_FRAME
Definition interpret.h:37
rlm_rcode_t rcode
The current rcode, from executing the instruction or merging the result from a frame.
Definition interpret.h:140
#define REXDENT()
Exdent (unindent) R* messages by one level.
Definition log.h:460
#define RHEXDUMP1(_data, _len, _fmt,...)
Definition log.h:722
#define RWDEBUG(fmt,...)
Definition log.h:378
#define RDEBUG_ENABLED3
True if request debug level 1-3 messages are enabled.
Definition log.h:352
#define RDEBUG3(fmt,...)
Definition log.h:360
#define RWDEBUG2(fmt,...)
Definition log.h:379
#define RERROR(fmt,...)
Definition log.h:315
#define RPERROR(fmt,...)
Definition log.h:319
#define REDEBUG2(fmt,...)
Definition log.h:389
#define RINDENT()
Indent R* messages by one level.
Definition log.h:447
void fr_md4_calc(uint8_t out[static MD4_DIGEST_LENGTH], uint8_t const *in, size_t inlen)
Calculate the MD4 hash of the contents of a buffer.
Definition md4.c:473
#define MD4_DIGEST_LENGTH
Definition md4.h:22
@ FR_TYPE_STRING
String of printable characters.
@ FR_TYPE_UINT8
8 Bit unsigned integer.
@ FR_TYPE_UINT32
32 Bit unsigned integer.
@ FR_TYPE_VOID
User data.
@ FR_TYPE_OCTETS
Raw octets.
long int ssize_t
unsigned char uint8_t
int fr_digest_cmp(uint8_t const *a, uint8_t const *b, size_t length)
Do a comparison of two authentication digests by comparing the FULL data.
Definition misc.c:516
int strncasecmp(char *s1, char *s2, int n)
Definition missing.c:35
char * strsep(char **stringp, char const *delim)
Definition missing.c:122
int strcasecmp(char *s1, char *s2)
Definition missing.c:65
void * env_data
Per call environment data.
Definition module_ctx.h:44
module_instance_t const * mi
Instance of the module being instantiated.
Definition module_ctx.h:42
void * thread
Thread specific instance data.
Definition module_ctx.h:43
void * rctx
Resume ctx that a module previously set.
Definition module_ctx.h:45
fr_event_list_t * el
Event list to register any IO handlers and timers against.
Definition module_ctx.h:68
void * thread
Thread instance data.
Definition module_ctx.h:67
module_instance_t const * mi
Instance of the module being instantiated.
Definition module_ctx.h:64
module_instance_t * mi
Instance of the module being instantiated.
Definition module_ctx.h:51
Temporary structure to hold arguments for module calls.
Definition module_ctx.h:41
Temporary structure to hold arguments for instantiation calls.
Definition module_ctx.h:50
Temporary structure to hold arguments for thread_instantiation calls.
Definition module_ctx.h:63
xlat_t * module_rlm_xlat_register(TALLOC_CTX *ctx, module_inst_ctx_t const *mctx, char const *name, xlat_func_t func, fr_type_t return_type)
Definition module_rlm.c:234
bool module_rlm_section_type_set(request_t *request, fr_dict_attr_t const *type_da, fr_dict_enum_value_t const *enumv)
Set the next section type if it's not already set.
Definition module_rlm.c:405
module_t common
Common fields presented by all modules.
Definition module_rlm.h:39
int mschap_nt_password_hash(uint8_t out[static NT_DIGEST_LENGTH], char const *password)
Converts Unicode password to 16-byte NT hash with MD4.
Definition mschap.c:52
void mschap_add_reply(request_t *request, uint8_t ident, fr_dict_attr_t const *da, char const *value, size_t len)
Definition mschap.c:162
void mschap_auth_response(char const *username, size_t username_len, uint8_t const *nt_hash_hash, uint8_t const *ntresponse, uint8_t const *peer_challenge, uint8_t const *auth_challenge, char *response)
Definition mschap.c:101
void mschap_challenge_hash(uint8_t challenge[static MSCHAP_CHALLENGE_LENGTH], uint8_t const peer_challenge[static MSCHAP_PEER_CHALLENGE_LENGTH], uint8_t const auth_challenge[static MSCHAP_PEER_AUTHENTICATOR_CHALLENGE_LENGTH], char const *user_name, size_t user_name_len)
Definition mschap.c:72
#define LM_DIGEST_LENGTH
Definition mschap.h:8
#define NT_DIGEST_LENGTH
Definition mschap.h:7
int fr_pair_value_memdup(fr_pair_t *vp, uint8_t const *src, size_t len, bool tainted)
Copy data into an "octets" data type.
Definition pair.c:2906
fr_pair_t * fr_pair_find_by_da_nested(fr_pair_list_t const *list, fr_dict_attr_t const *da)
Find a pair with a matching fr_dict_attr_t, by walking the nested fr_dict_attr_t tree.
Definition pair.c:791
fr_pair_list_t * fr_pair_parent_list(fr_pair_t const *vp)
Return a pointer to the parent pair list.
Definition pair.c:915
fr_pair_t * fr_pair_find_by_da(fr_pair_list_t const *list, fr_pair_t const *prev, fr_dict_attr_t const *da)
Find the first pair with a matching da.
Definition pair.c:716
fr_pair_t * fr_pair_parent(fr_pair_t const *vp)
Return a pointer to the parent pair.
Definition pair.c:923
fr_pair_t * fr_pair_afrom_da(TALLOC_CTX *ctx, fr_dict_attr_t const *da)
Dynamically allocate a new attribute and assign a fr_dict_attr_t.
Definition pair.c:284
int fr_pair_value_bstr_alloc(fr_pair_t *vp, char **out, size_t size, bool tainted)
Pre-allocate a memory buffer for a "string" type value pair.
Definition pair.c:2703
int fr_pair_value_mem_alloc(fr_pair_t *vp, uint8_t **out, size_t size, bool tainted)
Pre-allocate a memory buffer for a "octets" type value pair.
Definition pair.c:2855
static ssize_t normify(normalise_t *action, uint8_t *buffer, size_t bufflen, char const *known_good, size_t len, size_t min_len)
Definition password.c:439
fr_pair_t * password_find(bool *ephemeral, TALLOC_CTX *ctx, request_t *request, fr_dict_attr_t const *allowed_attrs[], size_t allowed_attrs_len, bool normify)
Find a "known good" password in the control list of a request.
Definition password.c:1004
static const conf_parser_t config[]
Definition base.c:164
#define fr_assert(_expr)
Definition rad_assert.h:37
static fr_dict_attr_t const * attr_user_name
#define pair_update_request(_attr, _da)
#define REDEBUG(fmt,...)
#define RDEBUG2(fmt,...)
#define WARN(fmt,...)
static bool done
Definition radclient.c:80
static rs_t * conf
Definition radsniff.c:52
uint32_t fr_rand(void)
Return a 32-bit random number.
Definition rand.c:128
rlm_rcode_t
Return codes indicating the result of the module call.
Definition rcode.h:44
@ RLM_MODULE_INVALID
The module considers the request invalid.
Definition rcode.h:51
@ RLM_MODULE_OK
The module is OK, continue.
Definition rcode.h:49
@ RLM_MODULE_DISALLOW
Reject the request (user is locked out).
Definition rcode.h:52
@ RLM_MODULE_REJECT
Immediately reject the request.
Definition rcode.h:47
@ RLM_MODULE_NOTFOUND
User not found.
Definition rcode.h:53
@ RLM_MODULE_NOOP
Module succeeded without doing anything.
Definition rcode.h:54
#define RETURN_UNLANG_INVALID
Definition rcode.h:72
#define RETURN_UNLANG_RCODE(_rcode)
Definition rcode.h:67
#define RETURN_UNLANG_FAIL
Definition rcode.h:69
#define RETURN_UNLANG_REJECT
Definition rcode.h:68
#define RETURN_UNLANG_OK
Definition rcode.h:70
#define RETURN_UNLANG_NOOP
Definition rcode.h:75
static int mod_thread_instantiate(module_thread_inst_ctx_t const *mctx)
static int mod_thread_detach(module_thread_inst_ctx_t const *mctx)
static const uint8_t SHSpad2[40]
fr_dict_attr_t const * attr_smb_account_ctrl
Definition rlm_mschap.c:240
tmpl_t const * username
Definition rlm_mschap.c:155
#define CHECK_OPTION(_option)
static unlang_action_t mschap_process_response(unlang_result_t *p_result, int *mschap_version, uint8_t nthashhash[static NT_DIGEST_LENGTH], rlm_mschap_t const *inst, request_t *request, mschap_auth_ctx_t *auth_ctx, fr_pair_t *challenge, fr_pair_t *response)
static const call_env_parser_t xlat_call_env[]
Definition rlm_mschap.c:161
static void mppe_chap2_get_keys128(uint8_t const *nt_hashhash, uint8_t const *nt_response, uint8_t *sendkey, uint8_t *recvkey)
static void mppe_add_reply(UNUSED rlm_mschap_t const *inst, request_t *request, fr_dict_attr_t const *da, uint8_t const *value, size_t len)
Definition rlm_mschap.c:786
fr_dict_attr_t const * attr_nt_password
Definition rlm_mschap.c:238
fr_dict_attr_t const * attr_ms_chap_new_cleartext_password
Definition rlm_mschap.c:233
fr_dict_autoload_t rlm_mschap_dict[]
Definition rlm_mschap.c:224
#define ACB_MNS
MNS logon user account.
Definition rlm_mschap.c:71
static const call_env_parser_t auth_call_env[]
Definition rlm_mschap.c:169
tmpl_t const * chap_response
Definition rlm_mschap.c:157
static unlang_action_t mschap_process_v2_response(unlang_result_t *p_result, int *mschap_version, uint8_t nthashhash[static NT_DIGEST_LENGTH], rlm_mschap_t const *inst, request_t *request, mschap_auth_ctx_t *auth_ctx, fr_pair_t *challenge, fr_pair_t *response)
tmpl_t const * chap2_cpw
Definition rlm_mschap.c:209
fr_dict_attr_t const * attr_eap_identity
Definition rlm_mschap.c:232
tmpl_t const * chap2_response
Definition rlm_mschap.c:208
static unlang_action_t mschap_error(unlang_result_t *p_result, rlm_mschap_t const *inst, request_t *request, unsigned char ident, int mschap_result, int mschap_version, fr_pair_t *smb_ctrl, mschap_auth_call_env_t *env_data)
#define ACB_AUTOLOCK
Account auto locked.
Definition rlm_mschap.c:76
#define MSCHAP_CALL_ENV(_x)
Definition rlm_mschap.c:134
fr_dict_attr_t const * attr_smb_account_ctrl_text
Definition rlm_mschap.c:239
static unlang_action_t mod_authenticate_resume(unlang_result_t *p_result, module_ctx_t const *mctx, request_t *request)
Complete mschap authentication after any tmpls have been expanded.
static const call_env_parser_t autz_call_env[]
Definition rlm_mschap.c:212
#define ACB_TEMPDUP
Temporary duplicate account.
Definition rlm_mschap.c:69
static int pdb_decode_acct_ctrl(char const *p)
Definition rlm_mschap.c:274
static fr_dict_t const * dict_freeradius
Definition rlm_mschap.c:220
static void mppe_GetMasterKey(uint8_t const *nt_hashhash, uint8_t const *nt_response, uint8_t *masterkey)
static const call_env_method_t mschap_auth_method_env
Definition rlm_mschap.c:184
static int nt_password_find(TALLOC_CTX *ctx, fr_pair_t **out, rlm_mschap_t const *inst, request_t *request)
Find a Password.NT value, or create one from a Password.Cleartext, or Password.With-Header attribute.
#define ACB_FR_EXPIRED
Password Expired.
Definition rlm_mschap.c:77
#define ACB_DISABLED
User account disabled.
Definition rlm_mschap.c:66
static unlang_action_t mschap_process_cpw_request(unlang_result_t *p_result, rlm_mschap_t const *inst, request_t *request, mschap_auth_ctx_t *auth_ctx)
static fr_dict_t const * dict_radius
Definition rlm_mschap.c:221
static const uint8_t magic1[27]
static int mod_bootstrap(module_inst_ctx_t const *mctx)
static const uint8_t SHSpad1[40]
fr_dict_attr_t const * attr_auth_type
Definition rlm_mschap.c:230
fr_dict_attr_t const * attr_ms_chap_user_name
Definition rlm_mschap.c:237
tmpl_t const * chap_response
Definition rlm_mschap.c:207
static unlang_action_t mod_authorize(unlang_result_t *p_result, module_ctx_t const *mctx, request_t *request)
static void mppe_GetAsymmetricStartKey(uint8_t *masterkey, uint8_t *sesskey, int keylen, int issend)
static xlat_arg_parser_t const mschap_xlat_args[]
Definition rlm_mschap.c:352
fr_dict_attr_t const * attr_ms_chap_use_ntlm_auth
Definition rlm_mschap.c:236
#define ACB_HOMDIRREQ
Home directory required.
Definition rlm_mschap.c:67
tmpl_t const * chap2_response
Definition rlm_mschap.c:158
module_rlm_t rlm_mschap
static int write_all(int fd, char const *buf, size_t len)
Definition rlm_mschap.c:801
fr_dict_attr_t const * attr_cleartext_password
Definition rlm_mschap.c:231
fr_dict_attr_autoload_t rlm_mschap_dict_attr[]
Definition rlm_mschap.c:243
static unlang_action_t mod_authenticate(unlang_result_t *p_result, module_ctx_t const *mctx, request_t *request)
static const uint8_t magic3[84]
static int do_mschap_cpw(rlm_mschap_t const *inst, request_t *request, mschap_auth_ctx_t *auth_ctx, uint8_t *new_nt_password, uint8_t *old_nt_hash)
Definition rlm_mschap.c:826
static int do_mschap(rlm_mschap_t const *inst, request_t *request, mschap_auth_ctx_t *auth_ctx, uint8_t const *challenge, uint8_t const *response, uint8_t nthashhash[static NT_DIGEST_LENGTH])
static const uint8_t magic2[84]
#define ACB_DOMTRUST
Interdomain trust account.
Definition rlm_mschap.c:72
#define ACB_WSTRUST
Workstation trust account.
Definition rlm_mschap.c:73
static void mppe_chap2_gen_keys128(uint8_t const *nt_hashhash, uint8_t const *response, uint8_t *sendkey, uint8_t *recvkey)
fr_dict_attr_t const * attr_ms_chap_new_nt_password
Definition rlm_mschap.c:234
#define ACB_NORMAL
Normal user account.
Definition rlm_mschap.c:70
tmpl_t const * chap_challenge
Definition rlm_mschap.c:156
#define ACB_PWNOTREQ
User password not required.
Definition rlm_mschap.c:68
static const conf_parser_t module_config[]
Definition rlm_mschap.c:100
fr_dict_attr_t const * attr_ms_chap_peer_challenge
Definition rlm_mschap.c:235
static int mschap_cpw_prepare(request_t *request, mschap_auth_ctx_t *auth_ctx)
Validate data required for change password requests.
#define MSCHAP_OPT_CALL_ENV(_opt, _x)
Definition rlm_mschap.c:151
static int mod_instantiate(module_inst_ctx_t const *mctx)
#define ACB_PWNOEXP
User password does not expire.
Definition rlm_mschap.c:75
static fr_pair_t * mschap_identity_find(request_t *request, fr_dict_attr_t const *attr_user_name)
Definition rlm_mschap.c:259
static const conf_parser_t passchange_config[]
Definition rlm_mschap.c:79
tmpl_t const * chap_challenge
Definition rlm_mschap.c:206
#define MSCHAP_COMMON_CALL_ENV(_x)
Definition rlm_mschap.c:143
#define ACB_SVRTRUST
Server trust account.
Definition rlm_mschap.c:74
static const conf_parser_t winbind_config[]
Definition rlm_mschap.c:91
uint8_t new_nt_encrypted[516]
Definition rlm_mschap.h:106
tmpl_t const * username
Definition rlm_mschap.h:82
MSCHAP_AUTH_METHOD
Definition rlm_mschap.h:17
@ AUTH_AUTO
Definition rlm_mschap.h:20
@ AUTH_INTERNAL
Definition rlm_mschap.h:18
@ AUTH_NTLMAUTH_EXEC
Definition rlm_mschap.h:19
MSCHAP_AUTH_METHOD method
Definition rlm_mschap.h:115
tmpl_t const * mppe_encryption_types
Definition rlm_mschap.h:92
fr_pair_t * cpw
Definition rlm_mschap.h:118
char const * name
Definition rlm_mschap.h:112
tmpl_t const * ntlm_cpw_domain
Definition rlm_mschap.h:98
fr_pair_t * new_hash
Definition rlm_mschap.h:108
tmpl_t const * ntlm_cpw_username
Definition rlm_mschap.h:97
tmpl_t const * chap_nt_enc_pw
Definition rlm_mschap.h:94
tmpl_t const * mppe_send_key
Definition rlm_mschap.h:91
rlm_mschap_t const * inst
Definition rlm_mschap.h:113
fr_value_box_list_t cpw_user
Definition rlm_mschap.h:103
tmpl_t const * chap_response
Definition rlm_mschap.h:85
tmpl_t const * local_cpw
Definition rlm_mschap.h:99
fr_value_box_list_t cpw_domain
Definition rlm_mschap.h:104
fr_pair_t * smb_ctrl
Definition rlm_mschap.h:117
tmpl_t const * chap_challenge
Definition rlm_mschap.h:84
tmpl_t const * chap2_response
Definition rlm_mschap.h:86
fr_value_box_list_t local_cpw_result
Definition rlm_mschap.h:105
tmpl_t const * mppe_encryption_policy
Definition rlm_mschap.h:89
mschap_auth_call_env_t * env_data
Definition rlm_mschap.h:114
tmpl_t const * mppe_recv_key
Definition rlm_mschap.h:90
tmpl_t const * chap_error
Definition rlm_mschap.h:83
tmpl_t const * chap2_cpw
Definition rlm_mschap.h:93
uint8_t old_nt_hash[NT_DIGEST_LENGTH]
Definition rlm_mschap.h:107
tmpl_t const * chap2_success
Definition rlm_mschap.h:87
mschap_cpw_ctx_t * cpw_ctx
Definition rlm_mschap.h:119
fr_pair_t * nt_password
Definition rlm_mschap.h:116
tmpl_t const * chap_mppe_keys
Definition rlm_mschap.h:88
static int winbind_ctx_alloc(winbind_ctx_t *wbctx, UNUSED void *uctx)
static conf_parser_t reuse_winbind_config[]
Definition rlm_winbind.c:44
static int _mod_ctx_free(winbind_ctx_t *wbctx)
struct wbcContext * ctx
Definition rlm_winbind.h:21
#define FR_SBUFF_IN(_start, _len_or_end)
#define FR_SBUFF_OUT(_start, _len_or_end)
#define SECTION_NAME(_name1, _name2)
Define a section name consisting of a verb and a noun.
Definition section.h:39
char const * name
Instance name e.g. user_database.
Definition module.h:361
CONF_SECTION * conf
Module's instance configuration.
Definition module.h:355
size_t inst_size
Size of the module's instance data.
Definition module.h:213
void * data
Module's instance data.
Definition module.h:297
void * boot
Data allocated during the boostrap phase.
Definition module.h:300
#define MODULE_BINDING_TERMINATOR
Terminate a module binding list.
Definition module.h:153
Named methods exported by a module.
Definition module.h:175
#define pair_append_control(_attr, _da)
Allocate and append a fr_pair_t to the control list.
Definition pair.h:57
#define pair_update_reply(_attr, _da)
Return or allocate a fr_pair_t in the reply list.
Definition pair.h:129
static fr_dict_attr_t const * tmpl_attr_tail_da(tmpl_t const *vpt)
Return the last attribute reference da.
Definition tmpl.h:826
void fr_sha1_init(fr_sha1_ctx *context)
Definition sha1.c:93
void fr_sha1_final(uint8_t digest[static SHA1_DIGEST_LENGTH], fr_sha1_ctx *context)
Definition sha1.c:141
void fr_sha1_update(fr_sha1_ctx *context, uint8_t const *in, size_t len)
Definition sha1.c:105
@ FR_SIGNAL_NONE
No signals.
Definition signal.h:39
#define FR_SLAB_CONFIG_CONF_PARSER
conf_parser_t entries to populate user configurable slab values
Definition slab.h:35
void smbhash(unsigned char *out, unsigned char const *in, unsigned char *key)
Definition smbdes.c:287
void smbdes_mschap(uint8_t const win_password[16], uint8_t const *challenge, uint8_t *response)
Definition smbdes.c:339
void smbdes_lmpwdhash(char const *password, uint8_t *lmhash)
Definition smbdes.c:319
PUBLIC int snprintf(char *string, size_t length, char *format, va_alist)
Definition snprintf.c:689
unlang_action_t unlang_module_yield(request_t *request, module_method_t resume, unlang_module_signal_t signal, fr_signal_t sigmask, void *rctx)
Yield a request back to the interpreter from within a module.
Definition module.c:431
eap_aka_sim_process_conf_t * inst
fr_pair_t * vp
Stores an attribute, a value and various bits of other data.
Definition pair.h:68
fr_dict_attr_t const *_CONST da
Dictionary attribute defines the attribute number, vendor and type of the pair.
Definition pair.h:69
char const * fr_syserror(int num)
Guaranteed to be thread-safe version of strerror.
Definition syserror.c:243
#define talloc_get_type_abort_const
Definition talloc.h:117
#define fr_time_delta_lt(_a, _b)
Definition time.h:285
static fr_time_delta_t fr_time_delta_from_sec(int64_t sec)
Definition time.h:599
#define fr_time_delta_ispos(_a)
Definition time.h:290
#define fr_time_delta_gt(_a, _b)
Definition time.h:283
int unlang_tmpl_push(TALLOC_CTX *ctx, unlang_result_t *p_result, fr_value_box_list_t *out, request_t *request, tmpl_t const *tmpl, unlang_tmpl_args_t *args, bool top_frame)
Push a tmpl onto the stack for evaluation.
Definition tmpl.c:276
@ T_BARE_WORD
Definition token.h:118
xlat_action_t
Definition xlat.h:37
@ XLAT_ACTION_FAIL
An xlat function failed.
Definition xlat.h:44
@ XLAT_ACTION_DONE
We're done evaluating this level of nesting.
Definition xlat.h:43
unsigned int required
Argument must be present, and non-empty.
Definition xlat.h:136
#define XLAT_ARG_PARSER_TERMINATOR
Definition xlat.h:160
Definition for a single argument consumed by an xlat function.
Definition xlat.h:135
static fr_slen_t parent
Definition pair.h:864
#define fr_strerror_printf(_fmt,...)
Log to thread local error buffer.
Definition strerror.h:64
int fr_value_box_asprintf(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, bool tainted, char const *fmt,...)
Print a formatted string using our internal printf wrapper and assign it to a value box.
Definition value.c:4851
int fr_value_box_strdup(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, char const *src, bool tainted)
Copy a nul terminated string to a fr_value_box_t.
Definition value.c:4763
int fr_value_box_bstrndup(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, char const *src, size_t len, bool tainted)
Copy a string to to a fr_value_box_t.
Definition value.c:5014
int fr_value_box_memdup(TALLOC_CTX *ctx, fr_value_box_t *dst, fr_dict_attr_t const *enumv, uint8_t const *src, size_t len, bool tainted)
Copy a buffer to a fr_value_box_t.
Definition value.c:5255
static fr_sbuff_err_t char size_t fr_sbuff_t * in
Definition value.h:1061
static fr_slen_t data
Definition value.h:1366
#define fr_box_strvalue_len(_val, _len)
Definition value.h:340
static fr_sbuff_err_t char ** out
Definition value.h:1061
static fr_sbuff_err_t char size_t * len
Definition value.h:1061
#define fr_box_time_delta(_val)
Definition value.h:397
int nonnull(2, 5))
#define fr_value_box_alloc_null(_ctx)
Allocate a value box for later use with a value assignment function.
Definition value.h:679
#define fr_box_octets(_val, _len)
Definition value.h:342
void * env_data
Expanded call env data.
Definition xlat_ctx.h:53
module_ctx_t const * mctx
Synthesised module calling ctx.
Definition xlat_ctx.h:52
An xlat calling ctx.
Definition xlat_ctx.h:49
int xlat_func_args_set(xlat_t *x, xlat_arg_parser_t const args[])
Register the arguments of an xlat.
Definition xlat_func.c:374
void xlat_func_call_env_set(xlat_t *x, call_env_method_t const *env_method)
Register call environment of an xlat.
Definition xlat_func.c:391