1 /* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
2 /* tests/asn.1/ktest.c */
3 /*
4 * Copyright (C) 1994 by the Massachusetts Institute of Technology.
5 * All rights reserved.
6 *
7 * Export of this software from the United States of America may
8 * require a specific license from the United States Government.
9 * It is the responsibility of any person or organization contemplating
10 * export to obtain such a license before exporting.
11 *
12 * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
13 * distribute this software and its documentation for any purpose and
14 * without fee is hereby granted, provided that the above copyright
15 * notice appear in all copies and that both that copyright notice and
16 * this permission notice appear in supporting documentation, and that
17 * the name of M.I.T. not be used in advertising or publicity pertaining
18 * to distribution of the software without specific, written prior
19 * permission. Furthermore if you modify this software you must label
20 * your software as modified software and not distribute it in such a
21 * fashion that it might be confused with the original M.I.T. software.
22 * M.I.T. makes no representations about the suitability of
23 * this software for any purpose. It is provided "as is" without express
24 * or implied warranty.
25 */
26
27 #include "ktest.h"
28 #include "utility.h"
29 #include <stdlib.h>
30
31 char *sample_principal_name = "hftsai/extra@ATHENA.MIT.EDU";
32
33 void
ktest_make_sample_authenticator(krb5_authenticator * a)34 ktest_make_sample_authenticator(krb5_authenticator *a)
35 {
36 ktest_make_sample_principal(&a->client);
37 a->checksum = ealloc(sizeof(krb5_checksum));
38 ktest_make_sample_checksum(a->checksum);
39 a->cusec = SAMPLE_USEC;
40 a->ctime = SAMPLE_TIME;
41 a->subkey = ealloc(sizeof(krb5_keyblock));
42 ktest_make_sample_keyblock(a->subkey);
43 a->seq_number = SAMPLE_SEQ_NUMBER;
44 ktest_make_sample_authorization_data(&a->authorization_data);
45 }
46
47 void
ktest_make_sample_principal(krb5_principal * p)48 ktest_make_sample_principal(krb5_principal *p)
49 {
50 if (krb5_parse_name(test_context, sample_principal_name, p))
51 abort();
52 }
53
54 void
ktest_make_sample_checksum(krb5_checksum * cs)55 ktest_make_sample_checksum(krb5_checksum *cs)
56 {
57 cs->checksum_type = 1;
58 cs->length = 4;
59 cs->contents = ealloc(4);
60 memcpy(cs->contents,"1234",4);
61 }
62
63 void
ktest_make_sample_keyblock(krb5_keyblock * kb)64 ktest_make_sample_keyblock(krb5_keyblock *kb)
65 {
66 kb->magic = KV5M_KEYBLOCK;
67 kb->enctype = 1;
68 kb->length = 8;
69 kb->contents = ealloc(8);
70 memcpy(kb->contents,"12345678",8);
71 }
72
73 void
ktest_make_sample_ticket(krb5_ticket * tkt)74 ktest_make_sample_ticket(krb5_ticket *tkt)
75 {
76 ktest_make_sample_principal(&tkt->server);
77 ktest_make_sample_enc_data(&tkt->enc_part);
78 tkt->enc_part2 = NULL;
79 }
80
81 void
ktest_make_sample_enc_data(krb5_enc_data * ed)82 ktest_make_sample_enc_data(krb5_enc_data *ed)
83 {
84 ed->kvno = 5;
85 ed->enctype = 0;
86 krb5_data_parse(&ed->ciphertext, "krbASN.1 test message");
87 }
88
89 void
ktest_make_sample_enc_tkt_part(krb5_enc_tkt_part * etp)90 ktest_make_sample_enc_tkt_part(krb5_enc_tkt_part *etp)
91 {
92 etp->flags = SAMPLE_FLAGS;
93 etp->session = ealloc(sizeof(krb5_keyblock));
94 ktest_make_sample_keyblock(etp->session);
95 ktest_make_sample_principal(&etp->client);
96 ktest_make_sample_transited(&etp->transited);
97 ktest_make_sample_ticket_times(&etp->times);
98 ktest_make_sample_addresses(&etp->caddrs);
99 ktest_make_sample_authorization_data(&etp->authorization_data);
100 }
101
102 void
ktest_make_sample_addresses(krb5_address *** caddrs)103 ktest_make_sample_addresses(krb5_address ***caddrs)
104 {
105 int i;
106
107 *caddrs = ealloc(3 * sizeof(krb5_address *));
108 for (i = 0; i < 2; i++) {
109 (*caddrs)[i] = ealloc(sizeof(krb5_address));
110 ktest_make_sample_address((*caddrs)[i]);
111 }
112 (*caddrs)[2] = NULL;
113 }
114
115 void
ktest_make_sample_authorization_data(krb5_authdata *** ad)116 ktest_make_sample_authorization_data(krb5_authdata ***ad)
117 {
118 int i;
119
120 *ad = ealloc(3 * sizeof(krb5_authdata *));
121 for (i = 0; i <= 1; i++) {
122 (*ad)[i] = ealloc(sizeof(krb5_authdata));
123 ktest_make_sample_authdata((*ad)[i]);
124 }
125 (*ad)[2] = NULL;
126 }
127
128 void
ktest_make_sample_transited(krb5_transited * t)129 ktest_make_sample_transited(krb5_transited *t)
130 {
131 t->tr_type = 1;
132 krb5_data_parse(&t->tr_contents, "EDU,MIT.,ATHENA.,WASHINGTON.EDU,CS.");
133 }
134
135 void
ktest_make_sample_ticket_times(krb5_ticket_times * tt)136 ktest_make_sample_ticket_times(krb5_ticket_times *tt)
137 {
138 tt->authtime = SAMPLE_TIME;
139 tt->starttime = SAMPLE_TIME;
140 tt->endtime = SAMPLE_TIME;
141 tt->renew_till = SAMPLE_TIME;
142 }
143
144 void
ktest_make_sample_address(krb5_address * a)145 ktest_make_sample_address(krb5_address *a)
146 {
147 a->addrtype = ADDRTYPE_INET;
148 a->length = 4;
149 a->contents = ealloc(4 * sizeof(krb5_octet));
150 a->contents[0] = 18;
151 a->contents[1] = 208;
152 a->contents[2] = 0;
153 a->contents[3] = 35;
154 }
155
156 void
ktest_make_sample_authdata(krb5_authdata * ad)157 ktest_make_sample_authdata(krb5_authdata *ad)
158 {
159 ad->ad_type = 1;
160 ad->length = 6;
161 ad->contents = ealloc(6 * sizeof(krb5_octet));
162 memcpy(ad->contents, "foobar", 6);
163 }
164
165 void
ktest_make_sample_enc_kdc_rep_part(krb5_enc_kdc_rep_part * ekr)166 ktest_make_sample_enc_kdc_rep_part(krb5_enc_kdc_rep_part *ekr)
167 {
168 ekr->session = ealloc(sizeof(krb5_keyblock));
169 ktest_make_sample_keyblock(ekr->session);
170 ktest_make_sample_last_req(&ekr->last_req);
171 ekr->nonce = SAMPLE_NONCE;
172 ekr->key_exp = SAMPLE_TIME;
173 ekr->flags = SAMPLE_FLAGS;
174 ekr->times.authtime = SAMPLE_TIME;
175 ekr->times.starttime = SAMPLE_TIME;
176 ekr->times.endtime = SAMPLE_TIME;
177 ekr->times.renew_till = SAMPLE_TIME;
178 ktest_make_sample_principal(&ekr->server);
179 ktest_make_sample_addresses(&ekr->caddrs);
180 }
181
182 void
ktest_make_sample_last_req(krb5_last_req_entry *** lr)183 ktest_make_sample_last_req(krb5_last_req_entry ***lr)
184 {
185 int i;
186
187 *lr = ealloc(3 * sizeof(krb5_last_req_entry *));
188 for (i = 0; i <= 1; i++)
189 ktest_make_sample_last_req_entry(&(*lr)[i]);
190 (*lr)[2] = NULL;
191 }
192
193 void
ktest_make_sample_last_req_entry(krb5_last_req_entry ** lre)194 ktest_make_sample_last_req_entry(krb5_last_req_entry **lre)
195 {
196 *lre = ealloc(sizeof(krb5_last_req_entry));
197 (*lre)->lr_type = -5;
198 (*lre)->value = SAMPLE_TIME;
199 }
200
201 void
ktest_make_sample_kdc_rep(krb5_kdc_rep * kdcr)202 ktest_make_sample_kdc_rep(krb5_kdc_rep *kdcr)
203 {
204 ktest_make_sample_pa_data_array(&kdcr->padata);
205 ktest_make_sample_principal(&kdcr->client);
206 kdcr->ticket = ealloc(sizeof(krb5_ticket));
207 ktest_make_sample_ticket(kdcr->ticket);
208 ktest_make_sample_enc_data(&kdcr->enc_part);
209 kdcr->enc_part2 = NULL;
210 }
211
212 void
ktest_make_sample_pa_data_array(krb5_pa_data *** pad)213 ktest_make_sample_pa_data_array(krb5_pa_data ***pad)
214 {
215 int i;
216
217 *pad = ealloc(3 * sizeof(krb5_pa_data *));
218 for (i = 0; i <= 1; i++) {
219 (*pad)[i] = ealloc(sizeof(krb5_pa_data));
220 ktest_make_sample_pa_data((*pad)[i]);
221 }
222 (*pad)[2] = NULL;
223 }
224
225 void
ktest_make_sample_empty_pa_data_array(krb5_pa_data *** pad)226 ktest_make_sample_empty_pa_data_array(krb5_pa_data ***pad)
227 {
228 *pad = ealloc(sizeof(krb5_pa_data *));
229 (*pad)[0] = NULL;
230 }
231
232 void
ktest_make_sample_pa_data(krb5_pa_data * pad)233 ktest_make_sample_pa_data(krb5_pa_data *pad)
234 {
235 pad->pa_type = 13;
236 pad->length = 7;
237 pad->contents = ealloc(7);
238 memcpy(pad->contents, "pa-data", 7);
239 }
240
241 void
ktest_make_sample_ap_req(krb5_ap_req * ar)242 ktest_make_sample_ap_req(krb5_ap_req *ar)
243 {
244 ar->ap_options = SAMPLE_FLAGS;
245 ar->ticket = ealloc(sizeof(krb5_ticket));
246 ktest_make_sample_ticket(ar->ticket);
247 ktest_make_sample_enc_data(&(ar->authenticator));
248 }
249
250 void
ktest_make_sample_ap_rep(krb5_ap_rep * ar)251 ktest_make_sample_ap_rep(krb5_ap_rep *ar)
252 {
253 ktest_make_sample_enc_data(&ar->enc_part);
254 }
255
256 void
ktest_make_sample_ap_rep_enc_part(krb5_ap_rep_enc_part * arep)257 ktest_make_sample_ap_rep_enc_part(krb5_ap_rep_enc_part *arep)
258 {
259 arep->ctime = SAMPLE_TIME;
260 arep->cusec = SAMPLE_USEC;
261 arep->subkey = ealloc(sizeof(krb5_keyblock));
262 ktest_make_sample_keyblock(arep->subkey);
263 arep->seq_number = SAMPLE_SEQ_NUMBER;
264 }
265
266 void
ktest_make_sample_kdc_req(krb5_kdc_req * kr)267 ktest_make_sample_kdc_req(krb5_kdc_req *kr)
268 {
269 /* msg_type is left up to the calling procedure */
270 ktest_make_sample_pa_data_array(&kr->padata);
271 kr->kdc_options = SAMPLE_FLAGS;
272 ktest_make_sample_principal(&(kr->client));
273 ktest_make_sample_principal(&(kr->server));
274 kr->from = SAMPLE_TIME;
275 kr->till = SAMPLE_TIME;
276 kr->rtime = SAMPLE_TIME;
277 kr->nonce = SAMPLE_NONCE;
278 kr->nktypes = 2;
279 kr->ktype = ealloc(2 * sizeof(krb5_enctype));
280 kr->ktype[0] = 0;
281 kr->ktype[1] = 1;
282 ktest_make_sample_addresses(&kr->addresses);
283 ktest_make_sample_enc_data(&kr->authorization_data);
284 ktest_make_sample_authorization_data(&kr->unenc_authdata);
285 ktest_make_sample_sequence_of_ticket(&kr->second_ticket);
286 }
287
288 void
ktest_make_sample_kdc_req_body(krb5_kdc_req * krb)289 ktest_make_sample_kdc_req_body(krb5_kdc_req *krb)
290 {
291 krb->kdc_options = SAMPLE_FLAGS;
292 ktest_make_sample_principal(&krb->client);
293 ktest_make_sample_principal(&krb->server);
294 krb->from = SAMPLE_TIME;
295 krb->till = SAMPLE_TIME;
296 krb->rtime = SAMPLE_TIME;
297 krb->nonce = SAMPLE_NONCE;
298 krb->nktypes = 2;
299 krb->ktype = (krb5_enctype*)calloc(2,sizeof(krb5_enctype));
300 krb->ktype[0] = 0;
301 krb->ktype[1] = 1;
302 ktest_make_sample_addresses(&krb->addresses);
303 ktest_make_sample_enc_data(&krb->authorization_data);
304 ktest_make_sample_authorization_data(&krb->unenc_authdata);
305 ktest_make_sample_sequence_of_ticket(&krb->second_ticket);
306 }
307
308 void
ktest_make_sample_safe(krb5_safe * s)309 ktest_make_sample_safe(krb5_safe *s)
310 {
311 ktest_make_sample_data(&s->user_data);
312 s->timestamp = SAMPLE_TIME;
313 s->usec = SAMPLE_USEC;
314 s->seq_number = SAMPLE_SEQ_NUMBER;
315 s->s_address = ealloc(sizeof(krb5_address));
316 ktest_make_sample_address(s->s_address);
317 s->r_address = ealloc(sizeof(krb5_address));
318 ktest_make_sample_address(s->r_address);
319 s->checksum = ealloc(sizeof(krb5_checksum));
320 ktest_make_sample_checksum(s->checksum);
321 }
322
323 void
ktest_make_sample_priv(krb5_priv * p)324 ktest_make_sample_priv(krb5_priv *p)
325 {
326 ktest_make_sample_enc_data(&p->enc_part);
327 }
328
329 void
ktest_make_sample_priv_enc_part(krb5_priv_enc_part * pep)330 ktest_make_sample_priv_enc_part(krb5_priv_enc_part *pep)
331 {
332 ktest_make_sample_data(&(pep->user_data));
333 pep->timestamp = SAMPLE_TIME;
334 pep->usec = SAMPLE_USEC;
335 pep->seq_number = SAMPLE_SEQ_NUMBER;
336 pep->s_address = ealloc(sizeof(krb5_address));
337 ktest_make_sample_address(pep->s_address);
338 pep->r_address = ealloc(sizeof(krb5_address));
339 ktest_make_sample_address(pep->r_address);
340 }
341
342 void
ktest_make_sample_cred(krb5_cred * c)343 ktest_make_sample_cred(krb5_cred *c)
344 {
345 ktest_make_sample_sequence_of_ticket(&c->tickets);
346 ktest_make_sample_enc_data(&c->enc_part);
347 }
348
349 void
ktest_make_sample_sequence_of_ticket(krb5_ticket *** sot)350 ktest_make_sample_sequence_of_ticket(krb5_ticket ***sot)
351 {
352 int i;
353
354 *sot = ealloc(3 * sizeof(krb5_ticket *));
355 for (i = 0; i < 2; i++) {
356 (*sot)[i] = ealloc(sizeof(krb5_ticket));
357 ktest_make_sample_ticket((*sot)[i]);
358 }
359 (*sot)[2] = NULL;
360 }
361
362 void
ktest_make_sample_cred_enc_part(krb5_cred_enc_part * cep)363 ktest_make_sample_cred_enc_part(krb5_cred_enc_part *cep)
364 {
365 cep->nonce = SAMPLE_NONCE;
366 cep->timestamp = SAMPLE_TIME;
367 cep->usec = SAMPLE_USEC;
368 cep->s_address = ealloc(sizeof(krb5_address));
369 ktest_make_sample_address(cep->s_address);
370 cep->r_address = ealloc(sizeof(krb5_address));
371 ktest_make_sample_address(cep->r_address);
372 ktest_make_sequence_of_cred_info(&cep->ticket_info);
373 }
374
375 void
ktest_make_sequence_of_cred_info(krb5_cred_info *** soci)376 ktest_make_sequence_of_cred_info(krb5_cred_info ***soci)
377 {
378 int i;
379
380 *soci = ealloc(3 * sizeof(krb5_cred_info *));
381 for (i = 0; i < 2; i++) {
382 (*soci)[i] = ealloc(sizeof(krb5_cred_info));
383 ktest_make_sample_cred_info((*soci)[i]);
384 }
385 (*soci)[2] = NULL;
386 }
387
388 void
ktest_make_sample_cred_info(krb5_cred_info * ci)389 ktest_make_sample_cred_info(krb5_cred_info *ci)
390 {
391 ci->session = ealloc(sizeof(krb5_keyblock));
392 ktest_make_sample_keyblock(ci->session);
393 ktest_make_sample_principal(&ci->client);
394 ktest_make_sample_principal(&ci->server);
395 ci->flags = SAMPLE_FLAGS;
396 ci->times.authtime = SAMPLE_TIME;
397 ci->times.starttime = SAMPLE_TIME;
398 ci->times.endtime = SAMPLE_TIME;
399 ci->times.renew_till = SAMPLE_TIME;
400 ktest_make_sample_addresses(&ci->caddrs);
401 }
402
403 void
ktest_make_sample_error(krb5_error * kerr)404 ktest_make_sample_error(krb5_error *kerr)
405 {
406 kerr->ctime = SAMPLE_TIME;
407 kerr->cusec = SAMPLE_USEC;
408 kerr->susec = SAMPLE_USEC;
409 kerr->stime = SAMPLE_TIME;
410 kerr->error = SAMPLE_ERROR;
411 ktest_make_sample_principal(&kerr->client);
412 ktest_make_sample_principal(&kerr->server);
413 ktest_make_sample_data(&kerr->text);
414 ktest_make_sample_data(&kerr->e_data);
415 }
416
417 void
ktest_make_sample_data(krb5_data * d)418 ktest_make_sample_data(krb5_data *d)
419 {
420 krb5_data_parse(d, "krb5data");
421 }
422
423 void
ktest_make_sample_etype_info(krb5_etype_info_entry *** p)424 ktest_make_sample_etype_info(krb5_etype_info_entry ***p)
425 {
426 krb5_etype_info_entry **info;
427 int i, len;
428 char *str;
429
430 info = ealloc(4 * sizeof(krb5_etype_info_entry *));
431 for (i = 0; i < 3; i++) {
432 info[i] = ealloc(sizeof(krb5_etype_info_entry));
433 info[i]->etype = i;
434 len = asprintf(&str, "Morton's #%d", i);
435 if (len < 0)
436 abort();
437 info[i]->salt = (krb5_octet *)str;
438 info[i]->length = len;
439 info[i]->s2kparams.data = NULL;
440 info[i]->s2kparams.length = 0;
441 info[i]->magic = KV5M_ETYPE_INFO_ENTRY;
442 }
443 free(info[1]->salt);
444 info[1]->length = KRB5_ETYPE_NO_SALT;
445 info[1]->salt = 0;
446 *p = info;
447 }
448
449
450 void
ktest_make_sample_etype_info2(krb5_etype_info_entry *** p)451 ktest_make_sample_etype_info2(krb5_etype_info_entry ***p)
452 {
453 krb5_etype_info_entry **info;
454 int i, len;
455 char *str;
456
457 info = ealloc(4 * sizeof(krb5_etype_info_entry *));
458 for (i = 0; i < 3; i++) {
459 info[i] = ealloc(sizeof(krb5_etype_info_entry));
460 info[i]->etype = i;
461 len = asprintf(&str, "Morton's #%d", i);
462 if (len < 0)
463 abort();
464 info[i]->salt = (krb5_octet *)str;
465 info[i]->length = (unsigned int)len;
466 len = asprintf(&info[i]->s2kparams.data, "s2k: %d", i);
467 if (len < 0)
468 abort();
469 info[i]->s2kparams.length = (unsigned int) len;
470 info[i]->magic = KV5M_ETYPE_INFO_ENTRY;
471 }
472 free(info[1]->salt);
473 info[1]->length = KRB5_ETYPE_NO_SALT;
474 info[1]->salt = 0;
475 *p = info;
476 }
477
478
479 void
ktest_make_sample_pa_enc_ts(krb5_pa_enc_ts * pa_enc)480 ktest_make_sample_pa_enc_ts(krb5_pa_enc_ts *pa_enc)
481 {
482 pa_enc->patimestamp = SAMPLE_TIME;
483 pa_enc->pausec = SAMPLE_USEC;
484 }
485
486 void
ktest_make_sample_sam_challenge_2(krb5_sam_challenge_2 * p)487 ktest_make_sample_sam_challenge_2(krb5_sam_challenge_2 *p)
488 {
489 /* Need a valid DER sequence encoding here; this one contains the OCTET
490 * STRING "challenge". */
491 krb5_data_parse(&p->sam_challenge_2_body, "\x30\x0B\x04\x09" "challenge");
492 p->sam_cksum = ealloc(2 * sizeof(krb5_checksum *));
493 p->sam_cksum[0] = ealloc(sizeof(krb5_checksum));
494 ktest_make_sample_checksum(p->sam_cksum[0]);
495 p->sam_cksum[1] = NULL;
496 }
497
498 void
ktest_make_sample_sam_challenge_2_body(krb5_sam_challenge_2_body * p)499 ktest_make_sample_sam_challenge_2_body(krb5_sam_challenge_2_body *p)
500 {
501 p->sam_type = 42;
502 p->sam_flags = KRB5_SAM_USE_SAD_AS_KEY;
503 krb5_data_parse(&p->sam_type_name, "type name");
504 p->sam_track_id = empty_data();
505 krb5_data_parse(&p->sam_challenge_label, "challenge label");
506 krb5_data_parse(&p->sam_challenge, "challenge ipse");
507 krb5_data_parse(&p->sam_response_prompt, "response_prompt ipse");
508 p->sam_pk_for_sad = empty_data();
509 p->sam_nonce = 0x543210;
510 p->sam_etype = ENCTYPE_AES256_CTS_HMAC_SHA384_192;
511 }
512
513 void
ktest_make_sample_sam_response_2(krb5_sam_response_2 * p)514 ktest_make_sample_sam_response_2(krb5_sam_response_2 *p)
515 {
516 p->magic = KV5M_SAM_RESPONSE;
517 p->sam_type = 43; /* information */
518 p->sam_flags = KRB5_SAM_USE_SAD_AS_KEY; /* KRB5_SAM_* values */
519 krb5_data_parse(&p->sam_track_id, "track data");
520 krb5_data_parse(&p->sam_enc_nonce_or_sad.ciphertext, "nonce or sad");
521 p->sam_enc_nonce_or_sad.enctype = ENCTYPE_AES256_CTS_HMAC_SHA384_192;
522 p->sam_enc_nonce_or_sad.kvno = 3382;
523 p->sam_nonce = 0x543210;
524 }
525
526 void
ktest_make_sample_enc_sam_response_enc_2(krb5_enc_sam_response_enc_2 * p)527 ktest_make_sample_enc_sam_response_enc_2(krb5_enc_sam_response_enc_2 *p)
528 {
529 p->magic = 83;
530 p->sam_nonce = 88;
531 krb5_data_parse(&p->sam_sad, "enc_sam_response_enc_2");
532 }
533
534 void
ktest_make_sample_pa_for_user(krb5_pa_for_user * p)535 ktest_make_sample_pa_for_user(krb5_pa_for_user *p)
536 {
537 ktest_make_sample_principal(&p->user);
538 ktest_make_sample_checksum(&p->cksum);
539 ktest_make_sample_data(&p->auth_package);
540 }
541
542 void
ktest_make_sample_pa_s4u_x509_user(krb5_pa_s4u_x509_user * p)543 ktest_make_sample_pa_s4u_x509_user(krb5_pa_s4u_x509_user *p)
544 {
545 krb5_s4u_userid *u = &p->user_id;
546
547 u->nonce = 13243546;
548 ktest_make_sample_principal(&u->user);
549 krb5_data_parse(&u->subject_cert, "pa_s4u_x509_user");
550 u->options = 0x80000000;
551 ktest_make_sample_checksum(&p->cksum);
552 }
553
554 void
ktest_make_sample_ad_kdcissued(krb5_ad_kdcissued * p)555 ktest_make_sample_ad_kdcissued(krb5_ad_kdcissued *p)
556 {
557 ktest_make_sample_checksum(&p->ad_checksum);
558 ktest_make_sample_principal(&p->i_principal);
559 ktest_make_sample_authorization_data(&p->elements);
560 }
561
562 void
ktest_make_sample_iakerb_header(krb5_iakerb_header * ih)563 ktest_make_sample_iakerb_header(krb5_iakerb_header *ih)
564 {
565 ktest_make_sample_data(&(ih->target_realm));
566 ih->cookie = ealloc(sizeof(krb5_data));
567 ktest_make_sample_data(ih->cookie);
568 }
569
570 void
ktest_make_sample_iakerb_finished(krb5_iakerb_finished * ih)571 ktest_make_sample_iakerb_finished(krb5_iakerb_finished *ih)
572 {
573 ktest_make_sample_checksum(&ih->checksum);
574 }
575
576 static void
ktest_make_sample_fast_finished(krb5_fast_finished * p)577 ktest_make_sample_fast_finished(krb5_fast_finished *p)
578 {
579 p->timestamp = SAMPLE_TIME;
580 p->usec = SAMPLE_USEC;
581 ktest_make_sample_principal(&p->client);
582 ktest_make_sample_checksum(&p->ticket_checksum);
583 }
584
585 void
ktest_make_sample_fast_response(krb5_fast_response * p)586 ktest_make_sample_fast_response(krb5_fast_response *p)
587 {
588 ktest_make_sample_pa_data_array(&p->padata);
589 p->strengthen_key = ealloc(sizeof(krb5_keyblock));
590 ktest_make_sample_keyblock(p->strengthen_key);
591 p->finished = ealloc(sizeof(krb5_fast_finished));
592 ktest_make_sample_fast_finished(p->finished);
593 p->nonce = SAMPLE_NONCE;
594 }
595
596 void
ktest_make_sha256_alg(krb5_algorithm_identifier * p)597 ktest_make_sha256_alg(krb5_algorithm_identifier *p)
598 {
599 /* { 2 16 840 1 101 3 4 2 1 } */
600 krb5_data_parse(&p->algorithm, "\x60\x86\x48\x01\x65\x03\x04\x02\x01");
601 p->parameters = empty_data();
602 }
603
604 void
ktest_make_sha1_alg(krb5_algorithm_identifier * p)605 ktest_make_sha1_alg(krb5_algorithm_identifier *p)
606 {
607 /* { 1 3 14 3 2 26 } */
608 krb5_data_parse(&p->algorithm, "\x2b\x0e\x03\x02\x1a");
609 p->parameters = empty_data();
610 }
611
612 void
ktest_make_minimal_otp_tokeninfo(krb5_otp_tokeninfo * p)613 ktest_make_minimal_otp_tokeninfo(krb5_otp_tokeninfo *p)
614 {
615 memset(p, 0, sizeof(*p));
616 p->length = p->format = p->iteration_count = -1;
617 }
618
619 void
ktest_make_maximal_otp_tokeninfo(krb5_otp_tokeninfo * p)620 ktest_make_maximal_otp_tokeninfo(krb5_otp_tokeninfo *p)
621 {
622 p->flags = KRB5_OTP_FLAG_NEXTOTP | KRB5_OTP_FLAG_COMBINE |
623 KRB5_OTP_FLAG_COLLECT_PIN | KRB5_OTP_FLAG_ENCRYPT_NONCE |
624 KRB5_OTP_FLAG_SEPARATE_PIN | KRB5_OTP_FLAG_CHECK_DIGIT;
625 krb5_data_parse(&p->vendor, "Examplecorp");
626 krb5_data_parse(&p->challenge, "hark!");
627 p->length = 10;
628 p->format = 2;
629 krb5_data_parse(&p->token_id, "yourtoken");
630 krb5_data_parse(&p->alg_id, "urn:ietf:params:xml:ns:keyprov:pskc:hotp");
631 p->supported_hash_alg = ealloc(3 * sizeof(*p->supported_hash_alg));
632 p->supported_hash_alg[0] = ealloc(sizeof(*p->supported_hash_alg[0]));
633 ktest_make_sha256_alg(p->supported_hash_alg[0]);
634 p->supported_hash_alg[1] = ealloc(sizeof(*p->supported_hash_alg[1]));
635 ktest_make_sha1_alg(p->supported_hash_alg[1]);
636 p->supported_hash_alg[2] = NULL;
637 p->iteration_count = 1000;
638 }
639
640 void
ktest_make_minimal_pa_otp_challenge(krb5_pa_otp_challenge * p)641 ktest_make_minimal_pa_otp_challenge(krb5_pa_otp_challenge *p)
642 {
643 memset(p, 0, sizeof(*p));
644 krb5_data_parse(&p->nonce, "minnonce");
645 p->tokeninfo = ealloc(2 * sizeof(*p->tokeninfo));
646 p->tokeninfo[0] = ealloc(sizeof(*p->tokeninfo[0]));
647 ktest_make_minimal_otp_tokeninfo(p->tokeninfo[0]);
648 p->tokeninfo[1] = NULL;
649 }
650
651 void
ktest_make_maximal_pa_otp_challenge(krb5_pa_otp_challenge * p)652 ktest_make_maximal_pa_otp_challenge(krb5_pa_otp_challenge *p)
653 {
654 krb5_data_parse(&p->nonce, "maxnonce");
655 krb5_data_parse(&p->service, "testservice");
656 p->tokeninfo = ealloc(3 * sizeof(*p->tokeninfo));
657 p->tokeninfo[0] = ealloc(sizeof(*p->tokeninfo[0]));
658 ktest_make_minimal_otp_tokeninfo(p->tokeninfo[0]);
659 p->tokeninfo[1] = ealloc(sizeof(*p->tokeninfo[1]));
660 ktest_make_maximal_otp_tokeninfo(p->tokeninfo[1]);
661 p->tokeninfo[2] = NULL;
662 krb5_data_parse(&p->salt, "keysalt");
663 krb5_data_parse(&p->s2kparams, "1234");
664 }
665
666 void
ktest_make_minimal_pa_otp_req(krb5_pa_otp_req * p)667 ktest_make_minimal_pa_otp_req(krb5_pa_otp_req *p)
668 {
669 memset(p, 0, sizeof(*p));
670 p->iteration_count = -1;
671 p->format = -1;
672 ktest_make_sample_enc_data(&p->enc_data);
673 }
674
675 void
ktest_make_maximal_pa_otp_req(krb5_pa_otp_req * p)676 ktest_make_maximal_pa_otp_req(krb5_pa_otp_req *p)
677 {
678 p->flags = KRB5_OTP_FLAG_NEXTOTP | KRB5_OTP_FLAG_COMBINE;
679 krb5_data_parse(&p->nonce, "nonce");
680 ktest_make_sample_enc_data(&p->enc_data);
681 p->hash_alg = ealloc(sizeof(*p->hash_alg));
682 ktest_make_sha256_alg(p->hash_alg);
683 p->iteration_count = 1000;
684 krb5_data_parse(&p->otp_value, "frogs");
685 krb5_data_parse(&p->pin, "myfirstpin");
686 krb5_data_parse(&p->challenge, "hark!");
687 p->time = SAMPLE_TIME;
688 krb5_data_parse(&p->counter, "346");
689 p->format = 2;
690 krb5_data_parse(&p->token_id, "yourtoken");
691 krb5_data_parse(&p->alg_id, "urn:ietf:params:xml:ns:keyprov:pskc:hotp");
692 krb5_data_parse(&p->vendor, "Examplecorp");
693 }
694
695 #ifndef DISABLE_PKINIT
696
697 static void
ktest_make_sample_pk_authenticator(krb5_pk_authenticator * p)698 ktest_make_sample_pk_authenticator(krb5_pk_authenticator *p)
699 {
700 p->cusec = SAMPLE_USEC;
701 p->ctime = SAMPLE_TIME;
702 p->nonce = SAMPLE_NONCE;
703 ktest_make_sample_data(&p->paChecksum);
704 p->freshnessToken = ealloc(sizeof(krb5_data));
705 ktest_make_sample_data(p->freshnessToken);
706 }
707
708 static void
ktest_make_sample_oid(krb5_data * p)709 ktest_make_sample_oid(krb5_data *p)
710 {
711 krb5_data_parse(p, "\052\206\110\206\367\022\001\002\002");
712 }
713
714 static void
ktest_make_sample_algorithm_identifier(krb5_algorithm_identifier * p)715 ktest_make_sample_algorithm_identifier(krb5_algorithm_identifier *p)
716 {
717 ktest_make_sample_oid(&p->algorithm);
718 /* Need a valid DER encoding here; this is the OCTET STRING "params". */
719 krb5_data_parse(&p->parameters, "\x04\x06" "params");
720 }
721
722 static void
ktest_make_sample_algorithm_identifier_no_params(krb5_algorithm_identifier * p)723 ktest_make_sample_algorithm_identifier_no_params(krb5_algorithm_identifier *p)
724 {
725 ktest_make_sample_oid(&p->algorithm);
726 p->parameters = empty_data();
727 }
728
729 static void
ktest_make_sample_external_principal_identifier(krb5_external_principal_identifier * p)730 ktest_make_sample_external_principal_identifier(
731 krb5_external_principal_identifier *p)
732 {
733 ktest_make_sample_data(&p->subjectName);
734 ktest_make_sample_data(&p->issuerAndSerialNumber);
735 ktest_make_sample_data(&p->subjectKeyIdentifier);
736 }
737
738 void
ktest_make_sample_pa_pk_as_req(krb5_pa_pk_as_req * p)739 ktest_make_sample_pa_pk_as_req(krb5_pa_pk_as_req *p)
740 {
741 ktest_make_sample_data(&p->signedAuthPack);
742 p->trustedCertifiers =
743 ealloc(2 * sizeof(krb5_external_principal_identifier *));
744 p->trustedCertifiers[0] =
745 ealloc(sizeof(krb5_external_principal_identifier));
746 ktest_make_sample_external_principal_identifier(p->trustedCertifiers[0]);
747 p->trustedCertifiers[1] = NULL;
748 ktest_make_sample_data(&p->kdcPkId);
749 }
750
751 static void
ktest_make_sample_dh_rep_info(krb5_dh_rep_info * p)752 ktest_make_sample_dh_rep_info(krb5_dh_rep_info *p)
753 {
754 ktest_make_sample_data(&p->dhSignedData);
755 ktest_make_sample_data(&p->serverDHNonce);
756 p->kdfID = ealloc(sizeof(krb5_data));
757 ktest_make_sample_data(p->kdfID);
758 }
759
760 void
ktest_make_sample_pa_pk_as_rep_dhInfo(krb5_pa_pk_as_rep * p)761 ktest_make_sample_pa_pk_as_rep_dhInfo(krb5_pa_pk_as_rep *p)
762 {
763 p->choice = choice_pa_pk_as_rep_dhInfo;
764 ktest_make_sample_dh_rep_info(&p->u.dh_Info);
765 }
766
767 void
ktest_make_sample_pa_pk_as_rep_encKeyPack(krb5_pa_pk_as_rep * p)768 ktest_make_sample_pa_pk_as_rep_encKeyPack(krb5_pa_pk_as_rep *p)
769 {
770 p->choice = choice_pa_pk_as_rep_encKeyPack;
771 ktest_make_sample_data(&p->u.encKeyPack);
772 }
773
774 void
ktest_make_sample_auth_pack(krb5_auth_pack * p)775 ktest_make_sample_auth_pack(krb5_auth_pack *p)
776 {
777 ktest_make_sample_pk_authenticator(&p->pkAuthenticator);
778 /* Need a valid DER encoding here; this is the OCTET STRING "pvalue". */
779 krb5_data_parse(&p->clientPublicValue, "\x04\x06" "pvalue");
780 p->supportedCMSTypes = ealloc(3 * sizeof(krb5_algorithm_identifier *));
781 p->supportedCMSTypes[0] = ealloc(sizeof(krb5_algorithm_identifier));
782 ktest_make_sample_algorithm_identifier(p->supportedCMSTypes[0]);
783 p->supportedCMSTypes[1] = ealloc(sizeof(krb5_algorithm_identifier));
784 ktest_make_sample_algorithm_identifier_no_params(p->supportedCMSTypes[1]);
785 p->supportedCMSTypes[2] = NULL;
786 ktest_make_sample_data(&p->clientDHNonce);
787 p->supportedKDFs = ealloc(2 * sizeof(krb5_data *));
788 p->supportedKDFs[0] = ealloc(sizeof(krb5_data));
789 ktest_make_sample_data(p->supportedKDFs[0]);
790 p->supportedKDFs[1] = NULL;
791 }
792
793 void
ktest_make_sample_kdc_dh_key_info(krb5_kdc_dh_key_info * p)794 ktest_make_sample_kdc_dh_key_info(krb5_kdc_dh_key_info *p)
795 {
796 ktest_make_sample_data(&p->subjectPublicKey);
797 p->nonce = SAMPLE_NONCE;
798 p->dhKeyExpiration = SAMPLE_TIME;
799 }
800
801 void
ktest_make_sample_reply_key_pack(krb5_reply_key_pack * p)802 ktest_make_sample_reply_key_pack(krb5_reply_key_pack *p)
803 {
804 ktest_make_sample_keyblock(&p->replyKey);
805 ktest_make_sample_checksum(&p->asChecksum);
806 }
807
808 void
ktest_make_sample_sp80056a_other_info(krb5_sp80056a_other_info * p)809 ktest_make_sample_sp80056a_other_info(krb5_sp80056a_other_info *p)
810 {
811 ktest_make_sample_algorithm_identifier_no_params(&p->algorithm_identifier);
812 ktest_make_sample_principal(&p->party_u_info);
813 ktest_make_sample_principal(&p->party_v_info);
814 ktest_make_sample_data(&p->supp_pub_info);
815 }
816
817 void
ktest_make_sample_pkinit_supp_pub_info(krb5_pkinit_supp_pub_info * p)818 ktest_make_sample_pkinit_supp_pub_info(krb5_pkinit_supp_pub_info *p)
819 {
820 p->enctype = ENCTYPE_AES256_CTS_HMAC_SHA384_192;
821 ktest_make_sample_data(&p->as_req);
822 ktest_make_sample_data(&p->pk_as_rep);
823 }
824
825 #endif /* not DISABLE_PKINIT */
826
827 #ifdef ENABLE_LDAP
828 static void
ktest_make_sample_key_data(krb5_key_data * p,int i)829 ktest_make_sample_key_data(krb5_key_data *p, int i)
830 {
831 char *str;
832 int len;
833
834 len = asprintf(&str, "key%d", i);
835 if (len < 0)
836 abort();
837 p->key_data_ver = 2;
838 p->key_data_type[0] = 2;
839 p->key_data_length[0] = (unsigned int) len;
840 p->key_data_contents[0] = (krb5_octet *)str;
841 len = asprintf(&str, "salt%d", i);
842 if (len < 0)
843 abort();
844 p->key_data_type[1] = i;
845 p->key_data_length[1] = (unsigned int) len;
846 p->key_data_contents[1] = (krb5_octet *)str;
847 }
848
849 void
ktest_make_sample_ldap_seqof_key_data(ldap_seqof_key_data * p)850 ktest_make_sample_ldap_seqof_key_data(ldap_seqof_key_data *p)
851 {
852 int i;
853
854 p->mkvno = 14;
855 p->n_key_data = 3;
856 p->key_data = calloc(3,sizeof(krb5_key_data));
857 p->kvno = 42;
858 for (i = 0; i < 3; i++)
859 ktest_make_sample_key_data(&p->key_data[i], i);
860 }
861 #endif
862
863 void
ktest_make_sample_kkdcp_message(krb5_kkdcp_message * p)864 ktest_make_sample_kkdcp_message(krb5_kkdcp_message *p)
865 {
866 krb5_kdc_req req;
867 krb5_data *message;
868
869 ktest_make_sample_kdc_req(&req);
870 req.msg_type = KRB5_AS_REQ;
871 encode_krb5_as_req(&req, &message);
872 p->kerb_message = *message;
873 free(message);
874 ktest_empty_kdc_req(&req);
875 ktest_make_sample_data(&(p->target_domain));
876 p->dclocator_hint = 0;
877 }
878
879 static krb5_authdata *
make_ad_element(krb5_authdatatype ad_type,const char * str)880 make_ad_element(krb5_authdatatype ad_type, const char *str)
881 {
882 krb5_authdata *ad;
883
884 ad = ealloc(sizeof(*ad));
885 ad->ad_type = ad_type;
886 ad->length = strlen(str);
887 ad->contents = ealloc(ad->length);
888 memcpy(ad->contents, str, ad->length);
889 return ad;
890 }
891
892 static krb5_verifier_mac *
make_vmac(krb5_boolean include_princ,krb5_kvno kvno,krb5_enctype enctype,const char * cksumstr)893 make_vmac(krb5_boolean include_princ, krb5_kvno kvno, krb5_enctype enctype,
894 const char *cksumstr)
895 {
896 krb5_verifier_mac *vmac;
897
898 vmac = ealloc(sizeof(*vmac));
899 if (include_princ) {
900 ktest_make_sample_principal(&vmac->princ);
901 (void)krb5_set_principal_realm(NULL, vmac->princ, "");
902 } else {
903 vmac->princ = NULL;
904 }
905 vmac->kvno = kvno;
906 vmac->enctype = enctype;
907 vmac->checksum.checksum_type = 1;
908 vmac->checksum.length = strlen(cksumstr);
909 vmac->checksum.contents = ealloc(vmac->checksum.length);
910 memcpy(vmac->checksum.contents, cksumstr, vmac->checksum.length);
911 return vmac;
912 }
913
914 void
ktest_make_minimal_cammac(krb5_cammac * p)915 ktest_make_minimal_cammac(krb5_cammac *p)
916 {
917 memset(p, 0, sizeof(*p));
918 p->elements = ealloc(2 * sizeof(*p->elements));
919 p->elements[0] = make_ad_element(1, "ad1");
920 p->elements[1] = NULL;
921 }
922
923 void
ktest_make_maximal_cammac(krb5_cammac * p)924 ktest_make_maximal_cammac(krb5_cammac *p)
925 {
926 p->elements = ealloc(3 * sizeof(*p->elements));
927 p->elements[0] = make_ad_element(1, "ad1");
928 p->elements[1] = make_ad_element(2, "ad2");
929 p->elements[2] = NULL;
930 p->kdc_verifier = make_vmac(TRUE, 5, 16, "cksumkdc");
931 p->svc_verifier = make_vmac(TRUE, 5, 16, "cksumsvc");
932 p->other_verifiers = ealloc(3 * sizeof(*p->other_verifiers));
933 p->other_verifiers[0] = make_vmac(FALSE, 0, 0, "cksum1");
934 p->other_verifiers[1] = make_vmac(TRUE, 5, 16, "cksum2");
935 p->other_verifiers[2] = NULL;
936 }
937
938 void
ktest_make_sample_secure_cookie(krb5_secure_cookie * p)939 ktest_make_sample_secure_cookie(krb5_secure_cookie *p)
940 {
941 ktest_make_sample_pa_data_array(&p->data);
942 p->time = SAMPLE_TIME;
943 }
944
945 void
ktest_make_minimal_spake_factor(krb5_spake_factor * p)946 ktest_make_minimal_spake_factor(krb5_spake_factor *p)
947 {
948 p->type = 1;
949 p->data = NULL;
950 }
951
952 void
ktest_make_maximal_spake_factor(krb5_spake_factor * p)953 ktest_make_maximal_spake_factor(krb5_spake_factor *p)
954 {
955 p->type = 2;
956 p->data = ealloc(sizeof(*p->data));
957 krb5_data_parse(p->data, "fdata");
958 }
959
960 void
ktest_make_support_pa_spake(krb5_pa_spake * p)961 ktest_make_support_pa_spake(krb5_pa_spake *p)
962 {
963 krb5_spake_support *s = &p->u.support;
964
965 s->ngroups = 2;
966 s->groups = ealloc(s->ngroups * sizeof(*s->groups));
967 s->groups[0] = 1;
968 s->groups[1] = 2;
969 p->choice = SPAKE_MSGTYPE_SUPPORT;
970 }
971
972 void
ktest_make_challenge_pa_spake(krb5_pa_spake * p)973 ktest_make_challenge_pa_spake(krb5_pa_spake *p)
974 {
975 krb5_spake_challenge *c = &p->u.challenge;
976
977 c->group = 1;
978 krb5_data_parse(&c->pubkey, "T value");
979 c->factors = ealloc(3 * sizeof(*c->factors));
980 c->factors[0] = ealloc(sizeof(*c->factors[0]));
981 ktest_make_minimal_spake_factor(c->factors[0]);
982 c->factors[1] = ealloc(sizeof(*c->factors[1]));
983 ktest_make_maximal_spake_factor(c->factors[1]);
984 c->factors[2] = NULL;
985 p->choice = SPAKE_MSGTYPE_CHALLENGE;
986 }
987
988 void
ktest_make_response_pa_spake(krb5_pa_spake * p)989 ktest_make_response_pa_spake(krb5_pa_spake *p)
990 {
991 krb5_spake_response *r = &p->u.response;
992
993 krb5_data_parse(&r->pubkey, "S value");
994 ktest_make_sample_enc_data(&r->factor);
995 p->choice = SPAKE_MSGTYPE_RESPONSE;
996 }
997
998 void
ktest_make_encdata_pa_spake(krb5_pa_spake * p)999 ktest_make_encdata_pa_spake(krb5_pa_spake *p)
1000 {
1001 ktest_make_sample_enc_data(&p->u.encdata);
1002 p->choice = SPAKE_MSGTYPE_ENCDATA;
1003 }
1004
1005 /****************************************************************/
1006 /* destructors */
1007
1008 void
ktest_destroy_data(krb5_data ** d)1009 ktest_destroy_data(krb5_data **d)
1010 {
1011 if (*d != NULL) {
1012 free((*d)->data);
1013 free(*d);
1014 *d = NULL;
1015 }
1016 }
1017
1018 void
ktest_empty_data(krb5_data * d)1019 ktest_empty_data(krb5_data *d)
1020 {
1021 if (d->data != NULL) {
1022 free(d->data);
1023 d->data = NULL;
1024 d->length = 0;
1025 }
1026 }
1027
1028 static void
ktest_empty_checksum(krb5_checksum * cs)1029 ktest_empty_checksum(krb5_checksum *cs)
1030 {
1031 free(cs->contents);
1032 cs->contents = NULL;
1033 }
1034
1035 void
ktest_destroy_checksum(krb5_checksum ** cs)1036 ktest_destroy_checksum(krb5_checksum **cs)
1037 {
1038 if (*cs != NULL) {
1039 free((*cs)->contents);
1040 free(*cs);
1041 *cs = NULL;
1042 }
1043 }
1044
1045 void
ktest_empty_keyblock(krb5_keyblock * kb)1046 ktest_empty_keyblock(krb5_keyblock *kb)
1047 {
1048 if (kb != NULL) {
1049 if (kb->contents) {
1050 free(kb->contents);
1051 kb->contents = NULL;
1052 }
1053 }
1054 }
1055
1056 void
ktest_destroy_keyblock(krb5_keyblock ** kb)1057 ktest_destroy_keyblock(krb5_keyblock **kb)
1058 {
1059 if (*kb != NULL) {
1060 free((*kb)->contents);
1061 free(*kb);
1062 *kb = NULL;
1063 }
1064 }
1065
1066 void
ktest_empty_authorization_data(krb5_authdata ** ad)1067 ktest_empty_authorization_data(krb5_authdata **ad)
1068 {
1069 size_t i;
1070
1071 if (*ad != NULL) {
1072 for (i=0; ad[i] != NULL; i++)
1073 ktest_destroy_authdata(&ad[i]);
1074 }
1075 }
1076
1077 void
ktest_destroy_authorization_data(krb5_authdata *** ad)1078 ktest_destroy_authorization_data(krb5_authdata ***ad)
1079 {
1080 ktest_empty_authorization_data(*ad);
1081 free(*ad);
1082 *ad = NULL;
1083 }
1084
1085 void
ktest_destroy_authdata(krb5_authdata ** ad)1086 ktest_destroy_authdata(krb5_authdata **ad)
1087 {
1088 if (*ad != NULL) {
1089 free((*ad)->contents);
1090 free(*ad);
1091 *ad = NULL;
1092 }
1093 }
1094
1095 void
ktest_empty_pa_data_array(krb5_pa_data ** pad)1096 ktest_empty_pa_data_array(krb5_pa_data **pad)
1097 {
1098 size_t i;
1099
1100 for (i=0; pad[i] != NULL; i++)
1101 ktest_destroy_pa_data(&pad[i]);
1102 }
1103
1104 void
ktest_destroy_pa_data_array(krb5_pa_data *** pad)1105 ktest_destroy_pa_data_array(krb5_pa_data ***pad)
1106 {
1107 ktest_empty_pa_data_array(*pad);
1108 free(*pad);
1109 *pad = NULL;
1110 }
1111
1112 void
ktest_destroy_pa_data(krb5_pa_data ** pad)1113 ktest_destroy_pa_data(krb5_pa_data **pad)
1114 {
1115 if (*pad != NULL) {
1116 free((*pad)->contents);
1117 free(*pad);
1118 *pad = NULL;
1119 }
1120 }
1121
1122 void
ktest_destroy_address(krb5_address ** a)1123 ktest_destroy_address(krb5_address **a)
1124 {
1125 if (*a != NULL) {
1126 free((*a)->contents);
1127 free(*a);
1128 *a = NULL;
1129 }
1130 }
1131
1132 void
ktest_empty_addresses(krb5_address ** a)1133 ktest_empty_addresses(krb5_address **a)
1134 {
1135 size_t i;
1136
1137 for (i=0; a[i] != NULL; i++)
1138 ktest_destroy_address(&a[i]);
1139 }
1140
1141 void
ktest_destroy_addresses(krb5_address *** a)1142 ktest_destroy_addresses(krb5_address ***a)
1143 {
1144 ktest_empty_addresses(*a);
1145 free(*a);
1146 *a = NULL;
1147 }
1148
1149 void
ktest_destroy_principal(krb5_principal * p)1150 ktest_destroy_principal(krb5_principal *p)
1151 {
1152 int i;
1153
1154 if (*p == NULL)
1155 return;
1156 for (i=0; i<(*p)->length; i++)
1157 ktest_empty_data(&(*p)->data[i]);
1158 ktest_empty_data(&(*p)->realm);
1159 free((*p)->data);
1160 free(*p);
1161 *p = NULL;
1162 }
1163
1164 void
ktest_destroy_sequence_of_integer(long ** soi)1165 ktest_destroy_sequence_of_integer(long **soi)
1166 {
1167 free(*soi);
1168 *soi = NULL;
1169 }
1170
1171 void
ktest_destroy_sequence_of_ticket(krb5_ticket *** sot)1172 ktest_destroy_sequence_of_ticket(krb5_ticket ***sot)
1173 {
1174 size_t i;
1175
1176 for (i=0; (*sot)[i] != NULL; i++)
1177 ktest_destroy_ticket(&(*sot)[i]);
1178 free(*sot);
1179 *sot = NULL;
1180 }
1181
1182 void
ktest_destroy_ticket(krb5_ticket ** tkt)1183 ktest_destroy_ticket(krb5_ticket **tkt)
1184 {
1185 ktest_destroy_principal(&(*tkt)->server);
1186 ktest_destroy_enc_data(&(*tkt)->enc_part);
1187 /* ktest_empty_enc_tkt_part(((*tkt)->enc_part2));*/
1188 free(*tkt);
1189 *tkt = NULL;
1190 }
1191
1192 void
ktest_empty_ticket(krb5_ticket * tkt)1193 ktest_empty_ticket(krb5_ticket *tkt)
1194 {
1195 if (tkt->server)
1196 ktest_destroy_principal(&tkt->server);
1197 ktest_destroy_enc_data(&tkt->enc_part);
1198 if (tkt->enc_part2)
1199 ktest_destroy_enc_tkt_part(&tkt->enc_part2);
1200 }
1201
1202 void
ktest_destroy_enc_data(krb5_enc_data * ed)1203 ktest_destroy_enc_data(krb5_enc_data *ed)
1204 {
1205 ktest_empty_data(&ed->ciphertext);
1206 ed->kvno = 0;
1207 }
1208
1209 void
ktest_destroy_etype_info_entry(krb5_etype_info_entry * i)1210 ktest_destroy_etype_info_entry(krb5_etype_info_entry *i)
1211 {
1212 if (i->salt)
1213 free(i->salt);
1214 ktest_empty_data(&i->s2kparams);
1215 free(i);
1216 }
1217
1218 void
ktest_destroy_etype_info(krb5_etype_info_entry ** info)1219 ktest_destroy_etype_info(krb5_etype_info_entry **info)
1220 {
1221 size_t i;
1222
1223 for (i = 0; info[i] != NULL; i++)
1224 ktest_destroy_etype_info_entry(info[i]);
1225 free(info);
1226 }
1227
1228 void
ktest_empty_kdc_req(krb5_kdc_req * kr)1229 ktest_empty_kdc_req(krb5_kdc_req *kr)
1230 {
1231 if (kr->padata)
1232 ktest_destroy_pa_data_array(&kr->padata);
1233
1234 if (kr->client)
1235 ktest_destroy_principal(&kr->client);
1236
1237 if (kr->server)
1238 ktest_destroy_principal(&kr->server);
1239 free(kr->ktype);
1240 if (kr->addresses)
1241 ktest_destroy_addresses(&kr->addresses);
1242 ktest_destroy_enc_data(&kr->authorization_data);
1243 if (kr->unenc_authdata)
1244 ktest_destroy_authorization_data(&kr->unenc_authdata);
1245 if (kr->second_ticket)
1246 ktest_destroy_sequence_of_ticket(&kr->second_ticket);
1247
1248 }
1249
1250 void
ktest_empty_kdc_rep(krb5_kdc_rep * kr)1251 ktest_empty_kdc_rep(krb5_kdc_rep *kr)
1252 {
1253 if (kr->padata)
1254 ktest_destroy_pa_data_array(&kr->padata);
1255
1256 if (kr->client)
1257 ktest_destroy_principal(&kr->client);
1258
1259 if (kr->ticket)
1260 ktest_destroy_ticket(&kr->ticket);
1261
1262 ktest_destroy_enc_data(&kr->enc_part);
1263
1264 if (kr->enc_part2) {
1265 ktest_empty_enc_kdc_rep_part(kr->enc_part2);
1266 free(kr->enc_part2);
1267 kr->enc_part2 = NULL;
1268 }
1269 }
1270
1271 void
ktest_empty_authenticator(krb5_authenticator * a)1272 ktest_empty_authenticator(krb5_authenticator *a)
1273 {
1274 if (a->client)
1275 ktest_destroy_principal(&a->client);
1276 if (a->checksum)
1277 ktest_destroy_checksum(&a->checksum);
1278 if (a->subkey)
1279 ktest_destroy_keyblock(&a->subkey);
1280 if (a->authorization_data)
1281 ktest_destroy_authorization_data(&a->authorization_data);
1282 }
1283
1284 void
ktest_empty_enc_tkt_part(krb5_enc_tkt_part * etp)1285 ktest_empty_enc_tkt_part(krb5_enc_tkt_part *etp)
1286 {
1287 if (etp->session)
1288 ktest_destroy_keyblock(&etp->session);
1289 if (etp->client)
1290 ktest_destroy_principal(&etp->client);
1291 if (etp->caddrs)
1292 ktest_destroy_addresses(&etp->caddrs);
1293 if (etp->authorization_data)
1294 ktest_destroy_authorization_data(&etp->authorization_data);
1295 ktest_destroy_transited(&etp->transited);
1296 }
1297
1298 void
ktest_destroy_enc_tkt_part(krb5_enc_tkt_part ** etp)1299 ktest_destroy_enc_tkt_part(krb5_enc_tkt_part **etp)
1300 {
1301 if (*etp) {
1302 ktest_empty_enc_tkt_part(*etp);
1303 free(*etp);
1304 *etp = NULL;
1305 }
1306 }
1307
1308 void
ktest_empty_enc_kdc_rep_part(krb5_enc_kdc_rep_part * ekr)1309 ktest_empty_enc_kdc_rep_part(krb5_enc_kdc_rep_part *ekr)
1310 {
1311 if (ekr->session)
1312 ktest_destroy_keyblock(&ekr->session);
1313
1314 if (ekr->server)
1315 ktest_destroy_principal(&ekr->server);
1316
1317 if (ekr->caddrs)
1318 ktest_destroy_addresses(&ekr->caddrs);
1319 ktest_destroy_last_req(&ekr->last_req);
1320 }
1321
1322 void
ktest_destroy_transited(krb5_transited * t)1323 ktest_destroy_transited(krb5_transited *t)
1324 {
1325 if (t->tr_contents.data)
1326 ktest_empty_data(&t->tr_contents);
1327 }
1328
1329 void
ktest_empty_ap_rep(krb5_ap_rep * ar)1330 ktest_empty_ap_rep(krb5_ap_rep *ar)
1331 {
1332 ktest_destroy_enc_data(&ar->enc_part);
1333 }
1334
1335 void
ktest_empty_ap_req(krb5_ap_req * ar)1336 ktest_empty_ap_req(krb5_ap_req *ar)
1337 {
1338 if (ar->ticket)
1339 ktest_destroy_ticket(&ar->ticket);
1340 ktest_destroy_enc_data(&ar->authenticator);
1341 }
1342
1343 void
ktest_empty_cred_enc_part(krb5_cred_enc_part * cep)1344 ktest_empty_cred_enc_part(krb5_cred_enc_part *cep)
1345 {
1346 if (cep->s_address)
1347 ktest_destroy_address(&cep->s_address);
1348 if (cep->r_address)
1349 ktest_destroy_address(&cep->r_address);
1350 if (cep->ticket_info)
1351 ktest_destroy_sequence_of_cred_info(&cep->ticket_info);
1352 }
1353
1354 void
ktest_destroy_cred_info(krb5_cred_info ** ci)1355 ktest_destroy_cred_info(krb5_cred_info **ci)
1356 {
1357 if ((*ci)->session)
1358 ktest_destroy_keyblock(&(*ci)->session);
1359 if ((*ci)->client)
1360 ktest_destroy_principal(&(*ci)->client);
1361 if ((*ci)->server)
1362 ktest_destroy_principal(&(*ci)->server);
1363 if ((*ci)->caddrs)
1364 ktest_destroy_addresses(&(*ci)->caddrs);
1365 free(*ci);
1366 *ci = NULL;
1367 }
1368
1369 void
ktest_destroy_sequence_of_cred_info(krb5_cred_info *** soci)1370 ktest_destroy_sequence_of_cred_info(krb5_cred_info ***soci)
1371 {
1372 size_t i;
1373
1374 for (i = 0; (*soci)[i] != NULL; i++)
1375 ktest_destroy_cred_info(&(*soci)[i]);
1376 free(*soci);
1377 *soci = NULL;
1378 }
1379
1380 void
ktest_empty_safe(krb5_safe * s)1381 ktest_empty_safe(krb5_safe *s)
1382 {
1383 ktest_empty_data(&s->user_data);
1384 ktest_destroy_address(&s->s_address);
1385 ktest_destroy_address(&s->r_address);
1386 ktest_destroy_checksum(&s->checksum);
1387 }
1388
1389 void
ktest_empty_priv_enc_part(krb5_priv_enc_part * pep)1390 ktest_empty_priv_enc_part(krb5_priv_enc_part *pep)
1391 {
1392 ktest_empty_data(&pep->user_data);
1393 ktest_destroy_address(&pep->s_address);
1394 ktest_destroy_address(&pep->r_address);
1395 }
1396
1397 void
ktest_empty_priv(krb5_priv * p)1398 ktest_empty_priv(krb5_priv *p)
1399 {
1400 ktest_destroy_enc_data(&p->enc_part);
1401 }
1402
1403 void
ktest_empty_cred(krb5_cred * c)1404 ktest_empty_cred(krb5_cred *c)
1405 {
1406 ktest_destroy_sequence_of_ticket(&c->tickets);
1407 ktest_destroy_enc_data(&c->enc_part);
1408 /* enc_part2 */
1409 }
1410
1411 void
ktest_destroy_last_req(krb5_last_req_entry *** lr)1412 ktest_destroy_last_req(krb5_last_req_entry ***lr)
1413 {
1414 size_t i;
1415
1416 if (*lr) {
1417 for (i=0; (*lr)[i] != NULL; i++)
1418 free((*lr)[i]);
1419
1420 free(*lr);
1421 }
1422 }
1423
1424 void
ktest_empty_error(krb5_error * kerr)1425 ktest_empty_error(krb5_error *kerr)
1426 {
1427 if (kerr->client)
1428 ktest_destroy_principal(&kerr->client);
1429 if (kerr->server)
1430 ktest_destroy_principal(&kerr->server);
1431 ktest_empty_data(&kerr->text);
1432 ktest_empty_data(&kerr->e_data);
1433 }
1434
1435 void
ktest_empty_ap_rep_enc_part(krb5_ap_rep_enc_part * arep)1436 ktest_empty_ap_rep_enc_part(krb5_ap_rep_enc_part *arep)
1437 {
1438 ktest_destroy_keyblock(&(arep)->subkey);
1439 }
1440
1441 void
ktest_empty_sam_challenge_2(krb5_sam_challenge_2 * p)1442 ktest_empty_sam_challenge_2(krb5_sam_challenge_2 *p)
1443 {
1444 krb5_checksum **ck;
1445
1446 ktest_empty_data(&p->sam_challenge_2_body);
1447 if (p->sam_cksum != NULL) {
1448 for (ck = p->sam_cksum; *ck != NULL; ck++)
1449 ktest_destroy_checksum(ck);
1450 free(p->sam_cksum);
1451 p->sam_cksum = NULL;
1452 }
1453 }
1454
1455 void
ktest_empty_sam_challenge_2_body(krb5_sam_challenge_2_body * p)1456 ktest_empty_sam_challenge_2_body(krb5_sam_challenge_2_body *p)
1457 {
1458 ktest_empty_data(&p->sam_type_name);
1459 ktest_empty_data(&p->sam_track_id);
1460 ktest_empty_data(&p->sam_challenge_label);
1461 ktest_empty_data(&p->sam_challenge);
1462 ktest_empty_data(&p->sam_response_prompt);
1463 ktest_empty_data(&p->sam_pk_for_sad);
1464 }
1465
1466 void
ktest_empty_sam_response_2(krb5_sam_response_2 * p)1467 ktest_empty_sam_response_2(krb5_sam_response_2 *p)
1468 {
1469 ktest_empty_data(&p->sam_track_id);
1470 ktest_empty_data(&p->sam_enc_nonce_or_sad.ciphertext);
1471 }
1472
1473 void
ktest_empty_enc_sam_response_enc_2(krb5_enc_sam_response_enc_2 * p)1474 ktest_empty_enc_sam_response_enc_2(krb5_enc_sam_response_enc_2 *p)
1475 {
1476 ktest_empty_data(&p->sam_sad);
1477 }
1478
1479 void
ktest_empty_pa_for_user(krb5_pa_for_user * p)1480 ktest_empty_pa_for_user(krb5_pa_for_user *p)
1481 {
1482 ktest_destroy_principal(&p->user);
1483 ktest_empty_checksum(&p->cksum);
1484 ktest_empty_data(&p->auth_package);
1485 }
1486
1487 void
ktest_empty_pa_s4u_x509_user(krb5_pa_s4u_x509_user * p)1488 ktest_empty_pa_s4u_x509_user(krb5_pa_s4u_x509_user *p)
1489 {
1490 ktest_destroy_principal(&p->user_id.user);
1491 ktest_empty_data(&p->user_id.subject_cert);
1492 free(p->cksum.contents);
1493 }
1494
1495 void
ktest_empty_ad_kdcissued(krb5_ad_kdcissued * p)1496 ktest_empty_ad_kdcissued(krb5_ad_kdcissued *p)
1497 {
1498 free(p->ad_checksum.contents);
1499 ktest_destroy_principal(&p->i_principal);
1500 ktest_destroy_authorization_data(&p->elements);
1501 }
1502
1503 void
ktest_empty_iakerb_header(krb5_iakerb_header * p)1504 ktest_empty_iakerb_header(krb5_iakerb_header *p)
1505 {
1506 krb5_free_data_contents(NULL, &p->target_realm);
1507 krb5_free_data(NULL, p->cookie);
1508 }
1509
1510 void
ktest_empty_iakerb_finished(krb5_iakerb_finished * p)1511 ktest_empty_iakerb_finished(krb5_iakerb_finished *p)
1512 {
1513 krb5_free_checksum_contents(NULL, &p->checksum);
1514 }
1515
1516 static void
ktest_empty_fast_finished(krb5_fast_finished * p)1517 ktest_empty_fast_finished(krb5_fast_finished *p)
1518 {
1519 ktest_destroy_principal(&p->client);
1520 ktest_empty_checksum(&p->ticket_checksum);
1521 }
1522
1523 void
ktest_empty_fast_response(krb5_fast_response * p)1524 ktest_empty_fast_response(krb5_fast_response *p)
1525 {
1526 ktest_destroy_pa_data_array(&p->padata);
1527 ktest_destroy_keyblock(&p->strengthen_key);
1528 if (p->finished != NULL) {
1529 ktest_empty_fast_finished(p->finished);
1530 free(p->finished);
1531 p->finished = NULL;
1532 }
1533 }
1534
1535 static void
ktest_empty_algorithm_identifier(krb5_algorithm_identifier * p)1536 ktest_empty_algorithm_identifier(krb5_algorithm_identifier *p)
1537 {
1538 ktest_empty_data(&p->algorithm);
1539 ktest_empty_data(&p->parameters);
1540 }
1541
1542 void
ktest_empty_otp_tokeninfo(krb5_otp_tokeninfo * p)1543 ktest_empty_otp_tokeninfo(krb5_otp_tokeninfo *p)
1544 {
1545 krb5_algorithm_identifier **alg;
1546
1547 p->flags = 0;
1548 krb5_free_data_contents(NULL, &p->vendor);
1549 krb5_free_data_contents(NULL, &p->challenge);
1550 krb5_free_data_contents(NULL, &p->token_id);
1551 krb5_free_data_contents(NULL, &p->alg_id);
1552 for (alg = p->supported_hash_alg; alg != NULL && *alg != NULL; alg++) {
1553 ktest_empty_algorithm_identifier(*alg);
1554 free(*alg);
1555 }
1556 free(p->supported_hash_alg);
1557 p->supported_hash_alg = NULL;
1558 p->length = p->format = p->iteration_count = -1;
1559 }
1560
1561 void
ktest_empty_pa_otp_challenge(krb5_pa_otp_challenge * p)1562 ktest_empty_pa_otp_challenge(krb5_pa_otp_challenge *p)
1563 {
1564 krb5_otp_tokeninfo **ti;
1565
1566 krb5_free_data_contents(NULL, &p->nonce);
1567 krb5_free_data_contents(NULL, &p->service);
1568 for (ti = p->tokeninfo; *ti != NULL; ti++) {
1569 ktest_empty_otp_tokeninfo(*ti);
1570 free(*ti);
1571 }
1572 free(p->tokeninfo);
1573 p->tokeninfo = NULL;
1574 krb5_free_data_contents(NULL, &p->salt);
1575 krb5_free_data_contents(NULL, &p->s2kparams);
1576 }
1577
1578 void
ktest_empty_pa_otp_req(krb5_pa_otp_req * p)1579 ktest_empty_pa_otp_req(krb5_pa_otp_req *p)
1580 {
1581 p->flags = 0;
1582 krb5_free_data_contents(NULL, &p->nonce);
1583 ktest_destroy_enc_data(&p->enc_data);
1584 if (p->hash_alg != NULL)
1585 ktest_empty_algorithm_identifier(p->hash_alg);
1586 free(p->hash_alg);
1587 p->hash_alg = NULL;
1588 p->iteration_count = -1;
1589 krb5_free_data_contents(NULL, &p->otp_value);
1590 krb5_free_data_contents(NULL, &p->pin);
1591 krb5_free_data_contents(NULL, &p->challenge);
1592 p->time = 0;
1593 krb5_free_data_contents(NULL, &p->counter);
1594 p->format = -1;
1595 krb5_free_data_contents(NULL, &p->token_id);
1596 krb5_free_data_contents(NULL, &p->alg_id);
1597 krb5_free_data_contents(NULL, &p->vendor);
1598 }
1599
1600 #ifndef DISABLE_PKINIT
1601
1602 static void
ktest_empty_pk_authenticator(krb5_pk_authenticator * p)1603 ktest_empty_pk_authenticator(krb5_pk_authenticator *p)
1604 {
1605 ktest_empty_data(&p->paChecksum);
1606 krb5_free_data(NULL, p->freshnessToken);
1607 p->freshnessToken = NULL;
1608 }
1609
1610 static void
ktest_empty_external_principal_identifier(krb5_external_principal_identifier * p)1611 ktest_empty_external_principal_identifier(
1612 krb5_external_principal_identifier *p)
1613 {
1614 ktest_empty_data(&p->subjectName);
1615 ktest_empty_data(&p->issuerAndSerialNumber);
1616 ktest_empty_data(&p->subjectKeyIdentifier);
1617 }
1618
1619 void
ktest_empty_pa_pk_as_req(krb5_pa_pk_as_req * p)1620 ktest_empty_pa_pk_as_req(krb5_pa_pk_as_req *p)
1621 {
1622 krb5_external_principal_identifier **pi;
1623
1624 ktest_empty_data(&p->signedAuthPack);
1625 for (pi = p->trustedCertifiers; *pi != NULL; pi++) {
1626 ktest_empty_external_principal_identifier(*pi);
1627 free(*pi);
1628 }
1629 free(p->trustedCertifiers);
1630 p->trustedCertifiers = NULL;
1631 ktest_empty_data(&p->kdcPkId);
1632 }
1633
1634 static void
ktest_empty_dh_rep_info(krb5_dh_rep_info * p)1635 ktest_empty_dh_rep_info(krb5_dh_rep_info *p)
1636 {
1637 ktest_empty_data(&p->dhSignedData);
1638 ktest_empty_data(&p->serverDHNonce);
1639 ktest_destroy_data(&p->kdfID);
1640 }
1641
1642 void
ktest_empty_pa_pk_as_rep(krb5_pa_pk_as_rep * p)1643 ktest_empty_pa_pk_as_rep(krb5_pa_pk_as_rep *p)
1644 {
1645 if (p->choice == choice_pa_pk_as_rep_dhInfo)
1646 ktest_empty_dh_rep_info(&p->u.dh_Info);
1647 else if (p->choice == choice_pa_pk_as_rep_encKeyPack)
1648 ktest_empty_data(&p->u.encKeyPack);
1649 p->choice = choice_pa_pk_as_rep_UNKNOWN;
1650 }
1651
1652 void
ktest_empty_auth_pack(krb5_auth_pack * p)1653 ktest_empty_auth_pack(krb5_auth_pack *p)
1654 {
1655 krb5_algorithm_identifier **ai;
1656 krb5_data **d;
1657
1658 ktest_empty_pk_authenticator(&p->pkAuthenticator);
1659 ktest_empty_data(&p->clientPublicValue);
1660 if (p->supportedCMSTypes != NULL) {
1661 for (ai = p->supportedCMSTypes; *ai != NULL; ai++) {
1662 ktest_empty_algorithm_identifier(*ai);
1663 free(*ai);
1664 }
1665 free(p->supportedCMSTypes);
1666 p->supportedCMSTypes = NULL;
1667 }
1668 ktest_empty_data(&p->clientDHNonce);
1669 if (p->supportedKDFs != NULL) {
1670 for (d = p->supportedKDFs; *d != NULL; d++) {
1671 ktest_empty_data(*d);
1672 free(*d);
1673 }
1674 free(p->supportedKDFs);
1675 p->supportedKDFs = NULL;
1676 }
1677 }
1678
1679 void
ktest_empty_kdc_dh_key_info(krb5_kdc_dh_key_info * p)1680 ktest_empty_kdc_dh_key_info(krb5_kdc_dh_key_info *p)
1681 {
1682 ktest_empty_data(&p->subjectPublicKey);
1683 }
1684
1685 void
ktest_empty_reply_key_pack(krb5_reply_key_pack * p)1686 ktest_empty_reply_key_pack(krb5_reply_key_pack *p)
1687 {
1688 ktest_empty_keyblock(&p->replyKey);
1689 ktest_empty_checksum(&p->asChecksum);
1690 }
1691
ktest_empty_sp80056a_other_info(krb5_sp80056a_other_info * p)1692 void ktest_empty_sp80056a_other_info(krb5_sp80056a_other_info *p)
1693 {
1694 ktest_empty_algorithm_identifier(&p->algorithm_identifier);
1695 ktest_destroy_principal(&p->party_u_info);
1696 ktest_destroy_principal(&p->party_v_info);
1697 ktest_empty_data(&p->supp_pub_info);
1698 }
1699
ktest_empty_pkinit_supp_pub_info(krb5_pkinit_supp_pub_info * p)1700 void ktest_empty_pkinit_supp_pub_info(krb5_pkinit_supp_pub_info *p)
1701 {
1702 ktest_empty_data(&p->as_req);
1703 ktest_empty_data(&p->pk_as_rep);
1704 }
1705
1706 #endif /* not DISABLE_PKINIT */
1707
1708 #ifdef ENABLE_LDAP
1709 void
ktest_empty_ldap_seqof_key_data(ldap_seqof_key_data * p)1710 ktest_empty_ldap_seqof_key_data(ldap_seqof_key_data *p)
1711 {
1712 int i;
1713
1714 for (i = 0; i < p->n_key_data; i++) {
1715 free(p->key_data[i].key_data_contents[0]);
1716 free(p->key_data[i].key_data_contents[1]);
1717 }
1718 free(p->key_data);
1719 }
1720 #endif
1721
1722 void
ktest_empty_kkdcp_message(krb5_kkdcp_message * p)1723 ktest_empty_kkdcp_message(krb5_kkdcp_message *p)
1724 {
1725 ktest_empty_data(&p->kerb_message);
1726 ktest_empty_data(&p->target_domain);
1727 p->dclocator_hint = -1;
1728 }
1729
1730 static void
destroy_verifier_mac(krb5_verifier_mac ** vmac)1731 destroy_verifier_mac(krb5_verifier_mac **vmac)
1732 {
1733 if (*vmac == NULL)
1734 return;
1735 ktest_destroy_principal(&(*vmac)->princ);
1736 ktest_empty_checksum(&(*vmac)->checksum);
1737 free(*vmac);
1738 *vmac = NULL;
1739 }
1740
1741 void
ktest_empty_cammac(krb5_cammac * p)1742 ktest_empty_cammac(krb5_cammac *p)
1743 {
1744 krb5_verifier_mac **vmacp;
1745
1746 ktest_destroy_authorization_data(&p->elements);
1747 destroy_verifier_mac(&p->kdc_verifier);
1748 destroy_verifier_mac(&p->svc_verifier);
1749 for (vmacp = p->other_verifiers; vmacp != NULL && *vmacp != NULL; vmacp++)
1750 destroy_verifier_mac(vmacp);
1751 free(p->other_verifiers);
1752 p->other_verifiers = NULL;
1753 }
1754
1755 void
ktest_empty_secure_cookie(krb5_secure_cookie * p)1756 ktest_empty_secure_cookie(krb5_secure_cookie *p)
1757 {
1758 ktest_destroy_pa_data_array(&p->data);
1759 }
1760
1761 void
ktest_empty_spake_factor(krb5_spake_factor * p)1762 ktest_empty_spake_factor(krb5_spake_factor *p)
1763 {
1764 krb5_free_data(NULL, p->data);
1765 p->data = NULL;
1766 }
1767
1768 void
ktest_empty_pa_spake(krb5_pa_spake * p)1769 ktest_empty_pa_spake(krb5_pa_spake *p)
1770 {
1771 krb5_spake_factor **f;
1772
1773 switch (p->choice) {
1774 case SPAKE_MSGTYPE_SUPPORT:
1775 free(p->u.support.groups);
1776 break;
1777 case SPAKE_MSGTYPE_CHALLENGE:
1778 ktest_empty_data(&p->u.challenge.pubkey);
1779 for (f = p->u.challenge.factors; *f != NULL; f++) {
1780 ktest_empty_spake_factor(*f);
1781 free(*f);
1782 }
1783 free(p->u.challenge.factors);
1784 break;
1785 case SPAKE_MSGTYPE_RESPONSE:
1786 ktest_empty_data(&p->u.response.pubkey);
1787 ktest_destroy_enc_data(&p->u.response.factor);
1788 break;
1789 case SPAKE_MSGTYPE_ENCDATA:
1790 ktest_destroy_enc_data(&p->u.encdata);
1791 break;
1792 default:
1793 break;
1794 }
1795 p->choice = SPAKE_MSGTYPE_UNKNOWN;
1796 }
1797