Line data Source code
1 : /*
2 : Unix SMB/CIFS implementation.
3 :
4 : Generic Authentication Interface
5 :
6 : Copyright (C) Andrew Tridgell 2003
7 : Copyright (C) Andrew Bartlett <abartlet@samba.org> 2004-2006
8 :
9 : This program is free software; you can redistribute it and/or modify
10 : it under the terms of the GNU General Public License as published by
11 : the Free Software Foundation; either version 3 of the License, or
12 : (at your option) any later version.
13 :
14 : This program is distributed in the hope that it will be useful,
15 : but WITHOUT ANY WARRANTY; without even the implied warranty of
16 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 : GNU General Public License for more details.
18 :
19 : You should have received a copy of the GNU General Public License
20 : along with this program. If not, see <http://www.gnu.org/licenses/>.
21 : */
22 :
23 : #include "includes.h"
24 : #include "system/network.h"
25 : #define TEVENT_DEPRECATED 1
26 : #include <tevent.h>
27 : #include "lib/tsocket/tsocket.h"
28 : #include "lib/util/tevent_ntstatus.h"
29 : #include "auth/gensec/gensec.h"
30 : #include "auth/gensec/gensec_internal.h"
31 : #include "librpc/gen_ndr/dcerpc.h"
32 : #include "auth/common_auth.h"
33 :
34 : #undef DBGC_CLASS
35 : #define DBGC_CLASS DBGC_AUTH
36 :
37 129118 : _PRIVATE_ NTSTATUS gensec_may_reset_crypto(struct gensec_security *gensec_security,
38 : bool full_reset)
39 : {
40 129118 : if (!gensec_security->ops->may_reset_crypto) {
41 63722 : return NT_STATUS_OK;
42 : }
43 :
44 65396 : return gensec_security->ops->may_reset_crypto(gensec_security, full_reset);
45 : }
46 :
47 : /*
48 : wrappers for the gensec function pointers
49 : */
50 699878 : _PUBLIC_ NTSTATUS gensec_unseal_packet(struct gensec_security *gensec_security,
51 : uint8_t *data, size_t length,
52 : const uint8_t *whole_pdu, size_t pdu_length,
53 : const DATA_BLOB *sig)
54 : {
55 699878 : if (!gensec_security->ops->unseal_packet) {
56 0 : return NT_STATUS_NOT_IMPLEMENTED;
57 : }
58 699878 : if (!gensec_have_feature(gensec_security, GENSEC_FEATURE_SIGN)) {
59 0 : return NT_STATUS_INVALID_PARAMETER;
60 : }
61 699878 : if (!gensec_have_feature(gensec_security, GENSEC_FEATURE_SEAL)) {
62 0 : return NT_STATUS_INVALID_PARAMETER;
63 : }
64 699878 : if (!gensec_have_feature(gensec_security, GENSEC_FEATURE_DCE_STYLE)) {
65 0 : return NT_STATUS_INVALID_PARAMETER;
66 : }
67 :
68 699878 : return gensec_security->ops->unseal_packet(gensec_security,
69 : data, length,
70 : whole_pdu, pdu_length,
71 : sig);
72 : }
73 :
74 219492 : _PUBLIC_ NTSTATUS gensec_check_packet(struct gensec_security *gensec_security,
75 : const uint8_t *data, size_t length,
76 : const uint8_t *whole_pdu, size_t pdu_length,
77 : const DATA_BLOB *sig)
78 : {
79 219492 : if (!gensec_security->ops->check_packet) {
80 0 : return NT_STATUS_NOT_IMPLEMENTED;
81 : }
82 219492 : if (!gensec_have_feature(gensec_security, GENSEC_FEATURE_SIGN)) {
83 6 : return NT_STATUS_INVALID_PARAMETER;
84 : }
85 :
86 219486 : return gensec_security->ops->check_packet(gensec_security, data, length, whole_pdu, pdu_length, sig);
87 : }
88 :
89 699986 : _PUBLIC_ NTSTATUS gensec_seal_packet(struct gensec_security *gensec_security,
90 : TALLOC_CTX *mem_ctx,
91 : uint8_t *data, size_t length,
92 : const uint8_t *whole_pdu, size_t pdu_length,
93 : DATA_BLOB *sig)
94 : {
95 699986 : if (!gensec_security->ops->seal_packet) {
96 0 : return NT_STATUS_NOT_IMPLEMENTED;
97 : }
98 699986 : if (!gensec_have_feature(gensec_security, GENSEC_FEATURE_SEAL)) {
99 0 : return NT_STATUS_INVALID_PARAMETER;
100 : }
101 699986 : if (!gensec_have_feature(gensec_security, GENSEC_FEATURE_SIGN)) {
102 0 : return NT_STATUS_INVALID_PARAMETER;
103 : }
104 699986 : if (!gensec_have_feature(gensec_security, GENSEC_FEATURE_DCE_STYLE)) {
105 0 : return NT_STATUS_INVALID_PARAMETER;
106 : }
107 :
108 699986 : return gensec_security->ops->seal_packet(gensec_security, mem_ctx, data, length, whole_pdu, pdu_length, sig);
109 : }
110 :
111 224747 : _PUBLIC_ NTSTATUS gensec_sign_packet(struct gensec_security *gensec_security,
112 : TALLOC_CTX *mem_ctx,
113 : const uint8_t *data, size_t length,
114 : const uint8_t *whole_pdu, size_t pdu_length,
115 : DATA_BLOB *sig)
116 : {
117 224747 : if (!gensec_security->ops->sign_packet) {
118 0 : return NT_STATUS_NOT_IMPLEMENTED;
119 : }
120 224747 : if (!gensec_have_feature(gensec_security, GENSEC_FEATURE_SIGN)) {
121 0 : return NT_STATUS_INVALID_PARAMETER;
122 : }
123 :
124 224747 : return gensec_security->ops->sign_packet(gensec_security, mem_ctx, data, length, whole_pdu, pdu_length, sig);
125 : }
126 :
127 325798 : _PUBLIC_ size_t gensec_sig_size(struct gensec_security *gensec_security, size_t data_size)
128 : {
129 325798 : if (!gensec_security->ops->sig_size) {
130 1043 : return 0;
131 : }
132 324741 : if (!gensec_have_feature(gensec_security, GENSEC_FEATURE_SIGN)) {
133 322 : return 0;
134 : }
135 324419 : if (gensec_have_feature(gensec_security, GENSEC_FEATURE_SEAL)) {
136 186462 : if (!gensec_have_feature(gensec_security, GENSEC_FEATURE_DCE_STYLE)) {
137 0 : return 0;
138 : }
139 : }
140 :
141 324419 : return gensec_security->ops->sig_size(gensec_security, data_size);
142 : }
143 :
144 102712 : _PUBLIC_ size_t gensec_max_wrapped_size(struct gensec_security *gensec_security)
145 : {
146 102712 : if (!gensec_security->ops->max_wrapped_size) {
147 17424 : return (1 << 17);
148 : }
149 :
150 85288 : return gensec_security->ops->max_wrapped_size(gensec_security);
151 : }
152 :
153 102712 : _PUBLIC_ size_t gensec_max_input_size(struct gensec_security *gensec_security)
154 : {
155 102712 : if (!gensec_security->ops->max_input_size) {
156 17424 : return (1 << 17) - gensec_sig_size(gensec_security, 1 << 17);
157 : }
158 :
159 85288 : return gensec_security->ops->max_input_size(gensec_security);
160 : }
161 :
162 2884356 : _PUBLIC_ NTSTATUS gensec_wrap(struct gensec_security *gensec_security,
163 : TALLOC_CTX *mem_ctx,
164 : const DATA_BLOB *in,
165 : DATA_BLOB *out)
166 : {
167 2884356 : if (!gensec_security->ops->wrap) {
168 0 : return NT_STATUS_NOT_IMPLEMENTED;
169 : }
170 2884356 : return gensec_security->ops->wrap(gensec_security, mem_ctx, in, out);
171 : }
172 :
173 2883776 : _PUBLIC_ NTSTATUS gensec_unwrap(struct gensec_security *gensec_security,
174 : TALLOC_CTX *mem_ctx,
175 : const DATA_BLOB *in,
176 : DATA_BLOB *out)
177 : {
178 2883776 : if (!gensec_security->ops->unwrap) {
179 0 : return NT_STATUS_NOT_IMPLEMENTED;
180 : }
181 2883776 : return gensec_security->ops->unwrap(gensec_security, mem_ctx, in, out);
182 : }
183 :
184 75995 : _PUBLIC_ NTSTATUS gensec_session_key(struct gensec_security *gensec_security,
185 : TALLOC_CTX *mem_ctx,
186 : DATA_BLOB *session_key)
187 : {
188 75995 : if (!gensec_have_feature(gensec_security, GENSEC_FEATURE_SESSION_KEY)) {
189 0 : return NT_STATUS_NO_USER_SESSION_KEY;
190 : }
191 :
192 75995 : if (!gensec_security->ops->session_key) {
193 0 : return NT_STATUS_NOT_IMPLEMENTED;
194 : }
195 :
196 75995 : return gensec_security->ops->session_key(gensec_security, mem_ctx, session_key);
197 : }
198 :
199 171143 : const char *gensec_final_auth_type(struct gensec_security *gensec_security)
200 : {
201 171143 : if (!gensec_security->ops->final_auth_type) {
202 3011 : return gensec_security->ops->name;
203 : }
204 :
205 168132 : return gensec_security->ops->final_auth_type(gensec_security);
206 : }
207 :
208 : /*
209 : * Log details of a successful GENSEC authorization to a service.
210 : *
211 : * Only successful authorizations are logged, as only these call gensec_session_info()
212 : *
213 : * The service may later refuse authorization due to an ACL.
214 : *
215 : */
216 68919 : static void log_successful_gensec_authz_event(struct gensec_security *gensec_security,
217 : struct auth_session_info *session_info)
218 : {
219 1348 : const struct tsocket_address *remote
220 68919 : = gensec_get_remote_address(gensec_security);
221 1348 : const struct tsocket_address *local
222 68919 : = gensec_get_local_address(gensec_security);
223 1348 : const char *service_description
224 68919 : = gensec_get_target_service_description(gensec_security);
225 1348 : const char *final_auth_type
226 68919 : = gensec_final_auth_type(gensec_security);
227 68919 : const char *transport_protection = NULL;
228 68919 : if (gensec_security->want_features & GENSEC_FEATURE_SMB_TRANSPORT) {
229 31599 : transport_protection = AUTHZ_TRANSPORT_PROTECTION_SMB;
230 36518 : } else if (gensec_security->want_features & GENSEC_FEATURE_LDAPS_TRANSPORT) {
231 46 : transport_protection = AUTHZ_TRANSPORT_PROTECTION_TLS;
232 36472 : } else if (gensec_have_feature(gensec_security, GENSEC_FEATURE_SEAL)) {
233 31919 : transport_protection = AUTHZ_TRANSPORT_PROTECTION_SEAL;
234 4168 : } else if (gensec_have_feature(gensec_security, GENSEC_FEATURE_SIGN)) {
235 3239 : transport_protection = AUTHZ_TRANSPORT_PROTECTION_SIGN;
236 : } else {
237 776 : transport_protection = AUTHZ_TRANSPORT_PROTECTION_NONE;
238 : }
239 68919 : log_successful_authz_event(gensec_security->auth_context->msg_ctx,
240 68919 : gensec_security->auth_context->lp_ctx,
241 : remote, local,
242 : service_description,
243 : final_auth_type,
244 : transport_protection,
245 : session_info,
246 : NULL /* client_audit_info */,
247 : NULL /* server_audit_info */);
248 68919 : }
249 :
250 :
251 : /**
252 : * Return the credentials of a logged on user, including session keys
253 : * etc.
254 : *
255 : * Only valid after a successful authentication
256 : *
257 : * May only be called once per authentication. This will also make an
258 : * authorization log entry, as it is already called by all the
259 : * callers.
260 : *
261 : */
262 :
263 133246 : _PUBLIC_ NTSTATUS gensec_session_info(struct gensec_security *gensec_security,
264 : TALLOC_CTX *mem_ctx,
265 : struct auth_session_info **session_info)
266 : {
267 2368 : NTSTATUS status;
268 133246 : if (!gensec_security->ops->session_info) {
269 0 : return NT_STATUS_NOT_IMPLEMENTED;
270 : }
271 133246 : status = gensec_security->ops->session_info(gensec_security, mem_ctx, session_info);
272 :
273 133246 : if (NT_STATUS_IS_OK(status) && !gensec_security->subcontext
274 69015 : && (gensec_security->want_features & GENSEC_FEATURE_NO_AUTHZ_LOG) == 0) {
275 68919 : log_successful_gensec_authz_event(gensec_security, *session_info);
276 : }
277 :
278 133246 : return status;
279 : }
280 :
281 446 : _PUBLIC_ void gensec_set_max_update_size(struct gensec_security *gensec_security,
282 : uint32_t max_update_size)
283 : {
284 446 : gensec_security->max_update_size = max_update_size;
285 446 : }
286 :
287 192055 : _PUBLIC_ size_t gensec_max_update_size(struct gensec_security *gensec_security)
288 : {
289 192055 : if (gensec_security->max_update_size == 0) {
290 187973 : return UINT32_MAX;
291 : }
292 :
293 446 : return gensec_security->max_update_size;
294 : }
295 :
296 272297 : static NTSTATUS gensec_verify_features(struct gensec_security *gensec_security)
297 : {
298 4742 : bool ok;
299 :
300 : /*
301 : * gensec_want_feature(GENSEC_FEATURE_SIGN)
302 : * and
303 : * gensec_want_feature(GENSEC_FEATURE_SEAL)
304 : * require these flags to be available.
305 : */
306 272297 : if (gensec_security->want_features & GENSEC_FEATURE_SIGN) {
307 78448 : if (!gensec_have_feature(gensec_security, GENSEC_FEATURE_SIGN)) {
308 3 : DEBUG(0,("Did not manage to negotiate mandatory feature "
309 : "SIGN\n"));
310 3 : return NT_STATUS_ACCESS_DENIED;
311 : }
312 : }
313 272294 : if (gensec_security->want_features & GENSEC_FEATURE_SEAL) {
314 72465 : if (!gensec_have_feature(gensec_security, GENSEC_FEATURE_SEAL)) {
315 3 : DEBUG(0,("Did not manage to negotiate mandatory feature "
316 : "SEAL\n"));
317 3 : return NT_STATUS_ACCESS_DENIED;
318 : }
319 72462 : if (!gensec_have_feature(gensec_security, GENSEC_FEATURE_SIGN)) {
320 0 : DEBUG(0,("Did not manage to negotiate mandatory feature "
321 : "SIGN for SEAL\n"));
322 0 : return NT_STATUS_ACCESS_DENIED;
323 : }
324 : }
325 :
326 272291 : if (gensec_security->dcerpc_auth_level < DCERPC_AUTH_LEVEL_PACKET) {
327 242896 : return NT_STATUS_OK;
328 : }
329 :
330 29395 : ok = gensec_have_feature(gensec_security,
331 : GENSEC_FEATURE_SIGN_PKT_HEADER);
332 29395 : if (!ok) {
333 0 : DBG_ERR("backend [%s] does not support header signing! "
334 : "auth_level[0x%x]\n",
335 : gensec_security->ops->name,
336 : gensec_security->dcerpc_auth_level);
337 0 : return NT_STATUS_INTERNAL_ERROR;
338 : }
339 :
340 29395 : return NT_STATUS_OK;
341 : }
342 :
343 : /**
344 : * Next state function for the GENSEC state machine
345 : *
346 : * @param gensec_security GENSEC State
347 : * @param out_mem_ctx The TALLOC_CTX for *out to be allocated on
348 : * @param in The request, as a DATA_BLOB
349 : * @param out The reply, as an talloc()ed DATA_BLOB, on *out_mem_ctx
350 : * @return Error, MORE_PROCESSING_REQUIRED if a reply is sent,
351 : * or NT_STATUS_OK if the user is authenticated.
352 : */
353 135236 : _PUBLIC_ NTSTATUS gensec_update(struct gensec_security *gensec_security,
354 : TALLOC_CTX *out_mem_ctx,
355 : const DATA_BLOB in, DATA_BLOB *out)
356 : {
357 1653 : NTSTATUS status;
358 135236 : TALLOC_CTX *frame = NULL;
359 135236 : struct tevent_context *ev = NULL;
360 135236 : struct tevent_req *subreq = NULL;
361 1653 : bool ok;
362 :
363 135236 : if (gensec_security->subcontext) {
364 : /*
365 : * gensec modules are not allowed to call the sync version.
366 : */
367 0 : return NT_STATUS_INTERNAL_ERROR;
368 : }
369 :
370 135236 : frame = talloc_stackframe();
371 :
372 135236 : ev = samba_tevent_context_init(frame);
373 135236 : if (ev == NULL) {
374 0 : status = NT_STATUS_NO_MEMORY;
375 0 : goto fail;
376 : }
377 :
378 : /*
379 : * TODO: remove this hack once the backends
380 : * are fixed.
381 : */
382 135236 : tevent_loop_allow_nesting(ev);
383 :
384 135236 : subreq = gensec_update_send(frame, ev, gensec_security, in);
385 135236 : if (subreq == NULL) {
386 0 : status = NT_STATUS_NO_MEMORY;
387 0 : goto fail;
388 : }
389 135236 : ok = tevent_req_poll_ntstatus(subreq, ev, &status);
390 135236 : if (!ok) {
391 0 : goto fail;
392 : }
393 135236 : status = gensec_update_recv(subreq, out_mem_ctx, out);
394 135236 : fail:
395 135236 : TALLOC_FREE(frame);
396 135236 : return status;
397 : }
398 :
399 : struct gensec_update_state {
400 : const struct gensec_security_ops *ops;
401 : struct gensec_security *gensec_security;
402 : NTSTATUS status;
403 : DATA_BLOB out;
404 : };
405 :
406 : static void gensec_update_cleanup(struct tevent_req *req,
407 : enum tevent_req_state req_state);
408 : static void gensec_update_done(struct tevent_req *subreq);
409 :
410 : /**
411 : * Next state function for the GENSEC state machine async version
412 : *
413 : * @param mem_ctx The memory context for the request
414 : * @param ev The event context for the request
415 : * @param gensec_security GENSEC State
416 : * @param in The request, as a DATA_BLOB
417 : *
418 : * @return The request handle or NULL on no memory failure
419 : */
420 :
421 612030 : _PUBLIC_ struct tevent_req *gensec_update_send(TALLOC_CTX *mem_ctx,
422 : struct tevent_context *ev,
423 : struct gensec_security *gensec_security,
424 : const DATA_BLOB in)
425 : {
426 612030 : struct tevent_req *req = NULL;
427 612030 : struct gensec_update_state *state = NULL;
428 612030 : struct tevent_req *subreq = NULL;
429 :
430 612030 : req = tevent_req_create(mem_ctx, &state,
431 : struct gensec_update_state);
432 612030 : if (req == NULL) {
433 0 : return NULL;
434 : }
435 612030 : state->ops = gensec_security->ops;
436 612030 : state->gensec_security = gensec_security;
437 :
438 612030 : if (gensec_security->update_busy_ptr != NULL) {
439 0 : tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
440 0 : return tevent_req_post(req, ev);
441 : }
442 :
443 612030 : if (gensec_security->child_security != NULL) {
444 0 : tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
445 0 : return tevent_req_post(req, ev);
446 : }
447 :
448 612030 : gensec_security->update_busy_ptr = &state->gensec_security;
449 612030 : tevent_req_set_cleanup_fn(req, gensec_update_cleanup);
450 :
451 612030 : subreq = state->ops->update_send(state, ev, gensec_security, in);
452 612030 : if (tevent_req_nomem(subreq, req)) {
453 0 : return tevent_req_post(req, ev);
454 : }
455 612030 : tevent_req_set_callback(subreq, gensec_update_done, req);
456 :
457 612030 : DBG_DEBUG("%s[%p]: subreq: %p\n", state->ops->name,
458 : state->gensec_security, subreq);
459 :
460 602272 : return req;
461 : }
462 :
463 1224060 : static void gensec_update_cleanup(struct tevent_req *req,
464 : enum tevent_req_state req_state)
465 : {
466 19516 : struct gensec_update_state *state =
467 1224060 : tevent_req_data(req,
468 : struct gensec_update_state);
469 :
470 1224060 : if (state->gensec_security == NULL) {
471 602272 : return;
472 : }
473 :
474 612030 : if (state->gensec_security->update_busy_ptr == &state->gensec_security) {
475 612030 : state->gensec_security->update_busy_ptr = NULL;
476 : }
477 :
478 612030 : state->gensec_security = NULL;
479 : }
480 :
481 612030 : static void gensec_update_done(struct tevent_req *subreq)
482 : {
483 9758 : struct tevent_req *req =
484 612030 : tevent_req_callback_data(subreq,
485 : struct tevent_req);
486 9758 : struct gensec_update_state *state =
487 612030 : tevent_req_data(req,
488 : struct gensec_update_state);
489 9758 : NTSTATUS status;
490 612030 : const char *debug_subreq = NULL;
491 :
492 612030 : if (CHECK_DEBUGLVL(DBGLVL_DEBUG)) {
493 : /*
494 : * We need to call tevent_req_print()
495 : * before calling the _recv function,
496 : * before tevent_req_received() was called.
497 : * in order to print the pointer value of
498 : * the subreq state.
499 : */
500 10 : debug_subreq = tevent_req_print(state, subreq);
501 : }
502 :
503 612030 : status = state->ops->update_recv(subreq, state, &state->out);
504 612030 : TALLOC_FREE(subreq);
505 612030 : state->status = status;
506 612030 : if (GENSEC_UPDATE_IS_NTERROR(status)) {
507 11939 : NTSTATUS orig_status = status;
508 11939 : bool force_no_such_user = false;
509 :
510 : /*
511 : * callers only expect NT_STATUS_NO_SUCH_USER.
512 : */
513 11939 : if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_ACCOUNT_NAME)) {
514 0 : force_no_such_user = true;
515 11939 : } else if (NT_STATUS_EQUAL(status, NT_STATUS_NO_SUCH_DOMAIN)) {
516 0 : force_no_such_user = true;
517 : }
518 :
519 11939 : if (state->gensec_security->subcontext) {
520 : /*
521 : * We should only map on the outer
522 : * gensec_update exchange, spnego
523 : * needs the raw status.
524 : */
525 6529 : force_no_such_user = false;
526 : }
527 :
528 11930 : if (force_no_such_user) {
529 : /*
530 : * nt_status_squash() may map
531 : * to NT_STATUS_LOGON_FAILURE later
532 : */
533 0 : status = NT_STATUS_NO_SUCH_USER;
534 : }
535 :
536 11939 : DBG_INFO("%s[%p]: %s%s%s%s%s\n",
537 : state->ops->name,
538 : state->gensec_security,
539 : NT_STATUS_EQUAL(status, orig_status) ?
540 : "" : nt_errstr(orig_status),
541 : NT_STATUS_EQUAL(status, orig_status) ?
542 : "" : " ",
543 : nt_errstr(status),
544 : debug_subreq ? " " : "",
545 : debug_subreq ? debug_subreq : "");
546 11939 : tevent_req_nterror(req, status);
547 11939 : return;
548 : }
549 600091 : DBG_DEBUG("%s[%p]: %s %s\n", state->ops->name,
550 : state->gensec_security, nt_errstr(status),
551 : debug_subreq);
552 600091 : if (NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
553 327794 : tevent_req_done(req);
554 327794 : return;
555 : }
556 :
557 : /*
558 : * Because callers using the
559 : * gensec_start_mech_by_authtype() never call
560 : * gensec_want_feature(), it isn't sensible for them
561 : * to have to call gensec_have_feature() manually, and
562 : * these are not points of negotiation, but are
563 : * asserted by the client
564 : */
565 272297 : status = gensec_verify_features(state->gensec_security);
566 272297 : if (tevent_req_nterror(req, status)) {
567 6 : return;
568 : }
569 :
570 272291 : tevent_req_done(req);
571 : }
572 :
573 : /**
574 : * Next state function for the GENSEC state machine
575 : *
576 : * @param req request state
577 : * @param out_mem_ctx The TALLOC_CTX for *out to be allocated on
578 : * @param out The reply, as an talloc()ed DATA_BLOB, on *out_mem_ctx
579 : * @return Error, MORE_PROCESSING_REQUIRED if a reply is sent,
580 : * or NT_STATUS_OK if the user is authenticated.
581 : */
582 612030 : _PUBLIC_ NTSTATUS gensec_update_recv(struct tevent_req *req,
583 : TALLOC_CTX *out_mem_ctx,
584 : DATA_BLOB *out)
585 : {
586 9758 : struct gensec_update_state *state =
587 612030 : tevent_req_data(req, struct gensec_update_state);
588 9758 : NTSTATUS status;
589 :
590 612030 : *out = data_blob_null;
591 :
592 612030 : if (tevent_req_is_nterror(req, &status)) {
593 11945 : tevent_req_received(req);
594 11945 : return status;
595 : }
596 :
597 600085 : *out = state->out;
598 600085 : talloc_steal(out_mem_ctx, out->data);
599 600085 : status = state->status;
600 600085 : tevent_req_received(req);
601 600085 : return status;
602 : }
603 :
604 : /**
605 : * Set the requirement for a certain feature on the connection
606 : *
607 : */
608 :
609 711095 : _PUBLIC_ void gensec_want_feature(struct gensec_security *gensec_security,
610 : uint32_t feature)
611 : {
612 711095 : if (!gensec_security->ops || !gensec_security->ops->want_feature) {
613 658632 : gensec_security->want_features |= feature;
614 658632 : return;
615 : }
616 52463 : gensec_security->ops->want_feature(gensec_security, feature);
617 : }
618 :
619 : /**
620 : * Check the requirement for a certain feature on the connection
621 : *
622 : */
623 :
624 12198984 : _PUBLIC_ bool gensec_have_feature(struct gensec_security *gensec_security,
625 : uint32_t feature)
626 : {
627 12198984 : if (!gensec_security->ops || !gensec_security->ops->have_feature) {
628 0 : return false;
629 : }
630 :
631 : /* We might 'have' features that we don't 'want', because the
632 : * other end demanded them, or we can't negotiate them off */
633 12198984 : return gensec_security->ops->have_feature(gensec_security, feature);
634 : }
635 :
636 98998 : _PUBLIC_ NTTIME gensec_expire_time(struct gensec_security *gensec_security)
637 : {
638 98998 : if (!gensec_security->ops->expire_time) {
639 24921 : return GENSEC_EXPIRE_TIME_INFINITY;
640 : }
641 :
642 73948 : return gensec_security->ops->expire_time(gensec_security);
643 : }
644 : /**
645 : * Return the credentials structure associated with a GENSEC context
646 : *
647 : */
648 :
649 843326 : _PUBLIC_ struct cli_credentials *gensec_get_credentials(struct gensec_security *gensec_security)
650 : {
651 843326 : if (!gensec_security) {
652 0 : return NULL;
653 : }
654 843326 : return gensec_security->credentials;
655 : }
656 :
657 : /**
658 : * Set the target service (such as 'http' or 'host') on a GENSEC context - ensures it is talloc()ed
659 : *
660 : * This is used for Kerberos service principal name resolution.
661 : */
662 :
663 185280 : _PUBLIC_ NTSTATUS gensec_set_target_service(struct gensec_security *gensec_security, const char *service)
664 : {
665 185280 : gensec_security->target.service = talloc_strdup(gensec_security, service);
666 185280 : if (!gensec_security->target.service) {
667 0 : return NT_STATUS_NO_MEMORY;
668 : }
669 185280 : return NT_STATUS_OK;
670 : }
671 :
672 201308 : _PUBLIC_ const char *gensec_get_target_service(struct gensec_security *gensec_security)
673 : {
674 201308 : if (gensec_security->target.service) {
675 191006 : return gensec_security->target.service;
676 : }
677 :
678 10110 : return "host";
679 : }
680 :
681 : /**
682 : * Set the target service (such as 'samr') on an GENSEC context - ensures it is talloc()ed.
683 : *
684 : * This is not the Kerberos service principal, instead this is a
685 : * constant value that can be logged as part of authentication and
686 : * authorization logging
687 : */
688 121911 : _PUBLIC_ NTSTATUS gensec_set_target_service_description(struct gensec_security *gensec_security,
689 : const char *service)
690 : {
691 121911 : gensec_security->target.service_description = talloc_strdup(gensec_security, service);
692 121911 : if (!gensec_security->target.service_description) {
693 0 : return NT_STATUS_NO_MEMORY;
694 : }
695 121911 : return NT_STATUS_OK;
696 : }
697 :
698 107005 : _PUBLIC_ const char *gensec_get_target_service_description(struct gensec_security *gensec_security)
699 : {
700 107005 : if (gensec_security->target.service_description) {
701 104049 : return gensec_security->target.service_description;
702 1462 : } else if (gensec_security->target.service) {
703 166 : return gensec_security->target.service;
704 : }
705 :
706 1296 : return NULL;
707 : }
708 :
709 : /**
710 : * Set the target hostname (suitable for kerberos resolutation) on a GENSEC context - ensures it is talloc()ed
711 : *
712 : */
713 :
714 75018 : _PUBLIC_ NTSTATUS gensec_set_target_hostname(struct gensec_security *gensec_security, const char *hostname)
715 : {
716 75018 : gensec_security->target.hostname = talloc_strdup(gensec_security, hostname);
717 75018 : if (hostname && !gensec_security->target.hostname) {
718 0 : return NT_STATUS_NO_MEMORY;
719 : }
720 75018 : return NT_STATUS_OK;
721 : }
722 :
723 201506 : _PUBLIC_ const char *gensec_get_target_hostname(struct gensec_security *gensec_security)
724 : {
725 : /* We allow the target hostname to be overridden for testing purposes */
726 201506 : if (gensec_security->settings->target_hostname) {
727 4646 : return gensec_security->settings->target_hostname;
728 : }
729 :
730 196860 : if (gensec_security->target.hostname) {
731 160158 : return gensec_security->target.hostname;
732 : }
733 :
734 : /* We could add use the 'set sockaddr' call, and do a reverse
735 : * lookup, but this would be both insecure (compromising the
736 : * way kerberos works) and add DNS timeouts */
737 35725 : return NULL;
738 : }
739 :
740 : /**
741 : * Set (and copy) local and peer socket addresses onto a socket
742 : * context on the GENSEC context.
743 : *
744 : * This is so that kerberos can include these addresses in
745 : * cryptographic tokens, to avoid certain attacks.
746 : */
747 :
748 : /**
749 : * @brief Set the local gensec address.
750 : *
751 : * @param gensec_security The gensec security context to use.
752 : *
753 : * @param remote The local address to set.
754 : *
755 : * @return On success NT_STATUS_OK is returned or an NT_STATUS
756 : * error.
757 : */
758 121975 : _PUBLIC_ NTSTATUS gensec_set_local_address(struct gensec_security *gensec_security,
759 : const struct tsocket_address *local)
760 : {
761 121975 : TALLOC_FREE(gensec_security->local_addr);
762 :
763 121975 : if (local == NULL) {
764 0 : return NT_STATUS_OK;
765 : }
766 :
767 121975 : gensec_security->local_addr = tsocket_address_copy(local, gensec_security);
768 121975 : if (gensec_security->local_addr == NULL) {
769 0 : return NT_STATUS_NO_MEMORY;
770 : }
771 :
772 121975 : return NT_STATUS_OK;
773 : }
774 :
775 : /**
776 : * @brief Set the remote gensec address.
777 : *
778 : * @param gensec_security The gensec security context to use.
779 : *
780 : * @param remote The remote address to set.
781 : *
782 : * @return On success NT_STATUS_OK is returned or an NT_STATUS
783 : * error.
784 : */
785 121907 : _PUBLIC_ NTSTATUS gensec_set_remote_address(struct gensec_security *gensec_security,
786 : const struct tsocket_address *remote)
787 : {
788 121907 : TALLOC_FREE(gensec_security->remote_addr);
789 :
790 121907 : if (remote == NULL) {
791 0 : return NT_STATUS_OK;
792 : }
793 :
794 121907 : gensec_security->remote_addr = tsocket_address_copy(remote, gensec_security);
795 121907 : if (gensec_security->remote_addr == NULL) {
796 0 : return NT_STATUS_NO_MEMORY;
797 : }
798 :
799 121907 : return NT_STATUS_OK;
800 : }
801 :
802 : /**
803 : * @brief Get the local address from a gensec security context.
804 : *
805 : * @param gensec_security The security context to get the address from.
806 : *
807 : * @return The address as tsocket_address which could be NULL if
808 : * no address is set.
809 : */
810 108477 : _PUBLIC_ const struct tsocket_address *gensec_get_local_address(struct gensec_security *gensec_security)
811 : {
812 108477 : if (gensec_security == NULL) {
813 0 : return NULL;
814 : }
815 108477 : return gensec_security->local_addr;
816 : }
817 :
818 : /**
819 : * @brief Get the remote address from a gensec security context.
820 : *
821 : * @param gensec_security The security context to get the address from.
822 : *
823 : * @return The address as tsocket_address which could be NULL if
824 : * no address is set.
825 : */
826 141941 : _PUBLIC_ const struct tsocket_address *gensec_get_remote_address(struct gensec_security *gensec_security)
827 : {
828 141941 : if (gensec_security == NULL) {
829 0 : return NULL;
830 : }
831 141941 : return gensec_security->remote_addr;
832 : }
833 :
834 : /**
835 : * Set the target principal (assuming it it known, say from the SPNEGO reply)
836 : * - ensures it is talloc()ed
837 : *
838 : */
839 :
840 219 : _PUBLIC_ NTSTATUS gensec_set_target_principal(struct gensec_security *gensec_security, const char *principal)
841 : {
842 219 : gensec_security->target.principal = talloc_strdup(gensec_security, principal);
843 219 : if (!gensec_security->target.principal) {
844 0 : return NT_STATUS_NO_MEMORY;
845 : }
846 219 : return NT_STATUS_OK;
847 : }
848 :
849 147107 : _PUBLIC_ const char *gensec_get_target_principal(struct gensec_security *gensec_security)
850 : {
851 147107 : if (gensec_security->target.principal) {
852 667 : return gensec_security->target.principal;
853 : }
854 :
855 142501 : return NULL;
856 : }
|
