Line data Source code
1 : /*
2 : Unix SMB/CIFS implementation.
3 : Password and authentication handling
4 : Copyright (C) Andrew Bartlett 2001-2002
5 :
6 : This program is free software; you can redistribute it and/or modify
7 : it under the terms of the GNU General Public License as published by
8 : the Free Software Foundation; either version 3 of the License, or
9 : (at your option) any later version.
10 :
11 : This program is distributed in the hope that it will be useful,
12 : but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : GNU General Public License for more details.
15 :
16 : You should have received a copy of the GNU General Public License
17 : along with this program. If not, see <http://www.gnu.org/licenses/>.
18 : */
19 :
20 : #include "includes.h"
21 : #include "auth.h"
22 : #include "../lib/tsocket/tsocket.h"
23 :
24 : #include "param/param.h"
25 : #include "../lib/messaging/messaging.h"
26 : #include "lib/global_contexts.h"
27 :
28 : #undef DBGC_CLASS
29 : #define DBGC_CLASS DBGC_AUTH
30 :
31 : static_decl_auth;
32 :
33 : static struct auth_init_function_entry *auth_backends = NULL;
34 :
35 : static struct auth_init_function_entry *auth_find_backend_entry(const char *name);
36 :
37 257533 : NTSTATUS smb_register_auth(int version, const char *name, auth_init_function init)
38 : {
39 257533 : struct auth_init_function_entry *entry = NULL;
40 :
41 257533 : if (version != AUTH_INTERFACE_VERSION) {
42 0 : DEBUG(0,("Can't register auth_method!\n"
43 : "You tried to register an auth module with AUTH_INTERFACE_VERSION %d, while this version of samba uses %d\n",
44 : version,AUTH_INTERFACE_VERSION));
45 0 : return NT_STATUS_OBJECT_TYPE_MISMATCH;
46 : }
47 :
48 257533 : if (!name || !init) {
49 0 : return NT_STATUS_INVALID_PARAMETER;
50 : }
51 :
52 257533 : DEBUG(5,("Attempting to register auth backend %s\n", name));
53 :
54 257533 : if (auth_find_backend_entry(name)) {
55 0 : DEBUG(0,("There already is an auth method registered with the name %s!\n", name));
56 0 : return NT_STATUS_OBJECT_NAME_COLLISION;
57 : }
58 :
59 257533 : entry = SMB_XMALLOC_P(struct auth_init_function_entry);
60 257533 : entry->name = smb_xstrdup(name);
61 257533 : entry->init = init;
62 :
63 257533 : DLIST_ADD(auth_backends, entry);
64 257533 : DEBUG(5,("Successfully added auth method '%s'\n", name));
65 257533 : return NT_STATUS_OK;
66 : }
67 :
68 574057 : static struct auth_init_function_entry *auth_find_backend_entry(const char *name)
69 : {
70 574057 : struct auth_init_function_entry *entry = auth_backends;
71 :
72 2465301 : while(entry) {
73 2207768 : if (strcmp(entry->name, name)==0) return entry;
74 1891244 : entry = entry->next;
75 : }
76 :
77 250861 : return NULL;
78 : }
79 :
80 : /****************************************************************************
81 : Try to get a challenge out of the various authentication modules.
82 : Returns a const char of length 8 bytes.
83 : ****************************************************************************/
84 :
85 28504 : NTSTATUS auth_get_ntlm_challenge(struct auth_context *auth_context,
86 : uint8_t chal[8])
87 : {
88 28504 : if (auth_context->challenge.length) {
89 0 : DBG_INFO("get_ntlm_challenge (auth subsystem): returning "
90 : "previous challenge by module %s (normal)\n",
91 : auth_context->challenge_set_by);
92 0 : memcpy(chal, auth_context->challenge.data, 8);
93 0 : return NT_STATUS_OK;
94 : }
95 :
96 28504 : auth_context->challenge = data_blob_talloc(auth_context, NULL, 8);
97 28504 : if (auth_context->challenge.data == NULL) {
98 0 : DBG_WARNING("data_blob_talloc failed\n");
99 0 : return NT_STATUS_NO_MEMORY;
100 : }
101 28504 : generate_random_buffer(
102 : auth_context->challenge.data, auth_context->challenge.length);
103 :
104 28504 : auth_context->challenge_set_by = "random";
105 :
106 28504 : memcpy(chal, auth_context->challenge.data, 8);
107 28504 : return NT_STATUS_OK;
108 : }
109 :
110 :
111 : /**
112 : * Check user is in correct domain (if required)
113 : *
114 : * @param user Only used to fill in the debug message
115 : *
116 : * @param domain The domain to be verified
117 : *
118 : * @return True if the user can connect with that domain,
119 : * False otherwise.
120 : **/
121 :
122 29128 : static bool check_domain_match(const char *user, const char *domain)
123 : {
124 : /*
125 : * If we aren't serving to trusted domains, we must make sure that
126 : * the validation request comes from an account in the same domain
127 : * as the Samba server
128 : */
129 :
130 29128 : if (!lp_allow_trusted_domains() &&
131 451 : !(strequal("", domain) ||
132 217 : strequal(lp_workgroup(), domain) ||
133 2 : is_myname(domain))) {
134 2 : DEBUG(1, ("check_domain_match: Attempt to connect as user %s from domain %s denied.\n", user, domain));
135 2 : return False;
136 : } else {
137 29126 : return True;
138 : }
139 : }
140 :
141 : /**
142 : * Check a user's Plaintext, LM or NTLM password.
143 : *
144 : * Check a user's password, as given in the user_info struct and return various
145 : * interesting details in the server_info struct.
146 : *
147 : * This function does NOT need to be in a become_root()/unbecome_root() pair
148 : * as it makes the calls itself when needed.
149 : *
150 : * The return value takes precedence over the contents of the server_info
151 : * struct. When the return is other than NT_STATUS_OK the contents
152 : * of that structure is undefined.
153 : *
154 : * @param user_info Contains the user supplied components, including the passwords.
155 : * Must be created with make_user_info() or one of its wrappers.
156 : *
157 : * @param auth_context Supplies the challenges and some other data.
158 : * Must be created with make_auth_context(), and the challenges should be
159 : * filled in, either at creation or by calling the challenge generation
160 : * function auth_get_challenge().
161 : *
162 : * @param pserver_info If successful, contains information about the authentication,
163 : * including a struct samu struct describing the user.
164 : *
165 : * @param pauthoritative Indicates if the result should be treated as final
166 : * result.
167 : *
168 : * @return An NTSTATUS with NT_STATUS_OK or an appropriate error.
169 : *
170 : **/
171 29128 : NTSTATUS auth_check_ntlm_password(TALLOC_CTX *mem_ctx,
172 : const struct auth_context *auth_context,
173 : const struct auth_usersupplied_info *user_info,
174 : struct auth_serversupplied_info **pserver_info,
175 : uint8_t *pauthoritative)
176 : {
177 0 : TALLOC_CTX *frame;
178 29128 : const char *auth_method_name = "";
179 : /* if all the modules say 'not for me' this is reasonable */
180 29128 : NTSTATUS nt_status = NT_STATUS_NOT_IMPLEMENTED;
181 0 : const char *unix_username;
182 0 : struct auth_methods *auth_method;
183 29128 : struct auth_serversupplied_info *server_info = NULL;
184 29128 : struct dom_sid sid = {0};
185 29128 : struct imessaging_context *msg_ctx = NULL;
186 29128 : struct loadparm_context *lp_ctx = NULL;
187 :
188 29128 : if (user_info == NULL || auth_context == NULL || pserver_info == NULL) {
189 0 : return NT_STATUS_LOGON_FAILURE;
190 : }
191 :
192 29128 : frame = talloc_stackframe();
193 :
194 29128 : if (lp_auth_event_notification()) {
195 860 : lp_ctx = loadparm_init_s3(frame, loadparm_s3_helpers());
196 860 : msg_ctx = imessaging_client_init(
197 : frame, lp_ctx, global_event_context());
198 : }
199 :
200 29128 : *pauthoritative = 1;
201 :
202 29128 : DBG_NOTICE("check_ntlm_password: Checking password for unmapped user "
203 : "[%s]\\[%s]@[%s] with the new password interface\n",
204 : user_info->client.domain_name,
205 : user_info->client.account_name,
206 : user_info->workstation_name);
207 :
208 29128 : DBG_NOTICE("check_ntlm_password: mapped user is: [%s]\\[%s]@[%s]\n",
209 : user_info->mapped.domain_name,
210 : user_info->mapped.account_name,
211 : user_info->workstation_name);
212 :
213 29128 : if (auth_context->challenge.length != 8) {
214 0 : DEBUG(0, ("check_ntlm_password: Invalid challenge stored for this auth context - cannot continue\n"));
215 0 : nt_status = NT_STATUS_LOGON_FAILURE;
216 0 : goto fail;
217 : }
218 :
219 29128 : if (auth_context->challenge_set_by)
220 29128 : DEBUG(10, ("check_ntlm_password: auth_context challenge created by %s\n",
221 : auth_context->challenge_set_by));
222 :
223 29128 : DEBUG(10, ("challenge is: \n"));
224 29128 : dump_data(5, auth_context->challenge.data, auth_context->challenge.length);
225 :
226 : #ifdef DEBUG_PASSWORD
227 29128 : DEBUG(100, ("user_info has passwords of length %d and %d\n",
228 : (int)user_info->password.response.lanman.length, (int)user_info->password.response.nt.length));
229 29128 : DEBUG(100, ("lm:\n"));
230 29128 : dump_data(100, user_info->password.response.lanman.data, user_info->password.response.lanman.length);
231 29128 : DEBUG(100, ("nt:\n"));
232 29128 : dump_data(100, user_info->password.response.nt.data, user_info->password.response.nt.length);
233 : #endif
234 :
235 : /* This needs to be sorted: If it doesn't match, what should we do? */
236 29128 : if (!check_domain_match(user_info->client.account_name,
237 29128 : user_info->mapped.domain_name)) {
238 2 : nt_status = NT_STATUS_LOGON_FAILURE;
239 2 : goto fail;
240 : }
241 :
242 63135 : for (auth_method = auth_context->auth_method_list;auth_method; auth_method = auth_method->next) {
243 :
244 63118 : auth_method_name = auth_method->name;
245 :
246 63118 : nt_status = auth_method->auth(auth_context,
247 : auth_method->private_data,
248 : talloc_tos(),
249 : user_info,
250 : &server_info);
251 :
252 63118 : if (!NT_STATUS_EQUAL(nt_status, NT_STATUS_NOT_IMPLEMENTED)) {
253 29109 : break;
254 : }
255 :
256 34009 : DBG_DEBUG("%s had nothing to say\n", auth_method->name);
257 : }
258 :
259 29126 : if (NT_STATUS_EQUAL(nt_status, NT_STATUS_NOT_IMPLEMENTED)) {
260 17 : *pauthoritative = 0;
261 17 : nt_status = NT_STATUS_NO_SUCH_USER;
262 : }
263 :
264 29126 : if (!NT_STATUS_IS_OK(nt_status)) {
265 3319 : DBG_INFO("%s authentication for user [%s] FAILED with "
266 : "error %s, authoritative=%u\n",
267 : auth_method_name,
268 : user_info->client.account_name,
269 : nt_errstr(nt_status),
270 : *pauthoritative);
271 3319 : goto fail;
272 : }
273 :
274 25807 : DBG_NOTICE("%s authentication for user [%s] succeeded\n",
275 : auth_method_name, user_info->client.account_name);
276 :
277 25807 : unix_username = server_info->unix_name;
278 :
279 : /* We skip doing this step if the caller asked us not to */
280 25807 : if (!(user_info->flags & USER_INFO_INFO3_AND_NO_AUTHZ)
281 25807 : && !(server_info->guest)) {
282 0 : const char *rhost;
283 :
284 25256 : if (tsocket_address_is_inet(user_info->remote_host, "ip")) {
285 25254 : rhost = tsocket_address_inet_addr_string(
286 25254 : user_info->remote_host, talloc_tos());
287 25254 : if (rhost == NULL) {
288 0 : nt_status = NT_STATUS_NO_MEMORY;
289 0 : goto fail;
290 : }
291 : } else {
292 2 : rhost = "127.0.0.1";
293 : }
294 :
295 : /* We might not be root if we are an RPC call */
296 25256 : become_root();
297 25256 : nt_status = smb_pam_accountcheck(unix_username, rhost);
298 25256 : unbecome_root();
299 :
300 25256 : if (NT_STATUS_IS_OK(nt_status)) {
301 25256 : DEBUG(5, ("check_ntlm_password: PAM Account for user [%s] "
302 : "succeeded\n", unix_username));
303 : } else {
304 0 : DEBUG(3, ("check_ntlm_password: PAM Account for user [%s] "
305 : "FAILED with error %s\n",
306 : unix_username, nt_errstr(nt_status)));
307 : }
308 : }
309 :
310 25807 : if (!NT_STATUS_IS_OK(nt_status)) {
311 0 : goto fail;
312 : }
313 :
314 25807 : nt_status = get_user_sid_info3_and_extra(server_info->info3,
315 25807 : &server_info->extra,
316 : &sid);
317 25807 : if (!NT_STATUS_IS_OK(nt_status)) {
318 0 : sid = (struct dom_sid) {0};
319 : }
320 :
321 25807 : log_authentication_event(msg_ctx,
322 : lp_ctx,
323 : &auth_context->start_time,
324 : user_info,
325 : nt_status,
326 25807 : server_info->info3->base.logon_domain.string,
327 25807 : server_info->info3->base.account_name.string,
328 : &sid,
329 : NULL /* client_audit_info */,
330 : NULL /* server_audit_info */);
331 :
332 25807 : DEBUG(server_info->guest ? 5 : 2,
333 : ("check_ntlm_password: %sauthentication for user "
334 : "[%s] -> [%s] -> [%s] succeeded\n",
335 : server_info->guest ? "guest " : "",
336 : user_info->client.account_name,
337 : user_info->mapped.account_name,
338 : unix_username));
339 :
340 25807 : *pserver_info = talloc_move(mem_ctx, &server_info);
341 :
342 25807 : TALLOC_FREE(frame);
343 25807 : return NT_STATUS_OK;
344 :
345 3321 : fail:
346 :
347 : /* failed authentication; check for guest lapping */
348 :
349 : /*
350 : * Please try not to change this string, it is probably in use
351 : * in audit logging tools
352 : */
353 3321 : DEBUG(2, ("check_ntlm_password: Authentication for user "
354 : "[%s] -> [%s] FAILED with error %s, authoritative=%u\n",
355 : user_info->client.account_name, user_info->mapped.account_name,
356 : nt_errstr(nt_status), *pauthoritative));
357 :
358 3321 : log_authentication_event(msg_ctx,
359 : lp_ctx,
360 : &auth_context->start_time,
361 : user_info,
362 : nt_status,
363 : NULL,
364 : NULL,
365 : NULL,
366 : NULL /* client_audit_info */,
367 : NULL /* server_audit_info */);
368 :
369 3321 : ZERO_STRUCTP(pserver_info);
370 :
371 3321 : TALLOC_FREE(frame);
372 :
373 3321 : return nt_status;
374 : }
375 :
376 : /***************************************************************************
377 : Clear out a auth_context, and destroy the attached TALLOC_CTX
378 : ***************************************************************************/
379 :
380 130183 : static int auth_context_destructor(void *ptr)
381 : {
382 130183 : struct auth_context *ctx = talloc_get_type(ptr, struct auth_context);
383 2087 : struct auth_methods *am;
384 :
385 :
386 : /* Free private data of context's authentication methods */
387 445334 : for (am = ctx->auth_method_list; am; am = am->next) {
388 315151 : TALLOC_FREE(am->private_data);
389 : }
390 :
391 130183 : return 0;
392 : }
393 :
394 : /***************************************************************************
395 : Make a auth_info struct
396 : ***************************************************************************/
397 :
398 130531 : static NTSTATUS make_auth_context(TALLOC_CTX *mem_ctx,
399 : struct auth_context **auth_context)
400 : {
401 2087 : struct auth_context *ctx;
402 :
403 130531 : ctx = talloc_zero(mem_ctx, struct auth_context);
404 130531 : if (!ctx) {
405 0 : DEBUG(0,("make_auth_context: talloc failed!\n"));
406 0 : return NT_STATUS_NO_MEMORY;
407 : }
408 :
409 130531 : ctx->start_time = timeval_current();
410 :
411 130531 : talloc_set_destructor((TALLOC_CTX *)ctx, auth_context_destructor);
412 :
413 130531 : *auth_context = ctx;
414 130531 : return NT_STATUS_OK;
415 : }
416 :
417 316524 : static bool load_auth_module(
418 : struct auth_context *auth_context,
419 : const char *module,
420 : struct auth_methods **ret)
421 : {
422 2087 : static bool initialised_static_modules = False;
423 :
424 2087 : struct auth_init_function_entry *entry;
425 316524 : char *module_name = smb_xstrdup(module);
426 316524 : char *module_params = NULL;
427 2087 : char *p;
428 316524 : bool good = False;
429 :
430 : /* Initialise static modules if not done so yet */
431 316524 : if(!initialised_static_modules) {
432 35205 : static_init_auth(NULL);
433 35205 : initialised_static_modules = True;
434 : }
435 :
436 316524 : DEBUG(5,("load_auth_module: Attempting to find an auth method to match %s\n",
437 : module));
438 :
439 316524 : p = strchr(module_name, ':');
440 316524 : if (p) {
441 0 : *p = 0;
442 0 : module_params = p+1;
443 0 : trim_char(module_params, ' ', ' ');
444 : }
445 :
446 316524 : trim_char(module_name, ' ', ' ');
447 :
448 316524 : entry = auth_find_backend_entry(module_name);
449 :
450 316524 : if (entry == NULL) {
451 0 : if (NT_STATUS_IS_OK(smb_probe_module("auth", module_name))) {
452 0 : entry = auth_find_backend_entry(module_name);
453 : }
454 : }
455 :
456 316524 : if (entry != NULL) {
457 316524 : if (!NT_STATUS_IS_OK(entry->init(auth_context, module_params, ret))) {
458 0 : DEBUG(0,("load_auth_module: auth method %s did not correctly init\n",
459 : module_name));
460 : } else {
461 316524 : DEBUG(5,("load_auth_module: auth method %s has a valid init\n",
462 : module_name));
463 314437 : good = True;
464 : }
465 : } else {
466 0 : DEBUG(0,("load_auth_module: can't find auth method %s!\n", module_name));
467 : }
468 :
469 316524 : SAFE_FREE(module_name);
470 316524 : return good;
471 : }
472 :
473 : /***************************************************************************
474 : Make a auth_info struct for the auth subsystem
475 : ***************************************************************************/
476 :
477 130531 : static NTSTATUS make_auth_context_text_list(TALLOC_CTX *mem_ctx,
478 : struct auth_context **auth_context,
479 : char **text_list)
480 : {
481 130531 : struct auth_methods *list = NULL;
482 130531 : struct auth_methods *t, *method = NULL;
483 2087 : NTSTATUS nt_status;
484 :
485 130531 : if (!text_list) {
486 0 : DEBUG(2,("make_auth_context_text_list: No auth method list!?\n"));
487 0 : return NT_STATUS_UNSUCCESSFUL;
488 : }
489 :
490 130531 : nt_status = make_auth_context(mem_ctx, auth_context);
491 :
492 130531 : if (!NT_STATUS_IS_OK(nt_status)) {
493 0 : return nt_status;
494 : }
495 :
496 447055 : for (;*text_list; text_list++) {
497 316524 : if (load_auth_module(*auth_context, *text_list, &t)) {
498 316524 : DLIST_ADD_END(list, t);
499 : }
500 : }
501 :
502 130531 : (*auth_context)->auth_method_list = list;
503 :
504 : /* Look for the first module to provide a prepare_gensec and
505 : * make_auth4_context hook, and set that if provided */
506 407857 : for (method = (*auth_context)->auth_method_list; method; method = method->next) {
507 316524 : if (method->prepare_gensec && method->make_auth4_context) {
508 39198 : (*auth_context)->prepare_gensec = method->prepare_gensec;
509 39198 : (*auth_context)->make_auth4_context = method->make_auth4_context;
510 39198 : break;
511 : }
512 : }
513 130531 : return NT_STATUS_OK;
514 : }
515 :
516 130531 : static NTSTATUS make_auth_context_specific(TALLOC_CTX *mem_ctx,
517 : struct auth_context **auth_context,
518 : const char *methods)
519 : {
520 2087 : char **method_list;
521 2087 : NTSTATUS status;
522 :
523 130531 : method_list = str_list_make_v3(talloc_tos(), methods, NULL);
524 130531 : if (method_list == NULL) {
525 0 : return NT_STATUS_NO_MEMORY;
526 : }
527 :
528 130531 : status = make_auth_context_text_list(
529 : mem_ctx, auth_context, method_list);
530 :
531 130531 : TALLOC_FREE(method_list);
532 :
533 130531 : return status;
534 : }
535 :
536 : /***************************************************************************
537 : Make a auth_context struct for the auth subsystem
538 : ***************************************************************************/
539 :
540 129798 : NTSTATUS make_auth3_context_for_ntlm(TALLOC_CTX *mem_ctx,
541 : struct auth_context **auth_context)
542 : {
543 129798 : const char *methods = NULL;
544 129798 : const char *role = NULL;
545 :
546 129798 : switch (lp_server_role()) {
547 37111 : case ROLE_ACTIVE_DIRECTORY_DC:
548 37111 : role = "'active directory domain controller'";
549 37111 : methods = "samba4";
550 37111 : break;
551 7010 : case ROLE_DOMAIN_MEMBER:
552 7010 : role = "'domain member'";
553 7010 : methods = "anonymous sam winbind sam_ignoredomain";
554 7010 : break;
555 40320 : case ROLE_DOMAIN_BDC:
556 : case ROLE_DOMAIN_PDC:
557 : case ROLE_IPA_DC:
558 40320 : role = "'DC'";
559 40320 : methods = "anonymous sam winbind sam_ignoredomain";
560 40320 : break;
561 43270 : case ROLE_STANDALONE:
562 43270 : if (lp_encrypt_passwords()) {
563 43270 : role = "'standalone server', encrypt passwords = yes";
564 43270 : methods = "anonymous sam_ignoredomain";
565 : } else {
566 0 : role = "'standalone server', encrypt passwords = no";
567 0 : methods = "anonymous unix";
568 : }
569 43270 : break;
570 0 : default:
571 0 : DEBUG(5,("Unknown auth method!\n"));
572 0 : return NT_STATUS_UNSUCCESSFUL;
573 : }
574 :
575 129798 : DBG_INFO("Making default auth method list for server role = %s\n",
576 : role);
577 :
578 129798 : return make_auth_context_specific(mem_ctx, auth_context, methods);
579 : }
580 :
581 733 : NTSTATUS make_auth3_context_for_netlogon(TALLOC_CTX *mem_ctx,
582 : struct auth_context **auth_context)
583 : {
584 733 : const char *methods = NULL;
585 :
586 733 : switch (lp_server_role()) {
587 733 : case ROLE_DOMAIN_BDC:
588 : case ROLE_DOMAIN_PDC:
589 : case ROLE_IPA_DC:
590 733 : methods = "sam_netlogon3 winbind";
591 733 : break;
592 :
593 0 : default:
594 0 : DBG_ERR("Invalid server role!\n");
595 0 : return NT_STATUS_INVALID_SERVER_STATE;
596 : }
597 :
598 733 : return make_auth_context_specific(mem_ctx, auth_context, methods);
599 : }
600 :
601 0 : NTSTATUS make_auth3_context_for_winbind(TALLOC_CTX *mem_ctx,
602 : struct auth_context **auth_context)
603 : {
604 0 : const char *methods = NULL;
605 :
606 0 : switch (lp_server_role()) {
607 0 : case ROLE_STANDALONE:
608 : case ROLE_DOMAIN_MEMBER:
609 : case ROLE_DOMAIN_BDC:
610 : case ROLE_DOMAIN_PDC:
611 : case ROLE_IPA_DC:
612 0 : methods = "sam";
613 0 : break;
614 0 : case ROLE_ACTIVE_DIRECTORY_DC:
615 0 : methods = "samba4:sam";
616 0 : break;
617 0 : default:
618 0 : DEBUG(5,("Unknown auth method!\n"));
619 0 : return NT_STATUS_UNSUCCESSFUL;
620 : }
621 :
622 0 : return make_auth_context_specific(mem_ctx, auth_context, methods);
623 : }
624 :
625 849 : bool auth3_context_set_challenge(
626 : struct auth_context *ctx,
627 : const uint8_t chal[8],
628 : const char *challenge_set_by)
629 : {
630 849 : ctx->challenge = data_blob_talloc(ctx, chal, 8);
631 849 : if (ctx->challenge.data == NULL) {
632 0 : return false;
633 : }
634 849 : ctx->challenge_set_by = talloc_strdup(ctx, challenge_set_by);
635 849 : if (ctx->challenge_set_by == NULL) {
636 0 : return false;
637 : }
638 849 : return true;
639 : }
|
