1 /* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
2 /* tests/asn.1/krb5_decode_leak.c */
3 /*
4 * Copyright (C) 2009 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 /*
28 * This program is intended to help detect memory leaks in the ASN.1
29 * decoder functions by exercising their failure paths. The setup
30 * code for the test cases is copied from krb5_encode_test.c.
31 *
32 * This code does not actually detect leaks by itself; it must be run
33 * through a leak-detection tool such as valgrind to do so. Simply
34 * running the program will exercise a bunch of ASN.1 encoder and
35 * decoder code paths but won't validate the results.
36 */
37
38 #include "k5-int.h"
39 #include "com_err.h"
40 #include "utility.h"
41 #include "ktest.h"
42 #include "debug.h"
43
44 krb5_context test_context;
45
46 /*
47 * Contrary to our usual convention, krb5_free_cred_enc_part is a
48 * contents-only free function (and is assumed to be by mk_cred and
49 * rd_cred) and we have no whole-structure free function for that data
50 * type. So create one here.
51 */
52 static void
free_cred_enc_part_whole(krb5_context ctx,krb5_cred_enc_part * val)53 free_cred_enc_part_whole(krb5_context ctx,
54 krb5_cred_enc_part *val)
55 {
56 krb5_free_cred_enc_part(ctx, val);
57 free(val);
58 }
59
60 int
main(int argc,char ** argv)61 main(int argc, char **argv)
62 {
63 krb5_data *code;
64 krb5_error_code retval;
65 unsigned int i;
66
67 retval = krb5_init_context(&test_context);
68 if (retval) {
69 com_err(argv[0], retval, "while initializing krb5");
70 exit(1);
71 }
72 init_access(argv[0]);
73
74 #define encode_run(value,type,typestring,description,encoder)
75
76 /*
77 * Encode a value. Then attempt to trigger most failure paths of
78 * the decoder function by passing in corrupt encodings, which we
79 * generate by perturbing each byte of the encoding in turn. Some
80 * of the perturbed encodings are expected to decode successfully,
81 * so we need a free function to discard successful results. Make
82 * sure to define a pointer named "tmp" of the correct type in the
83 * enclosing block.
84 */
85 #define leak_test(value, encoder, decoder, freefn) \
86 retval = encoder(&(value),&(code)); \
87 if (retval) { \
88 com_err("krb5_decode_leak", retval, "while encoding"); \
89 exit(1); \
90 } \
91 for (i = 0; i < code->length; i++) { \
92 code->data[i] = (char)~((unsigned char)code->data[i]); \
93 retval = decoder(code, &tmp); \
94 code->data[i] = (char)~((unsigned char)code->data[i]); \
95 if (retval == 0) \
96 freefn(test_context, tmp); \
97 } \
98 krb5_free_data(test_context, code);
99
100 /****************************************************************/
101 /* encode_krb5_authenticator */
102 {
103 krb5_authenticator authent, *tmp;
104
105 ktest_make_sample_authenticator(&authent);
106 leak_test(authent, encode_krb5_authenticator,
107 decode_krb5_authenticator, krb5_free_authenticator);
108
109 ktest_destroy_checksum(&(authent.checksum));
110 ktest_destroy_keyblock(&(authent.subkey));
111 authent.seq_number = 0;
112 ktest_empty_authorization_data(authent.authorization_data);
113 leak_test(authent, encode_krb5_authenticator,
114 decode_krb5_authenticator, krb5_free_authenticator);
115
116 ktest_destroy_authorization_data(&(authent.authorization_data));
117 leak_test(authent, encode_krb5_authenticator,
118 decode_krb5_authenticator, krb5_free_authenticator);
119 ktest_empty_authenticator(&authent);
120 }
121
122 /****************************************************************/
123 /* encode_krb5_ticket */
124 {
125 krb5_ticket tkt, *tmp;
126
127 ktest_make_sample_ticket(&tkt);
128 leak_test(tkt, encode_krb5_ticket, decode_krb5_ticket,
129 krb5_free_ticket);
130 ktest_empty_ticket(&tkt);
131 }
132
133 /****************************************************************/
134 /* encode_krb5_encryption_key */
135 {
136 krb5_keyblock keyblk, *tmp;
137
138 ktest_make_sample_keyblock(&keyblk);
139 leak_test(keyblk, encode_krb5_encryption_key,
140 decode_krb5_encryption_key, krb5_free_keyblock);
141 ktest_empty_keyblock(&keyblk);
142 }
143
144 /****************************************************************/
145 /* encode_krb5_enc_tkt_part */
146 {
147 krb5_ticket tkt;
148 krb5_enc_tkt_part *tmp;
149
150 memset(&tkt, 0, sizeof(krb5_ticket));
151 tkt.enc_part2 = ealloc(sizeof(krb5_enc_tkt_part));
152 ktest_make_sample_enc_tkt_part(tkt.enc_part2);
153
154 leak_test(*(tkt.enc_part2), encode_krb5_enc_tkt_part,
155 decode_krb5_enc_tkt_part, krb5_free_enc_tkt_part);
156
157 tkt.enc_part2->times.starttime = 0;
158 tkt.enc_part2->times.renew_till = 0;
159 ktest_destroy_address(&(tkt.enc_part2->caddrs[1]));
160 ktest_destroy_address(&(tkt.enc_part2->caddrs[0]));
161 ktest_destroy_authdata(&(tkt.enc_part2->authorization_data[1]));
162 ktest_destroy_authdata(&(tkt.enc_part2->authorization_data[0]));
163
164 /* ISODE version fails on the empty caddrs field */
165 ktest_destroy_addresses(&(tkt.enc_part2->caddrs));
166 ktest_destroy_authorization_data(&(tkt.enc_part2->authorization_data));
167
168 leak_test(*(tkt.enc_part2), encode_krb5_enc_tkt_part,
169 decode_krb5_enc_tkt_part, krb5_free_enc_tkt_part);
170 ktest_empty_ticket(&tkt);
171 }
172
173 /****************************************************************/
174 /* encode_krb5_enc_kdc_rep_part */
175 {
176 krb5_kdc_rep kdcr;
177 krb5_enc_kdc_rep_part *tmp;
178
179 memset(&kdcr, 0, sizeof(kdcr));
180
181 kdcr.enc_part2 = ealloc(sizeof(krb5_enc_kdc_rep_part));
182 ktest_make_sample_enc_kdc_rep_part(kdcr.enc_part2);
183
184 leak_test(*(kdcr.enc_part2), encode_krb5_enc_kdc_rep_part,
185 decode_krb5_enc_kdc_rep_part, krb5_free_enc_kdc_rep_part);
186
187 kdcr.enc_part2->key_exp = 0;
188 kdcr.enc_part2->times.starttime = 0;
189 kdcr.enc_part2->flags &= ~TKT_FLG_RENEWABLE;
190 ktest_destroy_addresses(&(kdcr.enc_part2->caddrs));
191
192 leak_test(*(kdcr.enc_part2), encode_krb5_enc_kdc_rep_part,
193 decode_krb5_enc_kdc_rep_part, krb5_free_enc_kdc_rep_part);
194
195 ktest_empty_kdc_rep(&kdcr);
196 }
197
198 /****************************************************************/
199 /* encode_krb5_as_rep */
200 {
201 krb5_kdc_rep kdcr, *tmp;
202
203 ktest_make_sample_kdc_rep(&kdcr);
204 kdcr.msg_type = KRB5_AS_REP;
205 leak_test(kdcr, encode_krb5_as_rep, decode_krb5_as_rep,
206 krb5_free_kdc_rep);
207
208 ktest_destroy_pa_data_array(&(kdcr.padata));
209 leak_test(kdcr, encode_krb5_as_rep, decode_krb5_as_rep,
210 krb5_free_kdc_rep);
211
212 ktest_empty_kdc_rep(&kdcr);
213
214 }
215
216 /****************************************************************/
217 /* encode_krb5_tgs_rep */
218 {
219 krb5_kdc_rep kdcr, *tmp;
220
221 ktest_make_sample_kdc_rep(&kdcr);
222 kdcr.msg_type = KRB5_TGS_REP;
223 leak_test(kdcr, encode_krb5_tgs_rep, decode_krb5_tgs_rep,
224 krb5_free_kdc_rep);
225
226 ktest_destroy_pa_data_array(&(kdcr.padata));
227 leak_test(kdcr, encode_krb5_tgs_rep, decode_krb5_tgs_rep,
228 krb5_free_kdc_rep);
229
230 ktest_empty_kdc_rep(&kdcr);
231
232 }
233
234 /****************************************************************/
235 /* encode_krb5_ap_req */
236 {
237 krb5_ap_req apreq, *tmp;
238
239 ktest_make_sample_ap_req(&apreq);
240 leak_test(apreq, encode_krb5_ap_req, decode_krb5_ap_req,
241 krb5_free_ap_req);
242 ktest_empty_ap_req(&apreq);
243 }
244
245 /****************************************************************/
246 /* encode_krb5_ap_rep */
247 {
248 krb5_ap_rep aprep, *tmp;
249
250 ktest_make_sample_ap_rep(&aprep);
251 leak_test(aprep, encode_krb5_ap_rep, decode_krb5_ap_rep,
252 krb5_free_ap_rep);
253 ktest_empty_ap_rep(&aprep);
254 }
255
256 /****************************************************************/
257 /* encode_krb5_ap_rep_enc_part */
258 {
259 krb5_ap_rep_enc_part apenc, *tmp;
260
261 ktest_make_sample_ap_rep_enc_part(&apenc);
262 leak_test(apenc, encode_krb5_ap_rep_enc_part,
263 decode_krb5_ap_rep_enc_part, krb5_free_ap_rep_enc_part);
264
265 ktest_destroy_keyblock(&(apenc.subkey));
266 apenc.seq_number = 0;
267 leak_test(apenc, encode_krb5_ap_rep_enc_part,
268 decode_krb5_ap_rep_enc_part, krb5_free_ap_rep_enc_part);
269 ktest_empty_ap_rep_enc_part(&apenc);
270 }
271
272 /****************************************************************/
273 /* encode_krb5_as_req */
274 {
275 krb5_kdc_req asreq, *tmp;
276
277 ktest_make_sample_kdc_req(&asreq);
278 asreq.msg_type = KRB5_AS_REQ;
279 asreq.kdc_options &= ~KDC_OPT_ENC_TKT_IN_SKEY;
280 leak_test(asreq, encode_krb5_as_req, decode_krb5_as_req,
281 krb5_free_kdc_req);
282
283 ktest_destroy_pa_data_array(&(asreq.padata));
284 ktest_destroy_principal(&(asreq.client));
285 #ifndef ISODE_SUCKS
286 ktest_destroy_principal(&(asreq.server));
287 #endif
288 asreq.kdc_options |= KDC_OPT_ENC_TKT_IN_SKEY;
289 asreq.from = 0;
290 asreq.rtime = 0;
291 ktest_destroy_addresses(&(asreq.addresses));
292 ktest_destroy_enc_data(&(asreq.authorization_data));
293 leak_test(asreq, encode_krb5_as_req, decode_krb5_as_req,
294 krb5_free_kdc_req);
295
296 ktest_destroy_sequence_of_ticket(&(asreq.second_ticket));
297 #ifndef ISODE_SUCKS
298 ktest_make_sample_principal(&(asreq.server));
299 #endif
300 asreq.kdc_options &= ~KDC_OPT_ENC_TKT_IN_SKEY;
301 leak_test(asreq, encode_krb5_as_req, decode_krb5_as_req,
302 krb5_free_kdc_req);
303 ktest_empty_kdc_req(&asreq);
304 }
305
306 /****************************************************************/
307 /* encode_krb5_tgs_req */
308 {
309 krb5_kdc_req tgsreq, *tmp;
310
311 ktest_make_sample_kdc_req(&tgsreq);
312 tgsreq.msg_type = KRB5_TGS_REQ;
313 tgsreq.kdc_options &= ~KDC_OPT_ENC_TKT_IN_SKEY;
314 leak_test(tgsreq, encode_krb5_tgs_req, decode_krb5_tgs_req,
315 krb5_free_kdc_req);
316
317 ktest_destroy_pa_data_array(&(tgsreq.padata));
318 ktest_destroy_principal(&(tgsreq.client));
319 #ifndef ISODE_SUCKS
320 ktest_destroy_principal(&(tgsreq.server));
321 #endif
322 tgsreq.kdc_options |= KDC_OPT_ENC_TKT_IN_SKEY;
323 tgsreq.from = 0;
324 tgsreq.rtime = 0;
325 ktest_destroy_addresses(&(tgsreq.addresses));
326 ktest_destroy_enc_data(&(tgsreq.authorization_data));
327 leak_test(tgsreq, encode_krb5_tgs_req, decode_krb5_tgs_req,
328 krb5_free_kdc_req);
329
330 ktest_destroy_sequence_of_ticket(&(tgsreq.second_ticket));
331 #ifndef ISODE_SUCKS
332 ktest_make_sample_principal(&(tgsreq.server));
333 #endif
334 tgsreq.kdc_options &= ~KDC_OPT_ENC_TKT_IN_SKEY;
335 leak_test(tgsreq, encode_krb5_tgs_req, decode_krb5_tgs_req,
336 krb5_free_kdc_req);
337 ktest_empty_kdc_req(&tgsreq);
338 }
339
340 /****************************************************************/
341 /* encode_krb5_kdc_req_body */
342 {
343 krb5_kdc_req kdcrb, *tmp;
344
345 memset(&kdcrb, 0, sizeof(kdcrb));
346 ktest_make_sample_kdc_req_body(&kdcrb);
347 kdcrb.kdc_options &= ~KDC_OPT_ENC_TKT_IN_SKEY;
348 leak_test(kdcrb, encode_krb5_kdc_req_body, decode_krb5_kdc_req_body,
349 krb5_free_kdc_req);
350
351 ktest_destroy_principal(&(kdcrb.client));
352 #ifndef ISODE_SUCKS
353 ktest_destroy_principal(&(kdcrb.server));
354 #endif
355 kdcrb.kdc_options |= KDC_OPT_ENC_TKT_IN_SKEY;
356 kdcrb.from = 0;
357 kdcrb.rtime = 0;
358 ktest_destroy_addresses(&(kdcrb.addresses));
359 ktest_destroy_enc_data(&(kdcrb.authorization_data));
360 leak_test(kdcrb, encode_krb5_kdc_req_body, decode_krb5_kdc_req_body,
361 krb5_free_kdc_req);
362
363 ktest_destroy_sequence_of_ticket(&(kdcrb.second_ticket));
364 #ifndef ISODE_SUCKS
365 ktest_make_sample_principal(&(kdcrb.server));
366 #endif
367 kdcrb.kdc_options &= ~KDC_OPT_ENC_TKT_IN_SKEY;
368 leak_test(kdcrb, encode_krb5_kdc_req_body, decode_krb5_kdc_req_body,
369 krb5_free_kdc_req);
370 ktest_empty_kdc_req(&kdcrb);
371 }
372
373 /****************************************************************/
374 /* encode_krb5_safe */
375 {
376 krb5_safe s, *tmp;
377
378 ktest_make_sample_safe(&s);
379 leak_test(s, encode_krb5_safe, decode_krb5_safe, krb5_free_safe);
380
381 s.timestamp = 0;
382 /* s.usec should be opted out by the timestamp */
383 s.seq_number = 0;
384 ktest_destroy_address(&(s.r_address));
385 leak_test(s, encode_krb5_safe, decode_krb5_safe, krb5_free_safe);
386 ktest_empty_safe(&s);
387 }
388
389 /****************************************************************/
390 /* encode_krb5_priv */
391 {
392 krb5_priv p, *tmp;
393
394 ktest_make_sample_priv(&p);
395 leak_test(p, encode_krb5_priv, decode_krb5_priv, krb5_free_priv);
396 ktest_empty_priv(&p);
397 }
398
399 /****************************************************************/
400 /* encode_krb5_enc_priv_part */
401 {
402 krb5_priv_enc_part ep, *tmp;
403
404 ktest_make_sample_priv_enc_part(&ep);
405 leak_test(ep, encode_krb5_enc_priv_part, decode_krb5_enc_priv_part,
406 krb5_free_priv_enc_part);
407
408 ep.timestamp = 0;
409 /* ep.usec should be opted out along with timestamp */
410 ep.seq_number = 0;
411 ktest_destroy_address(&(ep.r_address));
412 leak_test(ep, encode_krb5_enc_priv_part, decode_krb5_enc_priv_part,
413 krb5_free_priv_enc_part);
414 ktest_empty_priv_enc_part(&ep);
415 }
416
417 /****************************************************************/
418 /* encode_krb5_cred */
419 {
420 krb5_cred c, *tmp;
421
422 ktest_make_sample_cred(&c);
423 leak_test(c, encode_krb5_cred, decode_krb5_cred, krb5_free_cred);
424 ktest_empty_cred(&c);
425 }
426
427 /****************************************************************/
428 /* encode_krb5_enc_cred_part */
429 {
430 krb5_cred_enc_part cep, *tmp;
431
432 ktest_make_sample_cred_enc_part(&cep);
433 leak_test(cep, encode_krb5_enc_cred_part, decode_krb5_enc_cred_part,
434 free_cred_enc_part_whole);
435
436 ktest_destroy_principal(&(cep.ticket_info[0]->client));
437 ktest_destroy_principal(&(cep.ticket_info[0]->server));
438 cep.ticket_info[0]->flags = 0;
439 cep.ticket_info[0]->times.authtime = 0;
440 cep.ticket_info[0]->times.starttime = 0;
441 cep.ticket_info[0]->times.endtime = 0;
442 cep.ticket_info[0]->times.renew_till = 0;
443 ktest_destroy_addresses(&(cep.ticket_info[0]->caddrs));
444 cep.nonce = 0;
445 cep.timestamp = 0;
446 ktest_destroy_address(&(cep.s_address));
447 ktest_destroy_address(&(cep.r_address));
448 leak_test(cep, encode_krb5_enc_cred_part, decode_krb5_enc_cred_part,
449 free_cred_enc_part_whole);
450 ktest_empty_cred_enc_part(&cep);
451 }
452
453 /****************************************************************/
454 /* encode_krb5_error */
455 {
456 krb5_error kerr, *tmp;
457
458 ktest_make_sample_error(&kerr);
459 leak_test(kerr, encode_krb5_error, decode_krb5_error, krb5_free_error);
460
461 kerr.ctime = 0;
462 ktest_destroy_principal(&(kerr.client));
463 ktest_empty_data(&(kerr.text));
464 ktest_empty_data(&(kerr.e_data));
465 leak_test(kerr, encode_krb5_error, decode_krb5_error, krb5_free_error);
466
467 ktest_empty_error(&kerr);
468 }
469
470 /****************************************************************/
471 /* encode_krb5_authdata */
472 {
473 krb5_authdata **ad, **tmp;
474
475 ktest_make_sample_authorization_data(&ad);
476 leak_test(*ad, encode_krb5_authdata, decode_krb5_authdata,
477 krb5_free_authdata);
478 ktest_destroy_authorization_data(&ad);
479 }
480
481 /****************************************************************/
482 /* encode_padata_sequence and encode_typed_data */
483 {
484 krb5_pa_data **pa, **tmp;
485
486 ktest_make_sample_pa_data_array(&pa);
487 leak_test(*pa, encode_krb5_padata_sequence,
488 decode_krb5_padata_sequence, krb5_free_pa_data);
489 leak_test(*pa, encode_krb5_typed_data,
490 decode_krb5_typed_data, krb5_free_pa_data);
491 ktest_destroy_pa_data_array(&pa);
492 }
493
494 /****************************************************************/
495 /* encode_padata_sequence (empty) */
496 {
497 krb5_pa_data **pa, **tmp;
498
499 ktest_make_sample_empty_pa_data_array(&pa);
500 leak_test(*pa, encode_krb5_padata_sequence,
501 decode_krb5_padata_sequence, krb5_free_pa_data);
502 ktest_destroy_pa_data_array(&pa);
503 }
504
505 /****************************************************************/
506 /* encode_etype_info */
507 {
508 krb5_etype_info_entry **info, **tmp;
509
510 ktest_make_sample_etype_info(&info);
511 leak_test(*info, encode_krb5_etype_info, decode_krb5_etype_info,
512 krb5_free_etype_info);
513
514 ktest_destroy_etype_info_entry(info[2]); info[2] = 0;
515 ktest_destroy_etype_info_entry(info[1]); info[1] = 0;
516 leak_test(*info, encode_krb5_etype_info, decode_krb5_etype_info,
517 krb5_free_etype_info);
518
519 ktest_destroy_etype_info_entry(info[0]); info[0] = 0;
520 leak_test(*info, encode_krb5_etype_info, decode_krb5_etype_info,
521 krb5_free_etype_info);
522
523 ktest_destroy_etype_info(info);
524 }
525
526 /* encode_etype_info 2*/
527 {
528 krb5_etype_info_entry **info, **tmp;
529
530 ktest_make_sample_etype_info2(&info);
531 leak_test(*info, encode_krb5_etype_info2, decode_krb5_etype_info2,
532 krb5_free_etype_info);
533
534 ktest_destroy_etype_info_entry(info[2]); info[2] = 0;
535 ktest_destroy_etype_info_entry(info[1]); info[1] = 0;
536 leak_test(*info, encode_krb5_etype_info2, decode_krb5_etype_info2,
537 krb5_free_etype_info);
538
539 ktest_destroy_etype_info(info);
540 }
541
542 /****************************************************************/
543 /* encode_pa_enc_ts */
544 {
545 krb5_pa_enc_ts pa_enc, *tmp;
546
547 ktest_make_sample_pa_enc_ts(&pa_enc);
548 leak_test(pa_enc, encode_krb5_pa_enc_ts, decode_krb5_pa_enc_ts,
549 krb5_free_pa_enc_ts);
550 pa_enc.pausec = 0;
551 leak_test(pa_enc, encode_krb5_pa_enc_ts, decode_krb5_pa_enc_ts,
552 krb5_free_pa_enc_ts);
553 }
554
555 /****************************************************************/
556 /* encode_enc_data */
557 {
558 krb5_enc_data enc_data, *tmp;
559
560 ktest_make_sample_enc_data(&enc_data);
561 leak_test(enc_data, encode_krb5_enc_data, decode_krb5_enc_data,
562 krb5_free_enc_data);
563 ktest_destroy_enc_data(&enc_data);
564 }
565 /****************************************************************/
566 /* encode_krb5_sam_challenge_2 */
567 {
568 krb5_sam_challenge_2 sam_ch2, *tmp;
569
570 ktest_make_sample_sam_challenge_2(&sam_ch2);
571 leak_test(sam_ch2, encode_krb5_sam_challenge_2,
572 decode_krb5_sam_challenge_2, krb5_free_sam_challenge_2);
573 ktest_empty_sam_challenge_2(&sam_ch2);
574 }
575 /****************************************************************/
576 /* encode_krb5_sam_challenge_2 */
577 {
578 krb5_sam_challenge_2_body body, *tmp;
579
580 ktest_make_sample_sam_challenge_2_body(&body);
581 leak_test(body, encode_krb5_sam_challenge_2_body,
582 decode_krb5_sam_challenge_2_body,
583 krb5_free_sam_challenge_2_body);
584 ktest_empty_sam_challenge_2_body(&body);
585 }
586 /****************************************************************/
587 /* encode_krb5_sam_response_2 */
588 {
589 krb5_sam_response_2 sam_ch2, *tmp;
590
591 ktest_make_sample_sam_response_2(&sam_ch2);
592 leak_test(sam_ch2, encode_krb5_sam_response_2,
593 decode_krb5_sam_response_2, krb5_free_sam_response_2);
594 ktest_empty_sam_response_2(&sam_ch2);
595 }
596 /****************************************************************/
597 /* encode_krb5_sam_response_enc_2 */
598 {
599 krb5_enc_sam_response_enc_2 sam_ch2, *tmp;
600
601 ktest_make_sample_enc_sam_response_enc_2(&sam_ch2);
602 leak_test(sam_ch2, encode_krb5_enc_sam_response_enc_2,
603 decode_krb5_enc_sam_response_enc_2,
604 krb5_free_enc_sam_response_enc_2);
605 ktest_empty_enc_sam_response_enc_2(&sam_ch2);
606 }
607 /****************************************************************/
608 /* encode_krb5_pa_for_user */
609 {
610 krb5_pa_for_user foru, *tmp;
611 ktest_make_sample_pa_for_user(&foru);
612 leak_test(foru, encode_krb5_pa_for_user, decode_krb5_pa_for_user,
613 krb5_free_pa_for_user);
614 ktest_empty_pa_for_user(&foru);
615 }
616 /****************************************************************/
617 /* encode_krb5_pa_s4u_x509_user */
618 {
619 krb5_pa_s4u_x509_user s4u, *tmp;
620 ktest_make_sample_pa_s4u_x509_user(&s4u);
621 leak_test(s4u, encode_krb5_pa_s4u_x509_user,
622 decode_krb5_pa_s4u_x509_user,
623 krb5_free_pa_s4u_x509_user);
624 ktest_empty_pa_s4u_x509_user(&s4u);
625 }
626 /****************************************************************/
627 /* encode_krb5_ad_kdcissued */
628 {
629 krb5_ad_kdcissued kdci, *tmp;
630 ktest_make_sample_ad_kdcissued(&kdci);
631 leak_test(kdci, encode_krb5_ad_kdcissued,
632 decode_krb5_ad_kdcissued,
633 krb5_free_ad_kdcissued);
634 ktest_empty_ad_kdcissued(&kdci);
635 }
636 /****************************************************************/
637 /* encode_krb5_ad_signedpath */
638 {
639 krb5_ad_signedpath sp, *tmp;
640 ktest_make_sample_ad_signedpath(&sp);
641 leak_test(sp, encode_krb5_ad_signedpath,
642 decode_krb5_ad_signedpath,
643 krb5_free_ad_signedpath);
644 ktest_empty_ad_signedpath(&sp);
645 }
646 /****************************************************************/
647 /* encode_krb5_iakerb_header */
648 {
649 krb5_iakerb_header ih, *tmp;
650 ktest_make_sample_iakerb_header(&ih);
651 leak_test(ih, encode_krb5_iakerb_header,
652 decode_krb5_iakerb_header,
653 krb5_free_iakerb_header);
654 ktest_empty_iakerb_header(&ih);
655 }
656 /****************************************************************/
657 /* encode_krb5_iakerb_finished */
658 {
659 krb5_iakerb_finished ih, *tmp;
660 ktest_make_sample_iakerb_finished(&ih);
661 leak_test(ih, encode_krb5_iakerb_finished,
662 decode_krb5_iakerb_finished,
663 krb5_free_iakerb_finished);
664 ktest_empty_iakerb_finished(&ih);
665 }
666 /****************************************************************/
667 /* encode_krb5_fast_response */
668 {
669 krb5_fast_response fr, *tmp;
670 ktest_make_sample_fast_response(&fr);
671 leak_test(fr, encode_krb5_fast_response, decode_krb5_fast_response,
672 krb5_free_fast_response);
673 ktest_empty_fast_response(&fr);
674 }
675 /****************************************************************/
676 /* encode_krb5_pa_fx_fast_reply */
677 {
678 krb5_enc_data enc, *tmp;
679 ktest_make_sample_enc_data(&enc);
680 leak_test(enc, encode_krb5_pa_fx_fast_reply,
681 decode_krb5_pa_fx_fast_reply, krb5_free_enc_data);
682 ktest_destroy_enc_data(&enc);
683 }
684 krb5_free_context(test_context);
685 return 0;
686 }
687