Debian Codegraph @

source4/torture/auth/pac.c

raw
1 /*
2 Unix SMB/CIFS implementation.
3
4 Validate the krb5 pac generation routines
5
6 Copyright (C) Andrew Bartlett <[email protected]> 2005
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
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 "lib/util/util_file.h"
25 #include "system/kerberos.h"
26 #include "auth/auth.h"
27 #include "auth/kerberos/kerberos.h"
28 #include "samba3/samba3.h"
29 #include "libcli/security/security.h"
30 #include "torture/torture.h"
31 #include "auth/auth_sam_reply.h"
32 #include "param/param.h"
33 #include "librpc/gen_ndr/ndr_krb5pac.h"
34 #include "torture/auth/proto.h"
35 #include "auth/kerberos/pac_utils.h"
36
37 static bool torture_pac_self_check(struct torture_context *tctx)
38 {
39 NTSTATUS nt_status;
40 DATA_BLOB tmp_blob;
41 struct PAC_DATA *pac_data;
42 struct PAC_LOGON_INFO *logon_info;
43 union netr_Validation validation;
44
45 /* Generate a nice, arbitrary keyblock */
46 uint8_t server_bytes[16];
47 uint8_t krbtgt_bytes[16];
48 krb5_keyblock server_keyblock;
49 krb5_keyblock krbtgt_keyblock;
50
51 krb5_error_code ret;
52
53 struct smb_krb5_context *smb_krb5_context;
54
55 struct auth_user_info_dc *user_info_dc;
56 struct auth_user_info_dc *user_info_dc_out;
57
58 krb5_principal client_principal;
59 time_t logon_time = time(NULL);
60
61 TALLOC_CTX *mem_ctx = tctx;
62
63 torture_assert(tctx, 0 == smb_krb5_init_context(mem_ctx,
64 tctx->lp_ctx,
65 &smb_krb5_context),
66 "smb_krb5_init_context");
67
68 generate_random_buffer(server_bytes, 16);
69 generate_random_buffer(krbtgt_bytes, 16);
70
71 ret = smb_krb5_keyblock_init_contents(smb_krb5_context->krb5_context,
72 ENCTYPE_ARCFOUR_HMAC,
73 server_bytes, sizeof(server_bytes),
74 &server_keyblock);
75 torture_assert(tctx, !ret, talloc_asprintf(tctx,
76 "(self test) Server Keyblock encoding failed: %s",
77 smb_get_krb5_error_message(smb_krb5_context->krb5_context,
78 ret, mem_ctx)));
79
80 ret = smb_krb5_keyblock_init_contents(smb_krb5_context->krb5_context,
81 ENCTYPE_ARCFOUR_HMAC,
82 krbtgt_bytes, sizeof(krbtgt_bytes),
83 &krbtgt_keyblock);
84 if (ret) {
85 char *err = smb_get_krb5_error_message(smb_krb5_context->krb5_context,
86 ret, mem_ctx);
87
88 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
89 &server_keyblock);
90
91 torture_fail(tctx, talloc_asprintf(tctx,
92 "(self test) KRBTGT Keyblock encoding failed: %s", err));
93 }
94
95 /* We need an input, and this one requires no underlying database */
96 nt_status = auth_anonymous_user_info_dc(mem_ctx, lpcfg_netbios_name(tctx->lp_ctx), &user_info_dc);
97
98 if (!NT_STATUS_IS_OK(nt_status)) {
99 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
100 &server_keyblock);
101 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
102 &krbtgt_keyblock);
103 torture_fail(tctx, "auth_anonymous_user_info_dc");
104 }
105
106 ret = krb5_parse_name_flags(smb_krb5_context->krb5_context,
107 user_info_dc->info->account_name,
108 KRB5_PRINCIPAL_PARSE_NO_REALM,
109 &client_principal);
110 if (ret) {
111 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
112 &server_keyblock);
113 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
114 &krbtgt_keyblock);
115 torture_fail(tctx, "krb5_parse_name_flags(norealm)");
116 }
117
118 /* OK, go ahead and make a PAC */
119 ret = kerberos_create_pac(mem_ctx,
120 user_info_dc,
121 smb_krb5_context->krb5_context,
122 &krbtgt_keyblock,
123 &server_keyblock,
124 client_principal,
125 logon_time,
126 &tmp_blob);
127
128 if (ret) {
129 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
130 &krbtgt_keyblock);
131 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
132 &server_keyblock);
133 krb5_free_principal(smb_krb5_context->krb5_context,
134 client_principal);
135
136 torture_fail(tctx, talloc_asprintf(tctx,
137 "(self test) PAC encoding failed: %s",
138 smb_get_krb5_error_message(smb_krb5_context->krb5_context,
139 ret, mem_ctx)));
140 }
141
142 dump_data(10,tmp_blob.data,tmp_blob.length);
143
144 /* Now check that we can read it back (using full decode and validate) */
145 nt_status = kerberos_decode_pac(mem_ctx,
146 tmp_blob,
147 smb_krb5_context->krb5_context,
148 &krbtgt_keyblock,
149 &server_keyblock,
150 client_principal,
151 logon_time,
152 &pac_data);
153
154 if (!NT_STATUS_IS_OK(nt_status)) {
155 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
156 &krbtgt_keyblock);
157 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
158 &server_keyblock);
159 krb5_free_principal(smb_krb5_context->krb5_context,
160 client_principal);
161
162 torture_fail(tctx, talloc_asprintf(tctx,
163 "(self test) PAC decoding failed: %s",
164 nt_errstr(nt_status)));
165 }
166
167 /* Now check we can read it back (using Heimdal's pac parsing) */
168 nt_status = kerberos_pac_blob_to_user_info_dc(mem_ctx,
169 tmp_blob,
170 smb_krb5_context->krb5_context,
171 &user_info_dc_out, NULL, NULL);
172
173 /* The user's SID is the first element in the list */
174 if (!dom_sid_equal(&user_info_dc->sids[PRIMARY_USER_SID_INDEX].sid,
175 &user_info_dc_out->sids[PRIMARY_USER_SID_INDEX].sid)) {
176 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
177 &krbtgt_keyblock);
178 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
179 &server_keyblock);
180 krb5_free_principal(smb_krb5_context->krb5_context,
181 client_principal);
182
183 torture_fail(tctx,
184 talloc_asprintf(tctx,
185 "(self test) PAC Decode resulted in *different* domain SID: %s != %s",
186 dom_sid_string(mem_ctx, &user_info_dc->sids[PRIMARY_USER_SID_INDEX].sid),
187 dom_sid_string(mem_ctx, &user_info_dc_out->sids[PRIMARY_USER_SID_INDEX].sid)));
188 }
189 talloc_free(user_info_dc_out);
190
191 /* Now check that we can read it back (yet again) */
192 nt_status = kerberos_pac_logon_info(mem_ctx,
193 tmp_blob,
194 smb_krb5_context->krb5_context,
195 &krbtgt_keyblock,
196 &server_keyblock,
197 client_principal,
198 logon_time,
199 &logon_info);
200
201 if (!NT_STATUS_IS_OK(nt_status)) {
202 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
203 &krbtgt_keyblock);
204 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
205 &server_keyblock);
206 krb5_free_principal(smb_krb5_context->krb5_context,
207 client_principal);
208
209 torture_fail(tctx,
210 talloc_asprintf(tctx,
211 "(self test) PAC decoding (for logon info) failed: %s",
212 nt_errstr(nt_status)));
213 }
214
215 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
216 &krbtgt_keyblock);
217 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
218 &server_keyblock);
219 krb5_free_principal(smb_krb5_context->krb5_context,
220 client_principal);
221
222 /* And make a server info from the samba-parsed PAC */
223 validation.sam3 = &logon_info->info3;
224 nt_status = make_user_info_dc_netlogon_validation(mem_ctx,
225 "",
226 3, &validation,
227 true, /* This user was authenticated */
228 &user_info_dc_out);
229 if (!NT_STATUS_IS_OK(nt_status)) {
230 torture_fail(tctx,
231 talloc_asprintf(tctx,
232 "(self test) PAC decoding (make server info) failed: %s",
233 nt_errstr(nt_status)));
234 }
235
236 if (!dom_sid_equal(&user_info_dc->sids[PRIMARY_USER_SID_INDEX].sid,
237 &user_info_dc_out->sids[PRIMARY_USER_SID_INDEX].sid)) {
238 torture_fail(tctx,
239 talloc_asprintf(tctx,
240 "(self test) PAC Decode resulted in *different* domain SID: %s != %s",
241 dom_sid_string(mem_ctx, &user_info_dc->sids[PRIMARY_USER_SID_INDEX].sid),
242 dom_sid_string(mem_ctx, &user_info_dc_out->sids[PRIMARY_USER_SID_INDEX].sid)));
243 }
244 return true;
245 }
246
247
248 /* This is the PAC generated on my test network, by my test Win2k3 server.
249 -- abartlet 2005-07-04
250 */
251
252 static const uint8_t saved_pac[] = {
253 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xd8, 0x01, 0x00, 0x00,
254 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
255 0x20, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
256 0x40, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
257 0x58, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x10, 0x08, 0x00, 0xcc, 0xcc, 0xcc, 0xcc,
258 0xc8, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x30, 0xdf, 0xa6, 0xcb,
259 0x4f, 0x7d, 0xc5, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0xff,
260 0xff, 0xff, 0xff, 0x7f, 0xc0, 0x3c, 0x4e, 0x59, 0x62, 0x73, 0xc5, 0x01, 0xc0, 0x3c, 0x4e, 0x59,
261 0x62, 0x73, 0xc5, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x16, 0x00, 0x16, 0x00,
262 0x04, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
263 0x0c, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
264 0x14, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x02, 0x00, 0x65, 0x00, 0x00, 0x00,
265 0xed, 0x03, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x02, 0x00,
266 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
267 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x16, 0x00, 0x20, 0x00, 0x02, 0x00, 0x16, 0x00, 0x18, 0x00,
268 0x24, 0x00, 0x02, 0x00, 0x28, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
269 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
270 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
271 0x01, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
272 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00,
273 0x57, 0x00, 0x32, 0x00, 0x30, 0x00, 0x30, 0x00, 0x33, 0x00, 0x46, 0x00, 0x49, 0x00, 0x4e, 0x00,
274 0x41, 0x00, 0x4c, 0x00, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
275 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
276 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
277 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
278 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x04, 0x02, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
279 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, 0x57, 0x00, 0x32, 0x00,
280 0x30, 0x00, 0x30, 0x00, 0x33, 0x00, 0x46, 0x00, 0x49, 0x00, 0x4e, 0x00, 0x41, 0x00, 0x4c, 0x00,
281 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x57, 0x00, 0x49, 0x00,
282 0x4e, 0x00, 0x32, 0x00, 0x4b, 0x00, 0x33, 0x00, 0x54, 0x00, 0x48, 0x00, 0x49, 0x00, 0x4e, 0x00,
283 0x4b, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
284 0x15, 0x00, 0x00, 0x00, 0x11, 0x2f, 0xaf, 0xb5, 0x90, 0x04, 0x1b, 0xec, 0x50, 0x3b, 0xec, 0xdc,
285 0x01, 0x00, 0x00, 0x00, 0x30, 0x00, 0x02, 0x00, 0x07, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
286 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
287 0x80, 0x66, 0x28, 0xea, 0x37, 0x80, 0xc5, 0x01, 0x16, 0x00, 0x77, 0x00, 0x32, 0x00, 0x30, 0x00,
288 0x30, 0x00, 0x33, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x61, 0x00, 0x6c, 0x00, 0x24, 0x00,
289 0x76, 0xff, 0xff, 0xff, 0x37, 0xd5, 0xb0, 0xf7, 0x24, 0xf0, 0xd6, 0xd4, 0xec, 0x09, 0x86, 0x5a,
290 0xa0, 0xe8, 0xc3, 0xa9, 0x00, 0x00, 0x00, 0x00, 0x76, 0xff, 0xff, 0xff, 0xb4, 0xd8, 0xb8, 0xfe,
291 0x83, 0xb3, 0x13, 0x3f, 0xfc, 0x5c, 0x41, 0xad, 0xe2, 0x64, 0x83, 0xe0, 0x00, 0x00, 0x00, 0x00
292 };
293
294 /* Check with a known 'well formed' PAC, from my test server */
295 static bool torture_pac_saved_check(struct torture_context *tctx)
296 {
297 NTSTATUS nt_status;
298 enum ndr_err_code ndr_err;
299 DATA_BLOB tmp_blob, validate_blob;
300 struct PAC_DATA *pac_data, pac_data2;
301 struct PAC_LOGON_INFO *logon_info;
302 union netr_Validation validation;
303 const char *pac_file, *pac_kdc_key, *pac_member_key;
304 struct auth_user_info_dc *user_info_dc_out;
305
306 krb5_keyblock server_keyblock;
307 krb5_keyblock krbtgt_keyblock, *krbtgt_keyblock_p;
308 struct samr_Password *krbtgt_bytes, *krbsrv_bytes;
309
310 krb5_error_code ret;
311 struct smb_krb5_context *smb_krb5_context;
312
313 const char *principal_string;
314 krb5_principal client_principal;
315 const char *authtime_string;
316 time_t authtime;
317 TALLOC_CTX *mem_ctx = tctx;
318
319 torture_assert(tctx, 0 == smb_krb5_init_context(mem_ctx,
320 tctx->lp_ctx,
321 &smb_krb5_context),
322 "smb_krb5_init_context");
323
324 pac_kdc_key = torture_setting_string(tctx, "pac_kdc_key",
325 "B286757148AF7FD252C53603A150B7E7");
326
327 pac_member_key = torture_setting_string(tctx, "pac_member_key",
328 "D217FAEAE5E6B5F95CCC94077AB8A5FC");
329
330 torture_comment(tctx, "Using pac_kdc_key '%s'\n", pac_kdc_key);
331 torture_comment(tctx, "Using pac_member_key '%s'\n", pac_member_key);
332
333 /* The krbtgt key in use when the above PAC was generated.
334 * This is an arcfour-hmac-md5 key, extracted with our 'net
335 * samdump' tool. */
336 if (*pac_kdc_key == 0) {
337 krbtgt_bytes = NULL;
338 } else {
339 krbtgt_bytes = smbpasswd_gethexpwd(mem_ctx, pac_kdc_key);
340 if (!krbtgt_bytes) {
341 torture_fail(tctx, "(saved test) Could not interpret krbtgt key");
342 }
343 }
344
345 krbsrv_bytes = smbpasswd_gethexpwd(mem_ctx, pac_member_key);
346 if (!krbsrv_bytes) {
347 torture_fail(tctx, "(saved test) Could not interpret krbsrv key");
348 }
349
350 ret = smb_krb5_keyblock_init_contents(smb_krb5_context->krb5_context,
351 ENCTYPE_ARCFOUR_HMAC,
352 krbsrv_bytes->hash, sizeof(krbsrv_bytes->hash),
353 &server_keyblock);
354 torture_assert(tctx, !ret,
355 talloc_asprintf(tctx,
356 "(saved test) Server Keyblock encoding failed: %s",
357 smb_get_krb5_error_message(smb_krb5_context->krb5_context,
358 ret, mem_ctx)));
359
360 if (krbtgt_bytes) {
361 ret = smb_krb5_keyblock_init_contents(smb_krb5_context->krb5_context,
362 ENCTYPE_ARCFOUR_HMAC,
363 krbtgt_bytes->hash, sizeof(krbtgt_bytes->hash),
364 &krbtgt_keyblock);
365 if (ret) {
366 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
367 &server_keyblock);
368 torture_fail(tctx,
369 talloc_asprintf(tctx,
370 "(saved test) Server Keyblock encoding failed: %s",
371 smb_get_krb5_error_message(smb_krb5_context->krb5_context,
372 ret, mem_ctx)));
373 }
374 krbtgt_keyblock_p = &krbtgt_keyblock;
375 } else {
376 krbtgt_keyblock_p = NULL;
377 }
378
379 pac_file = torture_setting_string(tctx, "pac_file", NULL);
380 if (pac_file) {
381 tmp_blob.data = (uint8_t *)file_load(pac_file, &tmp_blob.length, 0, mem_ctx);
382 torture_comment(tctx, "(saved test) Loaded pac of size %ld from %s\n", (long)tmp_blob.length, pac_file);
383 } else {
384 tmp_blob = data_blob_talloc(mem_ctx, saved_pac, sizeof(saved_pac));
385 }
386
387 dump_data(10,tmp_blob.data,tmp_blob.length);
388
389 principal_string = torture_setting_string(tctx, "pac_client_principal",
390 "[email protected]");
391
392 authtime_string = torture_setting_string(tctx, "pac_authtime", "1120440609");
393 authtime = strtoull(authtime_string, NULL, 0);
394
395 ret = krb5_parse_name(smb_krb5_context->krb5_context, principal_string,
396 &client_principal);
397 if (ret) {
398 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
399 krbtgt_keyblock_p);
400 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
401 &server_keyblock);
402 torture_fail(tctx,
403 talloc_asprintf(tctx,
404 "(saved test) parsing of client principal [%s] failed: %s",
405 principal_string,
406 smb_get_krb5_error_message(smb_krb5_context->krb5_context, ret, mem_ctx)));
407 }
408
409 /* Decode and verify the signaure on the PAC */
410 nt_status = kerberos_decode_pac(mem_ctx,
411 tmp_blob,
412 smb_krb5_context->krb5_context,
413 krbtgt_keyblock_p,
414 &server_keyblock,
415 client_principal, authtime, &pac_data);
416 if (!NT_STATUS_IS_OK(nt_status)) {
417 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
418 krbtgt_keyblock_p);
419 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
420 &server_keyblock);
421 krb5_free_principal(smb_krb5_context->krb5_context, client_principal);
422
423 torture_fail(tctx, talloc_asprintf(tctx,
424 "(saved test) PAC decoding failed: %s",
425 nt_errstr(nt_status)));
426 }
427
428 /* Now check we can read it back (using Heimdal's pac parsing) */
429 nt_status = kerberos_pac_blob_to_user_info_dc(mem_ctx,
430 tmp_blob,
431 smb_krb5_context->krb5_context,
432 &user_info_dc_out,
433 NULL, NULL);
434
435 if (!NT_STATUS_IS_OK(nt_status)) {
436 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
437 krbtgt_keyblock_p);
438 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
439 &server_keyblock);
440 krb5_free_principal(smb_krb5_context->krb5_context, client_principal);
441
442 torture_fail(tctx, talloc_asprintf(tctx,
443 "(saved test) Heimdal PAC decoding failed: %s",
444 nt_errstr(nt_status)));
445 }
446
447 if (!pac_file &&
448 !dom_sid_equal(dom_sid_parse_talloc(mem_ctx,
449 "S-1-5-21-3048156945-3961193616-3706469200-1005"),
450 &user_info_dc_out->sids[PRIMARY_USER_SID_INDEX].sid)) {
451 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
452 krbtgt_keyblock_p);
453 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
454 &server_keyblock);
455 krb5_free_principal(smb_krb5_context->krb5_context, client_principal);
456
457 torture_fail(tctx,
458 talloc_asprintf(tctx,
459 "(saved test) Heimdal PAC Decode resulted in *different* domain SID: %s != %s",
460 "S-1-5-21-3048156945-3961193616-3706469200-1005",
461 dom_sid_string(mem_ctx, &user_info_dc_out->sids[PRIMARY_USER_SID_INDEX].sid)));
462 }
463
464 talloc_free(user_info_dc_out);
465
466 /* Parse the PAC again, for the logon info this time (using Samba4's parsing) */
467 nt_status = kerberos_pac_logon_info(mem_ctx,
468 tmp_blob,
469 smb_krb5_context->krb5_context,
470 krbtgt_keyblock_p,
471 &server_keyblock,
472 client_principal, authtime, &logon_info);
473
474 if (!NT_STATUS_IS_OK(nt_status)) {
475 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
476 krbtgt_keyblock_p);
477 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
478 &server_keyblock);
479 krb5_free_principal(smb_krb5_context->krb5_context, client_principal);
480
481 torture_fail(tctx,
482 talloc_asprintf(tctx,
483 "(saved test) PAC decoding (for logon info) failed: %s",
484 nt_errstr(nt_status)));
485 }
486
487 validation.sam3 = &logon_info->info3;
488 nt_status = make_user_info_dc_netlogon_validation(mem_ctx,
489 "",
490 3, &validation,
491 true, /* This user was authenticated */
492 &user_info_dc_out);
493 if (!NT_STATUS_IS_OK(nt_status)) {
494 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
495 krbtgt_keyblock_p);
496 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
497 &server_keyblock);
498 krb5_free_principal(smb_krb5_context->krb5_context, client_principal);
499
500 torture_fail(tctx,
501 talloc_asprintf(tctx,
502 "(saved test) PAC decoding (make server info) failed: %s",
503 nt_errstr(nt_status)));
504 }
505
506 if (!pac_file &&
507 !dom_sid_equal(dom_sid_parse_talloc(mem_ctx,
508 "S-1-5-21-3048156945-3961193616-3706469200-1005"),
509 &user_info_dc_out->sids[PRIMARY_USER_SID_INDEX].sid)) {
510 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
511 krbtgt_keyblock_p);
512 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
513 &server_keyblock);
514 krb5_free_principal(smb_krb5_context->krb5_context, client_principal);
515
516 torture_fail(tctx,
517 talloc_asprintf(tctx,
518 "(saved test) PAC Decode resulted in *different* domain SID: %s != %s",
519 "S-1-5-21-3048156945-3961193616-3706469200-1005",
520 dom_sid_string(mem_ctx, &user_info_dc_out->sids[PRIMARY_USER_SID_INDEX].sid)));
521 }
522
523 if (krbtgt_bytes == NULL) {
524 torture_comment(tctx, "skipping PAC encoding tests as non kdc key\n");
525 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
526 &server_keyblock);
527 krb5_free_principal(smb_krb5_context->krb5_context, client_principal);
528 return true;
529 }
530
531 ret = kerberos_encode_pac(mem_ctx,
532 pac_data,
533 smb_krb5_context->krb5_context,
534 krbtgt_keyblock_p,
535 &server_keyblock,
536 &validate_blob);
537
538 if (ret != 0) {
539 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
540 krbtgt_keyblock_p);
541 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
542 &server_keyblock);
543 krb5_free_principal(smb_krb5_context->krb5_context, client_principal);
544
545 torture_fail(tctx, "(saved test) PAC push failed");
546 }
547
548 dump_data(10, validate_blob.data, validate_blob.length);
549
550 /* compare both the length and the data bytes after a
551 * pull/push cycle. This ensures we use the exact same
552 * pointer, padding etc algorithms as win2k3.
553 */
554 if (tmp_blob.length != validate_blob.length) {
555 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
556 krbtgt_keyblock_p);
557 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
558 &server_keyblock);
559 krb5_free_principal(smb_krb5_context->krb5_context, client_principal);
560
561 torture_fail(tctx,
562 talloc_asprintf(tctx,
563 "(saved test) PAC push failed: original buffer length[%u] != created buffer length[%u]",
564 (unsigned)tmp_blob.length, (unsigned)validate_blob.length));
565 }
566
567 if (memcmp(tmp_blob.data, validate_blob.data, tmp_blob.length) != 0) {
568 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
569 krbtgt_keyblock_p);
570 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
571 &server_keyblock);
572 krb5_free_principal(smb_krb5_context->krb5_context, client_principal);
573
574 DEBUG(0, ("tmp_data:\n"));
575 dump_data(0, tmp_blob.data, tmp_blob.length);
576 DEBUG(0, ("validate_blob:\n"));
577 dump_data(0, validate_blob.data, validate_blob.length);
578
579 torture_fail(tctx, talloc_asprintf(tctx, "(saved test) PAC push failed: length[%u] matches, but data does not", (unsigned)tmp_blob.length));
580 }
581
582 ret = kerberos_create_pac(mem_ctx,
583 user_info_dc_out,
584 smb_krb5_context->krb5_context,
585 krbtgt_keyblock_p,
586 &server_keyblock,
587 client_principal, authtime,
588 &validate_blob);
589
590 if (ret != 0) {
591 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
592 krbtgt_keyblock_p);
593 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
594 &server_keyblock);
595 krb5_free_principal(smb_krb5_context->krb5_context, client_principal);
596
597 torture_fail(tctx, "(saved test) regnerated PAC create failed");
598 }
599
600 dump_data(10,validate_blob.data,validate_blob.length);
601
602 /* compare both the length and the data bytes after a
603 * pull/push cycle. This ensures we use the exact same
604 * pointer, padding etc algorithms as win2k3.
605 */
606 if (tmp_blob.length != validate_blob.length) {
607 ndr_err = ndr_pull_struct_blob(&validate_blob, mem_ctx,
608 &pac_data2,
609 (ndr_pull_flags_fn_t)ndr_pull_PAC_DATA);
610 nt_status = ndr_map_error2ntstatus(ndr_err);
611 torture_assert_ntstatus_ok(tctx, nt_status, "can't parse the PAC");
612
613 NDR_PRINT_DEBUG(PAC_DATA, pac_data);
614
615 NDR_PRINT_DEBUG(PAC_DATA, &pac_data2);
616
617 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
618 krbtgt_keyblock_p);
619 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
620 &server_keyblock);
621 krb5_free_principal(smb_krb5_context->krb5_context, client_principal);
622
623 torture_fail(tctx, talloc_asprintf(tctx,
624 "(saved test) PAC regenerate failed: original buffer length[%u] != created buffer length[%u]",
625 (unsigned)tmp_blob.length, (unsigned)validate_blob.length));
626 }
627
628 if (memcmp(tmp_blob.data, validate_blob.data, tmp_blob.length) != 0) {
629 ndr_err = ndr_pull_struct_blob(&validate_blob, mem_ctx,
630 &pac_data2,
631 (ndr_pull_flags_fn_t)ndr_pull_PAC_DATA);
632 nt_status = ndr_map_error2ntstatus(ndr_err);
633 torture_assert_ntstatus_ok(tctx, nt_status, "can't parse the PAC");
634
635 NDR_PRINT_DEBUG(PAC_DATA, pac_data);
636
637 NDR_PRINT_DEBUG(PAC_DATA, &pac_data2);
638
639 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
640 krbtgt_keyblock_p);
641 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
642 &server_keyblock);
643 krb5_free_principal(smb_krb5_context->krb5_context, client_principal);
644
645 DEBUG(0, ("tmp_data:\n"));
646 dump_data(0, tmp_blob.data, tmp_blob.length);
647 DEBUG(0, ("validate_blob:\n"));
648 dump_data(0, validate_blob.data, validate_blob.length);
649
650 torture_fail(tctx, talloc_asprintf(tctx,
651 "(saved test) PAC regenerate failed: length[%u] matches, but data does not", (unsigned)tmp_blob.length));
652 }
653
654 /* Break the auth time, to ensure we check this vital detail (not setting this caused all the pain in the first place... */
655 nt_status = kerberos_decode_pac(mem_ctx,
656 tmp_blob,
657 smb_krb5_context->krb5_context,
658 krbtgt_keyblock_p,
659 &server_keyblock,
660 client_principal,
661 authtime + 1, &pac_data);
662 if (NT_STATUS_IS_OK(nt_status)) {
663
664 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
665 krbtgt_keyblock_p);
666 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
667 &server_keyblock);
668 krb5_free_principal(smb_krb5_context->krb5_context, client_principal);
669 torture_fail(tctx, "(saved test) PAC decoding DID NOT fail on broken auth time (time + 1)");
670 }
671
672 /*
673 * Finally... Bugger up the KDC signature, and check we fail the checksum.
674 *
675 * Corrupt the byte eighth from the end to account for any padding.
676 */
677 torture_assert_int_greater(tctx, tmp_blob.length, 8, "PAC data blob is smaller than expected");
678 tmp_blob.data[tmp_blob.length - 9]++;
679
680 nt_status = kerberos_decode_pac(mem_ctx,
681 tmp_blob,
682 smb_krb5_context->krb5_context,
683 krbtgt_keyblock_p,
684 &server_keyblock,
685 client_principal,
686 authtime,
687 &pac_data);
688 if (NT_STATUS_IS_OK(nt_status)) {
689 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
690 krbtgt_keyblock_p);
691 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
692 &server_keyblock);
693 krb5_free_principal(smb_krb5_context->krb5_context, client_principal);
694 torture_fail(tctx, "(saved test) PAC decoding DID NOT fail on broken checksum");
695 }
696
697 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
698 krbtgt_keyblock_p);
699 krb5_free_keyblock_contents(smb_krb5_context->krb5_context,
700 &server_keyblock);
701 krb5_free_principal(smb_krb5_context->krb5_context, client_principal);
702 return true;
703 }
704
705 struct torture_suite *torture_pac(TALLOC_CTX *mem_ctx)
706 {
707 struct torture_suite *suite = torture_suite_create(mem_ctx, "pac");
708
709 torture_suite_add_simple_test(suite, "self check",
710 torture_pac_self_check);
711 torture_suite_add_simple_test(suite, "saved check",
712 torture_pac_saved_check);
713 return suite;
714 }