2 Unix SMB/CIFS implementation.
3 kerberos authorization data (PAC) utility library
4 Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2003
5 Copyright (C) Andrew Bartlett <abartlet@samba.org> 2004-2005
6 Copyright (C) Andrew Tridgell 2001
7 Copyright (C) Luke Howard 2002-2003
8 Copyright (C) Stefan Metzmacher 2004-2005
9 Copyright (C) Guenther Deschner 2005,2007,2008
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>.
28 #define DBGC_CLASS DBGC_AUTH
32 #include "librpc/gen_ndr/ndr_krb5pac.h"
33 #include "librpc/gen_ndr/auth.h"
34 #include "auth/common_auth.h"
35 #include "auth/kerberos/pac_utils.h"
37 krb5_error_code
check_pac_checksum(DATA_BLOB pac_data
,
38 struct PAC_SIGNATURE_DATA
*sig
,
40 const krb5_keyblock
*keyblock
)
44 krb5_keyusage usage
= 0;
45 krb5_boolean checksum_valid
= false;
49 case CKSUMTYPE_HMAC_MD5
:
50 /* ignores the key type */
52 case CKSUMTYPE_HMAC_SHA1_96_AES_256
:
53 if (KRB5_KEY_TYPE(keyblock
) != ENCTYPE_AES256_CTS_HMAC_SHA1_96
) {
58 case CKSUMTYPE_HMAC_SHA1_96_AES_128
:
59 if (KRB5_KEY_TYPE(keyblock
) != ENCTYPE_AES128_CTS_HMAC_SHA1_96
) {
65 DEBUG(2,("check_pac_checksum: Checksum Type %d is not supported\n",
70 #ifdef HAVE_CHECKSUM_IN_KRB5_CHECKSUM /* Heimdal */
71 cksum
.cksumtype
= (krb5_cksumtype
)sig
->type
;
72 cksum
.checksum
.length
= sig
->signature
.length
;
73 cksum
.checksum
.data
= sig
->signature
.data
;
75 cksum
.checksum_type
= (krb5_cksumtype
)sig
->type
;
76 cksum
.length
= sig
->signature
.length
;
77 cksum
.contents
= sig
->signature
.data
;
80 #ifdef HAVE_KRB5_KU_OTHER_CKSUM /* Heimdal */
81 usage
= KRB5_KU_OTHER_CKSUM
;
82 #elif defined(HAVE_KRB5_KEYUSAGE_APP_DATA_CKSUM) /* MIT */
83 usage
= KRB5_KEYUSAGE_APP_DATA_CKSUM
;
85 #error UNKNOWN_KRB5_KEYUSAGE
88 input
.data
= (char *)pac_data
.data
;
89 input
.length
= pac_data
.length
;
91 ret
= krb5_c_verify_checksum(context
,
97 if (!checksum_valid
) {
98 ret
= KRB5KRB_AP_ERR_BAD_INTEGRITY
;
101 DEBUG(2,("check_pac_checksum: PAC Verification failed: %s (%d)\n",
102 error_message(ret
), ret
));
110 * @brief Decode a blob containing a NDR encoded PAC structure
112 * @param mem_ctx - The memory context
113 * @param pac_data_blob - The data blob containing the NDR encoded data
114 * @param context - The Kerberos Context
115 * @param service_keyblock - The Service Key used to verify the checksum
116 * @param client_principal - The client principal
117 * @param tgs_authtime - The ticket timestamp
118 * @param pac_data_out - [out] The decoded PAC
120 * @return - A NTSTATUS error code
122 NTSTATUS
kerberos_decode_pac(TALLOC_CTX
*mem_ctx
,
123 DATA_BLOB pac_data_blob
,
124 krb5_context context
,
125 const krb5_keyblock
*krbtgt_keyblock
,
126 const krb5_keyblock
*service_keyblock
,
127 krb5_const_principal client_principal
,
129 struct PAC_DATA
**pac_data_out
)
132 enum ndr_err_code ndr_err
;
134 DATA_BLOB modified_pac_blob
;
136 NTTIME tgs_authtime_nttime
;
139 struct PAC_SIGNATURE_DATA
*srv_sig_ptr
= NULL
;
140 struct PAC_SIGNATURE_DATA
*kdc_sig_ptr
= NULL
;
141 struct PAC_SIGNATURE_DATA
*srv_sig_wipe
= NULL
;
142 struct PAC_SIGNATURE_DATA
*kdc_sig_wipe
= NULL
;
143 struct PAC_LOGON_NAME
*logon_name
= NULL
;
144 struct PAC_LOGON_INFO
*logon_info
= NULL
;
145 struct PAC_DATA
*pac_data
= NULL
;
146 struct PAC_DATA_RAW
*pac_data_raw
= NULL
;
148 DATA_BLOB
*srv_sig_blob
= NULL
;
149 DATA_BLOB
*kdc_sig_blob
= NULL
;
153 TALLOC_CTX
*tmp_ctx
= talloc_new(mem_ctx
);
155 return NT_STATUS_NO_MEMORY
;
159 *pac_data_out
= NULL
;
162 pac_data
= talloc(tmp_ctx
, struct PAC_DATA
);
163 pac_data_raw
= talloc(tmp_ctx
, struct PAC_DATA_RAW
);
164 kdc_sig_wipe
= talloc(tmp_ctx
, struct PAC_SIGNATURE_DATA
);
165 srv_sig_wipe
= talloc(tmp_ctx
, struct PAC_SIGNATURE_DATA
);
166 if (!pac_data_raw
|| !pac_data
|| !kdc_sig_wipe
|| !srv_sig_wipe
) {
167 talloc_free(tmp_ctx
);
168 return NT_STATUS_NO_MEMORY
;
171 ndr_err
= ndr_pull_struct_blob(&pac_data_blob
, pac_data
, pac_data
,
172 (ndr_pull_flags_fn_t
)ndr_pull_PAC_DATA
);
173 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
174 status
= ndr_map_error2ntstatus(ndr_err
);
175 DEBUG(0,("can't parse the PAC: %s\n",
177 talloc_free(tmp_ctx
);
181 if (pac_data
->num_buffers
< 4) {
182 /* we need logon_ingo, service_key and kdc_key */
183 DEBUG(0,("less than 4 PAC buffers\n"));
184 talloc_free(tmp_ctx
);
185 return NT_STATUS_INVALID_PARAMETER
;
188 ndr_err
= ndr_pull_struct_blob(
189 &pac_data_blob
, pac_data_raw
, pac_data_raw
,
190 (ndr_pull_flags_fn_t
)ndr_pull_PAC_DATA_RAW
);
191 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
192 status
= ndr_map_error2ntstatus(ndr_err
);
193 DEBUG(0,("can't parse the PAC: %s\n",
195 talloc_free(tmp_ctx
);
199 if (pac_data_raw
->num_buffers
< 4) {
200 /* we need logon_ingo, service_key and kdc_key */
201 DEBUG(0,("less than 4 PAC buffers\n"));
202 talloc_free(tmp_ctx
);
203 return NT_STATUS_INVALID_PARAMETER
;
206 if (pac_data
->num_buffers
!= pac_data_raw
->num_buffers
) {
207 /* we need logon_ingo, service_key and kdc_key */
208 DEBUG(0, ("misparse! PAC_DATA has %d buffers while "
209 "PAC_DATA_RAW has %d\n", pac_data
->num_buffers
,
210 pac_data_raw
->num_buffers
));
211 talloc_free(tmp_ctx
);
212 return NT_STATUS_INVALID_PARAMETER
;
215 for (i
=0; i
< pac_data
->num_buffers
; i
++) {
216 struct PAC_BUFFER
*data_buf
= &pac_data
->buffers
[i
];
217 struct PAC_BUFFER_RAW
*raw_buf
= &pac_data_raw
->buffers
[i
];
219 if (data_buf
->type
!= raw_buf
->type
) {
220 DEBUG(0, ("misparse! PAC_DATA buffer %d has type "
221 "%d while PAC_DATA_RAW has %d\n", i
,
222 data_buf
->type
, raw_buf
->type
));
223 talloc_free(tmp_ctx
);
224 return NT_STATUS_INVALID_PARAMETER
;
226 switch (data_buf
->type
) {
227 case PAC_TYPE_LOGON_INFO
:
228 if (!data_buf
->info
) {
231 logon_info
= data_buf
->info
->logon_info
.info
;
233 case PAC_TYPE_SRV_CHECKSUM
:
234 if (!data_buf
->info
) {
237 srv_sig_ptr
= &data_buf
->info
->srv_cksum
;
238 srv_sig_blob
= &raw_buf
->info
->remaining
;
240 case PAC_TYPE_KDC_CHECKSUM
:
241 if (!data_buf
->info
) {
244 kdc_sig_ptr
= &data_buf
->info
->kdc_cksum
;
245 kdc_sig_blob
= &raw_buf
->info
->remaining
;
247 case PAC_TYPE_LOGON_NAME
:
248 logon_name
= &data_buf
->info
->logon_name
;
256 DEBUG(0,("PAC no logon_info\n"));
257 talloc_free(tmp_ctx
);
258 return NT_STATUS_INVALID_PARAMETER
;
262 DEBUG(0,("PAC no logon_name\n"));
263 talloc_free(tmp_ctx
);
264 return NT_STATUS_INVALID_PARAMETER
;
267 if (!srv_sig_ptr
|| !srv_sig_blob
) {
268 DEBUG(0,("PAC no srv_key\n"));
269 talloc_free(tmp_ctx
);
270 return NT_STATUS_INVALID_PARAMETER
;
273 if (!kdc_sig_ptr
|| !kdc_sig_blob
) {
274 DEBUG(0,("PAC no kdc_key\n"));
275 talloc_free(tmp_ctx
);
276 return NT_STATUS_INVALID_PARAMETER
;
279 /* Find and zero out the signatures,
280 * as required by the signing algorithm */
282 /* We find the data blobs above,
283 * now we parse them to get at the exact portion we should zero */
284 ndr_err
= ndr_pull_struct_blob(
285 kdc_sig_blob
, kdc_sig_wipe
, kdc_sig_wipe
,
286 (ndr_pull_flags_fn_t
)ndr_pull_PAC_SIGNATURE_DATA
);
287 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
288 status
= ndr_map_error2ntstatus(ndr_err
);
289 DEBUG(0,("can't parse the KDC signature: %s\n",
291 talloc_free(tmp_ctx
);
295 ndr_err
= ndr_pull_struct_blob(
296 srv_sig_blob
, srv_sig_wipe
, srv_sig_wipe
,
297 (ndr_pull_flags_fn_t
)ndr_pull_PAC_SIGNATURE_DATA
);
298 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
299 status
= ndr_map_error2ntstatus(ndr_err
);
300 DEBUG(0,("can't parse the SRV signature: %s\n",
302 talloc_free(tmp_ctx
);
306 /* Now zero the decoded structure */
307 memset(kdc_sig_wipe
->signature
.data
,
308 '\0', kdc_sig_wipe
->signature
.length
);
309 memset(srv_sig_wipe
->signature
.data
,
310 '\0', srv_sig_wipe
->signature
.length
);
312 /* and reencode, back into the same place it came from */
313 ndr_err
= ndr_push_struct_blob(
314 kdc_sig_blob
, pac_data_raw
, kdc_sig_wipe
,
315 (ndr_push_flags_fn_t
)ndr_push_PAC_SIGNATURE_DATA
);
316 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
317 status
= ndr_map_error2ntstatus(ndr_err
);
318 DEBUG(0,("can't repack the KDC signature: %s\n",
320 talloc_free(tmp_ctx
);
323 ndr_err
= ndr_push_struct_blob(
324 srv_sig_blob
, pac_data_raw
, srv_sig_wipe
,
325 (ndr_push_flags_fn_t
)ndr_push_PAC_SIGNATURE_DATA
);
326 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
327 status
= ndr_map_error2ntstatus(ndr_err
);
328 DEBUG(0,("can't repack the SRV signature: %s\n",
330 talloc_free(tmp_ctx
);
334 /* push out the whole structure, but now with zero'ed signatures */
335 ndr_err
= ndr_push_struct_blob(
336 &modified_pac_blob
, pac_data_raw
, pac_data_raw
,
337 (ndr_push_flags_fn_t
)ndr_push_PAC_DATA_RAW
);
338 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
339 status
= ndr_map_error2ntstatus(ndr_err
);
340 DEBUG(0,("can't repack the RAW PAC: %s\n",
342 talloc_free(tmp_ctx
);
346 if (service_keyblock
) {
347 /* verify by service_key */
348 ret
= check_pac_checksum(modified_pac_blob
, srv_sig_ptr
,
352 DEBUG(5, ("PAC Decode: Failed to verify the service "
353 "signature: %s\n", error_message(ret
)));
354 return NT_STATUS_ACCESS_DENIED
;
357 if (krbtgt_keyblock
) {
358 /* verify the service key checksum by krbtgt_key */
359 ret
= check_pac_checksum(srv_sig_ptr
->signature
, kdc_sig_ptr
,
360 context
, krbtgt_keyblock
);
362 DEBUG(1, ("PAC Decode: Failed to verify the KDC signature: %s\n",
363 smb_get_krb5_error_message(context
, ret
, tmp_ctx
)));
364 talloc_free(tmp_ctx
);
365 return NT_STATUS_ACCESS_DENIED
;
371 /* Convert to NT time, so as not to loose accuracy in comparison */
372 unix_to_nt_time(&tgs_authtime_nttime
, tgs_authtime
);
374 if (tgs_authtime_nttime
!= logon_name
->logon_time
) {
375 DEBUG(2, ("PAC Decode: "
376 "Logon time mismatch between ticket and PAC!\n"));
377 DEBUG(2, ("PAC Decode: PAC: %s\n",
378 nt_time_string(tmp_ctx
, logon_name
->logon_time
)));
379 DEBUG(2, ("PAC Decode: Ticket: %s\n",
380 nt_time_string(tmp_ctx
, tgs_authtime_nttime
)));
381 talloc_free(tmp_ctx
);
382 return NT_STATUS_ACCESS_DENIED
;
386 if (client_principal
) {
387 char *client_principal_string
;
388 ret
= krb5_unparse_name_flags(context
, client_principal
,
389 KRB5_PRINCIPAL_UNPARSE_NO_REALM
|KRB5_PRINCIPAL_UNPARSE_DISPLAY
,
390 &client_principal_string
);
392 DEBUG(2, ("Could not unparse name from ticket to match with name from PAC: [%s]:%s\n",
393 logon_name
->account_name
, error_message(ret
)));
394 talloc_free(tmp_ctx
);
395 return NT_STATUS_INVALID_PARAMETER
;
398 bool_ret
= strcmp(client_principal_string
, logon_name
->account_name
) == 0;
401 DEBUG(2, ("Name in PAC [%s] does not match principal name "
403 logon_name
->account_name
,
404 client_principal_string
));
405 SAFE_FREE(client_principal_string
);
406 talloc_free(tmp_ctx
);
407 return NT_STATUS_ACCESS_DENIED
;
409 SAFE_FREE(client_principal_string
);
413 DEBUG(3,("Found account name from PAC: %s [%s]\n",
414 logon_info
->info3
.base
.account_name
.string
,
415 logon_info
->info3
.base
.full_name
.string
));
417 DEBUG(10,("Successfully validated Kerberos PAC\n"));
419 if (DEBUGLEVEL
>= 10) {
421 s
= NDR_PRINT_STRUCT_STRING(tmp_ctx
, PAC_DATA
, pac_data
);
423 DEBUGADD(10,("%s\n", s
));
428 *pac_data_out
= talloc_steal(mem_ctx
, pac_data
);
434 NTSTATUS
kerberos_pac_logon_info(TALLOC_CTX
*mem_ctx
,
436 krb5_context context
,
437 const krb5_keyblock
*krbtgt_keyblock
,
438 const krb5_keyblock
*service_keyblock
,
439 krb5_const_principal client_principal
,
441 struct PAC_LOGON_INFO
**logon_info
)
444 struct PAC_DATA
*pac_data
;
446 nt_status
= kerberos_decode_pac(mem_ctx
,
454 if (!NT_STATUS_IS_OK(nt_status
)) {
459 for (i
=0; i
< pac_data
->num_buffers
; i
++) {
460 if (pac_data
->buffers
[i
].type
!= PAC_TYPE_LOGON_INFO
) {
463 *logon_info
= pac_data
->buffers
[i
].info
->logon_info
.info
;
466 return NT_STATUS_INVALID_PARAMETER
;
471 static NTSTATUS
auth4_context_fetch_PAC_DATA_CTR(
472 struct auth4_context
*auth_ctx
,
474 struct smb_krb5_context
*smb_krb5_context
,
476 const char *princ_name
,
477 const struct tsocket_address
*remote_address
,
478 uint32_t session_info_flags
,
479 struct auth_session_info
**session_info
)
481 struct PAC_DATA_CTR
*pac_data_ctr
= NULL
;
484 if (pac_blob
== NULL
) {
485 return NT_STATUS_NO_IMPERSONATION_TOKEN
;
488 pac_data_ctr
= talloc_zero(mem_ctx
, struct PAC_DATA_CTR
);
489 if (pac_data_ctr
== NULL
) {
490 status
= NT_STATUS_NO_MEMORY
;
494 status
= kerberos_decode_pac(pac_data_ctr
,
501 &pac_data_ctr
->pac_data
);
502 if (!NT_STATUS_IS_OK(status
)) {
506 pac_data_ctr
->pac_blob
= data_blob_talloc(pac_data_ctr
,
509 if (pac_data_ctr
->pac_blob
.length
!= pac_blob
->length
) {
510 status
= NT_STATUS_NO_MEMORY
;
514 *session_info
= talloc_zero(mem_ctx
, struct auth_session_info
);
515 if (*session_info
== NULL
) {
516 status
= NT_STATUS_NO_MEMORY
;
520 TALLOC_FREE(auth_ctx
->private_data
);
521 auth_ctx
->private_data
= talloc_move(auth_ctx
, &pac_data_ctr
);
526 TALLOC_FREE(pac_data_ctr
);
531 struct auth4_context
*auth4_context_for_PAC_DATA_CTR(TALLOC_CTX
*mem_ctx
)
533 struct auth4_context
*auth_ctx
= NULL
;
535 auth_ctx
= talloc_zero(mem_ctx
, struct auth4_context
);
536 if (auth_ctx
== NULL
) {
539 auth_ctx
->generate_session_info_pac
= auth4_context_fetch_PAC_DATA_CTR
;
544 struct PAC_DATA_CTR
*auth4_context_get_PAC_DATA_CTR(struct auth4_context
*auth_ctx
,
547 struct PAC_DATA_CTR
*p
= NULL
;
548 SMB_ASSERT(auth_ctx
->generate_session_info_pac
== auth4_context_fetch_PAC_DATA_CTR
);
549 p
= talloc_get_type_abort(auth_ctx
->private_data
, struct PAC_DATA_CTR
);
550 auth_ctx
->private_data
= NULL
;
551 return talloc_move(mem_ctx
, &p
);