1 /* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -*- */
2 /* tests/asn.1/ktest_equal.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 <stdlib.h>
28 #include <stdio.h>
29 #include "ktest_equal.h"
30
31 #define FALSE 0
32 #define TRUE 1
33
34 #define struct_equal(field,comparator) \
35 comparator(&(ref->field),&(var->field))
36
37 #define ptr_equal(field,comparator) \
38 comparator(ref->field,var->field)
39
40 #define scalar_equal(field) \
41 ((ref->field) == (var->field))
42
43 #define len_equal(length,field,comparator) \
44 ((ref->length == var->length) && \
45 comparator(ref->length,ref->field,var->field))
46
47 int
ktest_equal_authenticator(krb5_authenticator * ref,krb5_authenticator * var)48 ktest_equal_authenticator(krb5_authenticator *ref, krb5_authenticator *var)
49 {
50 int p = TRUE;
51
52 if (ref == var) return TRUE;
53 else if (ref == NULL || var == NULL) return FALSE;
54 p = p && ptr_equal(client,ktest_equal_principal_data);
55 p = p && ptr_equal(checksum,ktest_equal_checksum);
56 p = p && scalar_equal(cusec);
57 p = p && scalar_equal(ctime);
58 p = p && ptr_equal(subkey,ktest_equal_keyblock);
59 p = p && scalar_equal(seq_number);
60 p = p && ptr_equal(authorization_data,ktest_equal_authorization_data);
61 return p;
62 }
63
64 int
ktest_equal_principal_data(krb5_principal_data * ref,krb5_principal_data * var)65 ktest_equal_principal_data(krb5_principal_data *ref, krb5_principal_data *var)
66 {
67 if (ref == var) return TRUE;
68 else if (ref == NULL || var == NULL) return FALSE;
69 return(struct_equal(realm,ktest_equal_data) &&
70 len_equal(length,data,ktest_equal_array_of_data) &&
71 scalar_equal(type));
72 }
73
74 int
ktest_equal_authdata(krb5_authdata * ref,krb5_authdata * var)75 ktest_equal_authdata(krb5_authdata *ref, krb5_authdata *var)
76 {
77 if (ref == var) return TRUE;
78 else if (ref == NULL || var == NULL) return FALSE;
79 return(scalar_equal(ad_type) &&
80 len_equal(length,contents,ktest_equal_array_of_octet));
81 }
82
83 int
ktest_equal_checksum(krb5_checksum * ref,krb5_checksum * var)84 ktest_equal_checksum(krb5_checksum *ref, krb5_checksum *var)
85 {
86 if (ref == var) return TRUE;
87 else if (ref == NULL || var == NULL) return FALSE;
88 return(scalar_equal(checksum_type) && len_equal(length,contents,ktest_equal_array_of_octet));
89 }
90
91 int
ktest_equal_keyblock(krb5_keyblock * ref,krb5_keyblock * var)92 ktest_equal_keyblock(krb5_keyblock *ref, krb5_keyblock *var)
93 {
94 if (ref == var) return TRUE;
95 else if (ref == NULL || var == NULL) return FALSE;
96 return(scalar_equal(enctype) && len_equal(length,contents,ktest_equal_array_of_octet));
97 }
98
99 int
ktest_equal_data(krb5_data * ref,krb5_data * var)100 ktest_equal_data(krb5_data *ref, krb5_data *var)
101 {
102 if (ref == var) return TRUE;
103 else if (ref == NULL || var == NULL) return FALSE;
104 return(len_equal(length,data,ktest_equal_array_of_char));
105 }
106
107 int
ktest_equal_ticket(krb5_ticket * ref,krb5_ticket * var)108 ktest_equal_ticket(krb5_ticket *ref, krb5_ticket *var)
109 {
110 int p = TRUE;
111 if (ref == var) return TRUE;
112 else if (ref == NULL || var == NULL) return FALSE;
113 p = p && ptr_equal(server,ktest_equal_principal_data);
114 p = p && struct_equal(enc_part,ktest_equal_enc_data);
115 /* enc_part2 is irrelevant, as far as the ASN.1 code is concerned */
116 return p;
117 }
118
119 int
ktest_equal_enc_data(krb5_enc_data * ref,krb5_enc_data * var)120 ktest_equal_enc_data(krb5_enc_data *ref, krb5_enc_data *var)
121 {
122 int p = TRUE;
123 if (ref == var) return TRUE;
124 else if (ref == NULL || var == NULL) return FALSE;
125 p = p && scalar_equal(enctype);
126 p = p && scalar_equal(kvno);
127 p = p && struct_equal(ciphertext,ktest_equal_data);
128 return p;
129 }
130
131 int
ktest_equal_encryption_key(krb5_keyblock * ref,krb5_keyblock * var)132 ktest_equal_encryption_key(krb5_keyblock *ref, krb5_keyblock *var)
133 {
134 int p = TRUE;
135 if (ref == var) return TRUE;
136 else if (ref == NULL || var == NULL) return FALSE;
137 p = p && scalar_equal(enctype);
138 p = p && len_equal(length,contents,ktest_equal_array_of_octet);
139 return p;
140 }
141
142 int
ktest_equal_enc_tkt_part(krb5_enc_tkt_part * ref,krb5_enc_tkt_part * var)143 ktest_equal_enc_tkt_part(krb5_enc_tkt_part *ref, krb5_enc_tkt_part *var)
144 {
145 int p = TRUE;
146 if (ref == var) return TRUE;
147 else if (ref == NULL || var == NULL) return FALSE;
148 p = p && scalar_equal(flags);
149 p = p && ptr_equal(session,ktest_equal_encryption_key);
150 p = p && ptr_equal(client,ktest_equal_principal_data);
151 p = p && struct_equal(transited,ktest_equal_transited);
152 p = p && struct_equal(times,ktest_equal_ticket_times);
153 p = p && ptr_equal(caddrs,ktest_equal_addresses);
154 p = p && ptr_equal(authorization_data,ktest_equal_authorization_data);
155 return p;
156 }
157
158 int
ktest_equal_transited(krb5_transited * ref,krb5_transited * var)159 ktest_equal_transited(krb5_transited *ref, krb5_transited *var)
160 {
161 int p = TRUE;
162 if (ref == var) return TRUE;
163 else if (ref == NULL || var == NULL) return FALSE;
164 p = p && scalar_equal(tr_type);
165 p = p && struct_equal(tr_contents,ktest_equal_data);
166 return p;
167 }
168
169 int
ktest_equal_ticket_times(krb5_ticket_times * ref,krb5_ticket_times * var)170 ktest_equal_ticket_times(krb5_ticket_times *ref, krb5_ticket_times *var)
171 {
172 int p = TRUE;
173 if (ref == var) return TRUE;
174 else if (ref == NULL || var == NULL) return FALSE;
175 p = p && scalar_equal(authtime);
176 p = p && scalar_equal(starttime);
177 p = p && scalar_equal(endtime);
178 p = p && scalar_equal(renew_till);
179 return p;
180 }
181
182 int
ktest_equal_address(krb5_address * ref,krb5_address * var)183 ktest_equal_address(krb5_address *ref, krb5_address *var)
184 {
185 int p = TRUE;
186 if (ref == var) return TRUE;
187 else if (ref == NULL || var == NULL) return FALSE;
188 p = p && scalar_equal(addrtype);
189 p = p && len_equal(length,contents,ktest_equal_array_of_octet);
190 return p;
191 }
192
193 int
ktest_equal_enc_kdc_rep_part(krb5_enc_kdc_rep_part * ref,krb5_enc_kdc_rep_part * var)194 ktest_equal_enc_kdc_rep_part(krb5_enc_kdc_rep_part *ref,
195 krb5_enc_kdc_rep_part *var)
196 {
197 int p = TRUE;
198 if (ref == var) return TRUE;
199 else if (ref == NULL || var == NULL) return FALSE;
200 p = p && ptr_equal(session,ktest_equal_keyblock);
201 p = p && ptr_equal(last_req,ktest_equal_last_req);
202 p = p && scalar_equal(nonce);
203 p = p && scalar_equal(key_exp);
204 p = p && scalar_equal(flags);
205 p = p && struct_equal(times,ktest_equal_ticket_times);
206 p = p && ptr_equal(server,ktest_equal_principal_data);
207 p = p && ptr_equal(caddrs,ktest_equal_addresses);
208 return p;
209 }
210
211 int
ktest_equal_priv(krb5_priv * ref,krb5_priv * var)212 ktest_equal_priv(krb5_priv *ref, krb5_priv *var)
213 {
214 int p = TRUE;
215 if (ref == var) return TRUE;
216 else if (ref == NULL || var == NULL) return FALSE;
217 p = p && struct_equal(enc_part,ktest_equal_enc_data);
218 return p;
219 }
220
221 int
ktest_equal_cred(krb5_cred * ref,krb5_cred * var)222 ktest_equal_cred(krb5_cred *ref, krb5_cred *var)
223 {
224 int p = TRUE;
225 if (ref == var) return TRUE;
226 else if (ref == NULL || var == NULL) return FALSE;
227 p = p && ptr_equal(tickets,ktest_equal_sequence_of_ticket);
228 p = p && struct_equal(enc_part,ktest_equal_enc_data);
229 return p;
230 }
231
232 int
ktest_equal_error(krb5_error * ref,krb5_error * var)233 ktest_equal_error(krb5_error *ref, krb5_error *var)
234 {
235 int p = TRUE;
236 if (ref == var) return TRUE;
237 else if (ref == NULL || var == NULL) return FALSE;
238 p = p && scalar_equal(ctime);
239 p = p && scalar_equal(cusec);
240 p = p && scalar_equal(susec);
241 p = p && scalar_equal(stime);
242 p = p && scalar_equal(error);
243 p = p && ptr_equal(client,ktest_equal_principal_data);
244 p = p && ptr_equal(server,ktest_equal_principal_data);
245 p = p && struct_equal(text,ktest_equal_data);
246 p = p && struct_equal(e_data,ktest_equal_data);
247 return p;
248 }
249
250 int
ktest_equal_ap_req(krb5_ap_req * ref,krb5_ap_req * var)251 ktest_equal_ap_req(krb5_ap_req *ref, krb5_ap_req *var)
252 {
253 int p = TRUE;
254 if (ref == var) return TRUE;
255 else if (ref == NULL || var == NULL) return FALSE;
256 p = p && scalar_equal(ap_options);
257 p = p && ptr_equal(ticket,ktest_equal_ticket);
258 p = p && struct_equal(authenticator,ktest_equal_enc_data);
259 return p;
260 }
261
262 int
ktest_equal_ap_rep(krb5_ap_rep * ref,krb5_ap_rep * var)263 ktest_equal_ap_rep(krb5_ap_rep *ref, krb5_ap_rep *var)
264 {
265 int p = TRUE;
266 if (ref == var) return TRUE;
267 else if (ref == NULL || var == NULL) return FALSE;
268 p = p && struct_equal(enc_part,ktest_equal_enc_data);
269 return p;
270 }
271
272 int
ktest_equal_ap_rep_enc_part(krb5_ap_rep_enc_part * ref,krb5_ap_rep_enc_part * var)273 ktest_equal_ap_rep_enc_part(krb5_ap_rep_enc_part *ref,
274 krb5_ap_rep_enc_part *var)
275 {
276 int p = TRUE;
277 if (ref == var) return TRUE;
278 else if (ref == NULL || var == NULL) return FALSE;
279 p = p && scalar_equal(ctime);
280 p = p && scalar_equal(cusec);
281 p = p && ptr_equal(subkey,ktest_equal_encryption_key);
282 p = p && scalar_equal(seq_number);
283 return p;
284 }
285
286 int
ktest_equal_safe(krb5_safe * ref,krb5_safe * var)287 ktest_equal_safe(krb5_safe *ref, krb5_safe *var)
288 {
289 int p = TRUE;
290 if (ref == var) return TRUE;
291 else if (ref == NULL || var == NULL) return FALSE;
292 p = p && struct_equal(user_data,ktest_equal_data);
293 p = p && scalar_equal(timestamp);
294 p = p && scalar_equal(usec);
295 p = p && scalar_equal(seq_number);
296 p = p && ptr_equal(s_address,ktest_equal_address);
297 p = p && ptr_equal(r_address,ktest_equal_address);
298 p = p && ptr_equal(checksum,ktest_equal_checksum);
299 return p;
300 }
301
302
303 int
ktest_equal_enc_cred_part(krb5_cred_enc_part * ref,krb5_cred_enc_part * var)304 ktest_equal_enc_cred_part(krb5_cred_enc_part *ref, krb5_cred_enc_part *var)
305 {
306 int p = TRUE;
307 if (ref == var) return TRUE;
308 else if (ref == NULL || var == NULL) return FALSE;
309 p = p && scalar_equal(nonce);
310 p = p && scalar_equal(timestamp);
311 p = p && scalar_equal(usec);
312 p = p && ptr_equal(s_address,ktest_equal_address);
313 p = p && ptr_equal(r_address,ktest_equal_address);
314 p = p && ptr_equal(ticket_info,ktest_equal_sequence_of_cred_info);
315 return p;
316 }
317
318 int
ktest_equal_enc_priv_part(krb5_priv_enc_part * ref,krb5_priv_enc_part * var)319 ktest_equal_enc_priv_part(krb5_priv_enc_part *ref, krb5_priv_enc_part *var)
320 {
321 int p = TRUE;
322 if (ref == var) return TRUE;
323 else if (ref == NULL || var == NULL) return FALSE;
324 p = p && struct_equal(user_data,ktest_equal_data);
325 p = p && scalar_equal(timestamp);
326 p = p && scalar_equal(usec);
327 p = p && scalar_equal(seq_number);
328 p = p && ptr_equal(s_address,ktest_equal_address);
329 p = p && ptr_equal(r_address,ktest_equal_address);
330 return p;
331 }
332
333 int
ktest_equal_as_rep(krb5_kdc_rep * ref,krb5_kdc_rep * var)334 ktest_equal_as_rep(krb5_kdc_rep *ref, krb5_kdc_rep *var)
335 {
336 int p = TRUE;
337 if (ref == var) return TRUE;
338 else if (ref == NULL || var == NULL) return FALSE;
339 p = p && scalar_equal(msg_type);
340 p = p && ptr_equal(padata,ktest_equal_sequence_of_pa_data);
341 p = p && ptr_equal(client,ktest_equal_principal_data);
342 p = p && ptr_equal(ticket,ktest_equal_ticket);
343 p = p && struct_equal(enc_part,ktest_equal_enc_data);
344 p = p && ptr_equal(enc_part2,ktest_equal_enc_kdc_rep_part);
345 return p;
346 }
347
348 int
ktest_equal_tgs_rep(krb5_kdc_rep * ref,krb5_kdc_rep * var)349 ktest_equal_tgs_rep(krb5_kdc_rep *ref, krb5_kdc_rep *var)
350 {
351 return ktest_equal_as_rep(ref,var);
352 }
353
354 int
ktest_equal_as_req(krb5_kdc_req * ref,krb5_kdc_req * var)355 ktest_equal_as_req(krb5_kdc_req *ref, krb5_kdc_req *var)
356 {
357 int p = TRUE;
358 if (ref == var) return TRUE;
359 else if (ref == NULL || var == NULL) return FALSE;
360 p = p && scalar_equal(msg_type);
361 p = p && ptr_equal(padata,ktest_equal_sequence_of_pa_data);
362 p = p && scalar_equal(kdc_options);
363 p = p && ptr_equal(client,ktest_equal_principal_data);
364 p = p && ptr_equal(server,ktest_equal_principal_data);
365 p = p && scalar_equal(from);
366 p = p && scalar_equal(till);
367 p = p && scalar_equal(rtime);
368 p = p && scalar_equal(nonce);
369 p = p && len_equal(nktypes,ktype,ktest_equal_array_of_enctype);
370 p = p && ptr_equal(addresses,ktest_equal_addresses);
371 p = p && struct_equal(authorization_data,ktest_equal_enc_data);
372 /* This field isn't actually in the ASN.1 encoding. */
373 /* p = p && ptr_equal(unenc_authdata,ktest_equal_authorization_data); */
374 return p;
375 }
376
377 int
ktest_equal_tgs_req(krb5_kdc_req * ref,krb5_kdc_req * var)378 ktest_equal_tgs_req(krb5_kdc_req *ref, krb5_kdc_req *var)
379 {
380 return ktest_equal_as_req(ref,var);
381 }
382
383 int
ktest_equal_kdc_req_body(krb5_kdc_req * ref,krb5_kdc_req * var)384 ktest_equal_kdc_req_body(krb5_kdc_req *ref, krb5_kdc_req *var)
385 {
386 int p = TRUE;
387 if (ref == var) return TRUE;
388 else if (ref == NULL || var == NULL) return FALSE;
389 p = p && scalar_equal(kdc_options);
390 p = p && ptr_equal(client,ktest_equal_principal_data);
391 p = p && ptr_equal(server,ktest_equal_principal_data);
392 p = p && scalar_equal(from);
393 p = p && scalar_equal(till);
394 p = p && scalar_equal(rtime);
395 p = p && scalar_equal(nonce);
396 p = p && len_equal(nktypes,ktype,ktest_equal_array_of_enctype);
397 p = p && ptr_equal(addresses,ktest_equal_addresses);
398 p = p && struct_equal(authorization_data,ktest_equal_enc_data);
399 /* This isn't part of the ASN.1 encoding. */
400 /* p = p && ptr_equal(unenc_authdata,ktest_equal_authorization_data); */
401 return p;
402 }
403
404 int
ktest_equal_last_req_entry(krb5_last_req_entry * ref,krb5_last_req_entry * var)405 ktest_equal_last_req_entry(krb5_last_req_entry *ref, krb5_last_req_entry *var)
406 {
407 int p = TRUE;
408 if (ref == var) return TRUE;
409 else if (ref == NULL || var == NULL) return FALSE;
410 p = p && scalar_equal(lr_type);
411 p = p && scalar_equal(value);
412 return p;
413 }
414
415 int
ktest_equal_pa_data(krb5_pa_data * ref,krb5_pa_data * var)416 ktest_equal_pa_data(krb5_pa_data *ref, krb5_pa_data *var)
417 {
418 int p = TRUE;
419 if (ref == var) return TRUE;
420 else if (ref == NULL || var == NULL) return FALSE;
421 p = p && scalar_equal(pa_type);
422 p = p && len_equal(length,contents,ktest_equal_array_of_octet);
423 return p;
424 }
425
426 int
ktest_equal_cred_info(krb5_cred_info * ref,krb5_cred_info * var)427 ktest_equal_cred_info(krb5_cred_info *ref, krb5_cred_info *var)
428 {
429 int p = TRUE;
430 if (ref == var) return TRUE;
431 else if (ref == NULL || var == NULL) return FALSE;
432 p = p && ptr_equal(session,ktest_equal_keyblock);
433 p = p && ptr_equal(client,ktest_equal_principal_data);
434 p = p && ptr_equal(server,ktest_equal_principal_data);
435 p = p && scalar_equal(flags);
436 p = p && struct_equal(times,ktest_equal_ticket_times);
437 p = p && ptr_equal(caddrs,ktest_equal_addresses);
438
439 return p;
440 }
441
442 int
ktest_equal_krb5_etype_info_entry(krb5_etype_info_entry * ref,krb5_etype_info_entry * var)443 ktest_equal_krb5_etype_info_entry(krb5_etype_info_entry *ref,
444 krb5_etype_info_entry *var)
445 {
446 if (ref->etype != var->etype)
447 return FALSE;
448 if (ref->length != var->length)
449 return FALSE;
450 if (ref->length > 0 && ref->length != KRB5_ETYPE_NO_SALT)
451 if (memcmp(ref->salt, var->salt, ref->length) != 0)
452 return FALSE;
453 return TRUE;
454 }
455
456 int
ktest_equal_krb5_pa_enc_ts(krb5_pa_enc_ts * ref,krb5_pa_enc_ts * var)457 ktest_equal_krb5_pa_enc_ts(krb5_pa_enc_ts *ref, krb5_pa_enc_ts *var)
458 {
459 int p = TRUE;
460 if (ref == var) return TRUE;
461 else if (ref == NULL || var == NULL) return FALSE;
462 p = p && scalar_equal(patimestamp);
463 p = p && scalar_equal(pausec);
464 return p;
465 }
466
467 #define equal_str(f) struct_equal(f,ktest_equal_data)
468
469 int
ktest_equal_sam_challenge_2_body(krb5_sam_challenge_2_body * ref,krb5_sam_challenge_2_body * var)470 ktest_equal_sam_challenge_2_body(krb5_sam_challenge_2_body *ref,
471 krb5_sam_challenge_2_body *var)
472 {
473 int p = TRUE;
474 if (ref == var) return TRUE;
475 else if (ref == NULL || var == NULL) return FALSE;
476 p = p && scalar_equal(sam_type);
477 p = p && scalar_equal(sam_flags);
478 p = p && equal_str(sam_type_name);
479 p = p && equal_str(sam_track_id);
480 p = p && equal_str(sam_challenge_label);
481 p = p && equal_str(sam_challenge);
482 p = p && equal_str(sam_response_prompt);
483 p = p && equal_str(sam_pk_for_sad);
484 p = p && scalar_equal(sam_nonce);
485 p = p && scalar_equal(sam_etype);
486 return p;
487 }
488
489 int
ktest_equal_sam_challenge_2(krb5_sam_challenge_2 * ref,krb5_sam_challenge_2 * var)490 ktest_equal_sam_challenge_2(krb5_sam_challenge_2 *ref,
491 krb5_sam_challenge_2 *var)
492 {
493 int p = TRUE;
494 if (ref == var) return TRUE;
495 else if (ref == NULL || var == NULL) return FALSE;
496 p = p && equal_str(sam_challenge_2_body);
497 p = p && ptr_equal(sam_cksum,ktest_equal_sequence_of_checksum);
498 return p;
499 }
500
501 int
ktest_equal_pa_for_user(krb5_pa_for_user * ref,krb5_pa_for_user * var)502 ktest_equal_pa_for_user(krb5_pa_for_user *ref, krb5_pa_for_user *var)
503 {
504 int p = TRUE;
505 if (ref == var) return TRUE;
506 else if (ref == NULL || var == NULL) return FALSE;
507 p = p && ptr_equal(user, ktest_equal_principal_data);
508 p = p && struct_equal(cksum, ktest_equal_checksum);
509 p = p && equal_str(auth_package);
510 return p;
511 }
512
513 int
ktest_equal_pa_s4u_x509_user(krb5_pa_s4u_x509_user * ref,krb5_pa_s4u_x509_user * var)514 ktest_equal_pa_s4u_x509_user(krb5_pa_s4u_x509_user *ref,
515 krb5_pa_s4u_x509_user *var)
516 {
517 int p = TRUE;
518 if (ref == var) return TRUE;
519 else if (ref == NULL || var == NULL) return FALSE;
520 p = p && scalar_equal(user_id.nonce);
521 p = p && ptr_equal(user_id.user,ktest_equal_principal_data);
522 p = p && struct_equal(user_id.subject_cert,ktest_equal_data);
523 p = p && scalar_equal(user_id.options);
524 p = p && struct_equal(cksum,ktest_equal_checksum);
525 return p;
526 }
527
528 int
ktest_equal_ad_kdcissued(krb5_ad_kdcissued * ref,krb5_ad_kdcissued * var)529 ktest_equal_ad_kdcissued(krb5_ad_kdcissued *ref, krb5_ad_kdcissued *var)
530 {
531 int p = TRUE;
532 if (ref == var) return TRUE;
533 else if (ref == NULL || var == NULL) return FALSE;
534 p = p && struct_equal(ad_checksum,ktest_equal_checksum);
535 p = p && ptr_equal(i_principal,ktest_equal_principal_data);
536 p = p && ptr_equal(elements,ktest_equal_authorization_data);
537 return p;
538 }
539
540 int
ktest_equal_ad_signedpath_data(krb5_ad_signedpath_data * ref,krb5_ad_signedpath_data * var)541 ktest_equal_ad_signedpath_data(krb5_ad_signedpath_data *ref,
542 krb5_ad_signedpath_data *var)
543 {
544 int p = TRUE;
545 if (ref == var) return TRUE;
546 else if (ref == NULL || var == NULL) return FALSE;
547 p = p && ptr_equal(client,ktest_equal_principal_data);
548 p = p && scalar_equal(authtime);
549 p = p && ptr_equal(delegated,ktest_equal_sequence_of_principal);
550 p = p && ptr_equal(method_data,ktest_equal_sequence_of_pa_data);
551 p = p && ptr_equal(authorization_data,ktest_equal_authorization_data);
552 return p;
553 }
554
555 int
ktest_equal_ad_signedpath(krb5_ad_signedpath * ref,krb5_ad_signedpath * var)556 ktest_equal_ad_signedpath(krb5_ad_signedpath *ref, krb5_ad_signedpath *var)
557 {
558 int p = TRUE;
559 if (ref == var) return TRUE;
560 else if (ref == NULL || var == NULL) return FALSE;
561 p = p && scalar_equal(enctype);
562 p = p && struct_equal(checksum,ktest_equal_checksum);
563 p = p && ptr_equal(delegated,ktest_equal_sequence_of_principal);
564 p = p && ptr_equal(method_data,ktest_equal_sequence_of_pa_data);
565 return p;
566 }
567
568 int
ktest_equal_iakerb_header(krb5_iakerb_header * ref,krb5_iakerb_header * var)569 ktest_equal_iakerb_header(krb5_iakerb_header *ref, krb5_iakerb_header *var)
570 {
571 int p = TRUE;
572 if (ref == var) return TRUE;
573 else if (ref == NULL || var == NULL) return FALSE;
574 p = p && struct_equal(target_realm,ktest_equal_data);
575 p = p && ptr_equal(cookie,ktest_equal_data);
576 return p;
577 }
578
579 int
ktest_equal_iakerb_finished(krb5_iakerb_finished * ref,krb5_iakerb_finished * var)580 ktest_equal_iakerb_finished(krb5_iakerb_finished *ref,
581 krb5_iakerb_finished *var)
582 {
583 int p = TRUE;
584 if (ref == var) return TRUE;
585 else if (ref == NULL || var == NULL) return FALSE;
586 p = p && struct_equal(checksum,ktest_equal_checksum);
587 return p;
588 }
589
590 static int
ktest_equal_fast_finished(krb5_fast_finished * ref,krb5_fast_finished * var)591 ktest_equal_fast_finished(krb5_fast_finished *ref, krb5_fast_finished *var)
592 {
593 int p = TRUE;
594 if (ref == var) return TRUE;
595 else if (ref == NULL || var == NULL) return FALSE;
596 p = p && scalar_equal(timestamp);
597 p = p && scalar_equal(usec);
598 p = p && ptr_equal(client, ktest_equal_principal_data);
599 p = p && struct_equal(ticket_checksum, ktest_equal_checksum);
600 return p;
601 }
602
603 int
ktest_equal_fast_response(krb5_fast_response * ref,krb5_fast_response * var)604 ktest_equal_fast_response(krb5_fast_response *ref, krb5_fast_response *var)
605 {
606 int p = TRUE;
607 if (ref == var) return TRUE;
608 else if (ref == NULL || var == NULL) return FALSE;
609 p = p && ptr_equal(padata, ktest_equal_sequence_of_pa_data);
610 p = p && ptr_equal(strengthen_key, ktest_equal_keyblock);
611 p = p && ptr_equal(finished, ktest_equal_fast_finished);
612 p = p && scalar_equal(nonce);
613 return p;
614 }
615
616 static int
ktest_equal_algorithm_identifier(krb5_algorithm_identifier * ref,krb5_algorithm_identifier * var)617 ktest_equal_algorithm_identifier(krb5_algorithm_identifier *ref,
618 krb5_algorithm_identifier *var)
619 {
620 int p = TRUE;
621 if (ref == var) return TRUE;
622 else if (ref == NULL || var == NULL) return FALSE;
623 p = p && equal_str(algorithm);
624 p = p && equal_str(parameters);
625 return p;
626 }
627
628 int
ktest_equal_otp_tokeninfo(krb5_otp_tokeninfo * ref,krb5_otp_tokeninfo * var)629 ktest_equal_otp_tokeninfo(krb5_otp_tokeninfo *ref, krb5_otp_tokeninfo *var)
630 {
631 int p = TRUE;
632 if (ref == var) return TRUE;
633 else if (ref == NULL || var == NULL) return FALSE;
634 p = p && scalar_equal(flags);
635 p = p && equal_str(vendor);
636 p = p && equal_str(challenge);
637 p = p && scalar_equal(length);
638 p = p && scalar_equal(format);
639 p = p && equal_str(token_id);
640 p = p && equal_str(alg_id);
641 p = p && ptr_equal(supported_hash_alg,
642 ktest_equal_sequence_of_algorithm_identifier);
643 p = p && scalar_equal(iteration_count);
644 return p;
645 }
646
647 int
ktest_equal_pa_otp_challenge(krb5_pa_otp_challenge * ref,krb5_pa_otp_challenge * var)648 ktest_equal_pa_otp_challenge(krb5_pa_otp_challenge *ref,
649 krb5_pa_otp_challenge *var)
650 {
651 int p = TRUE;
652 if (ref == var) return TRUE;
653 else if (ref == NULL || var == NULL) return FALSE;
654 p = p && equal_str(nonce);
655 p = p && equal_str(service);
656 p = p && ptr_equal(tokeninfo, ktest_equal_sequence_of_otp_tokeninfo);
657 p = p && equal_str(salt);
658 p = p && equal_str(s2kparams);
659 return p;
660 }
661
662 int
ktest_equal_pa_otp_req(krb5_pa_otp_req * ref,krb5_pa_otp_req * var)663 ktest_equal_pa_otp_req(krb5_pa_otp_req *ref, krb5_pa_otp_req *var)
664 {
665 int p = TRUE;
666 if (ref == var) return TRUE;
667 else if (ref == NULL || var == NULL) return FALSE;
668 p = p && scalar_equal(flags);
669 p = p && equal_str(nonce);
670 p = p && struct_equal(enc_data, ktest_equal_enc_data);
671 p = p && ptr_equal(hash_alg, ktest_equal_algorithm_identifier);
672 p = p && scalar_equal(iteration_count);
673 p = p && equal_str(otp_value);
674 p = p && equal_str(pin);
675 p = p && equal_str(challenge);
676 p = p && scalar_equal(time);
677 p = p && equal_str(counter);
678 p = p && scalar_equal(format);
679 p = p && equal_str(token_id);
680 p = p && equal_str(alg_id);
681 p = p && equal_str(vendor);
682 return p;
683 }
684
685 #ifdef ENABLE_LDAP
686 static int
equal_key_data(krb5_key_data * ref,krb5_key_data * var)687 equal_key_data(krb5_key_data *ref, krb5_key_data *var)
688 {
689 int p = TRUE;
690 if (ref == var) return TRUE;
691 else if (ref == NULL || var == NULL) return FALSE;
692 p = p && scalar_equal(key_data_type[0]);
693 p = p && scalar_equal(key_data_type[1]);
694 p = p && len_equal(key_data_length[0],key_data_contents[0],
695 ktest_equal_array_of_octet);
696 p = p && len_equal(key_data_length[1],key_data_contents[1],
697 ktest_equal_array_of_octet);
698 return p;
699 }
700
701 static int
equal_key_data_array(int n,krb5_key_data * ref,krb5_key_data * val)702 equal_key_data_array(int n, krb5_key_data *ref, krb5_key_data *val)
703 {
704 int i, p = TRUE;
705 for (i = 0; i < n; i++) {
706 p = p && equal_key_data(ref+i, val+i);
707 }
708 return p;
709 }
710
711 int
ktest_equal_ldap_sequence_of_keys(ldap_seqof_key_data * ref,ldap_seqof_key_data * var)712 ktest_equal_ldap_sequence_of_keys(ldap_seqof_key_data *ref,
713 ldap_seqof_key_data *var)
714 {
715 int p = TRUE;
716 if (ref == var) return TRUE;
717 else if (ref == NULL || var == NULL) return FALSE;
718 p = p && scalar_equal(mkvno);
719 p = p && scalar_equal(kvno);
720 p = p && len_equal(n_key_data,key_data,equal_key_data_array);
721 return p;
722 }
723 #endif
724
725 /**** arrays ****************************************************************/
726
727 int
ktest_equal_array_of_data(int length,krb5_data * ref,krb5_data * var)728 ktest_equal_array_of_data(int length, krb5_data *ref, krb5_data *var)
729 {
730 int i,p = TRUE;
731
732 if (length == 0 || ref == var) return TRUE;
733 else if (ref == NULL || var == NULL) return FALSE;
734 for (i=0; i<(length); i++) {
735 p = p && ktest_equal_data(&(ref[i]),&(var[i]));
736 }
737 return p;
738 }
739
740 int
ktest_equal_array_of_octet(unsigned int length,krb5_octet * ref,krb5_octet * var)741 ktest_equal_array_of_octet(unsigned int length, krb5_octet *ref,
742 krb5_octet *var)
743 {
744 unsigned int i, p = TRUE;
745
746 if (length == 0 || ref == var) return TRUE;
747 else if (ref == NULL || var == NULL) return FALSE;
748 for (i=0; i<length; i++)
749 p = p && (ref[i] == var[i]);
750 return p;
751 }
752
753 int
ktest_equal_array_of_char(unsigned int length,char * ref,char * var)754 ktest_equal_array_of_char(unsigned int length, char *ref, char *var)
755 {
756 unsigned int i, p = TRUE;
757
758 if (length == 0 || ref == var) return TRUE;
759 else if (ref == NULL || var == NULL) return FALSE;
760 for (i=0; i<length; i++)
761 p = p && (ref[i] == var[i]);
762 return p;
763 }
764
765 int
ktest_equal_array_of_enctype(int length,krb5_enctype * ref,krb5_enctype * var)766 ktest_equal_array_of_enctype(int length, krb5_enctype *ref, krb5_enctype *var)
767 {
768 int i, p = TRUE;
769
770 if (length == 0 || ref == var) return TRUE;
771 else if (ref == NULL || var == NULL) return FALSE;
772 for (i=0; i<length; i++)
773 p = p && (ref[i] == var[i]);
774 return p;
775 }
776
777 #define array_compare(comparator) \
778 int i,p = TRUE; \
779 if (ref == var) return TRUE; \
780 if (!ref || !ref[0]) \
781 return (!var || !var[0]); \
782 if (!var || !var[0]) return FALSE; \
783 for (i=0; ref[i] != NULL && var[i] != NULL; i++) \
784 p = p && comparator(ref[i],var[i]); \
785 if (ref[i] == NULL && var[i] == NULL) return p; \
786 else return FALSE
787
788 int
ktest_equal_authorization_data(krb5_authdata ** ref,krb5_authdata ** var)789 ktest_equal_authorization_data(krb5_authdata **ref, krb5_authdata **var)
790 {
791 array_compare(ktest_equal_authdata);
792 }
793
794 int
ktest_equal_addresses(krb5_address ** ref,krb5_address ** var)795 ktest_equal_addresses(krb5_address **ref, krb5_address **var)
796 {
797 array_compare(ktest_equal_address);
798 }
799
800 int
ktest_equal_last_req(krb5_last_req_entry ** ref,krb5_last_req_entry ** var)801 ktest_equal_last_req(krb5_last_req_entry **ref, krb5_last_req_entry **var)
802 {
803 array_compare(ktest_equal_last_req_entry);
804 }
805
806 int
ktest_equal_sequence_of_ticket(krb5_ticket ** ref,krb5_ticket ** var)807 ktest_equal_sequence_of_ticket(krb5_ticket **ref, krb5_ticket **var)
808 {
809 array_compare(ktest_equal_ticket);
810 }
811
812 int
ktest_equal_sequence_of_pa_data(krb5_pa_data ** ref,krb5_pa_data ** var)813 ktest_equal_sequence_of_pa_data(krb5_pa_data **ref, krb5_pa_data **var)
814 {
815 array_compare(ktest_equal_pa_data);
816 }
817
818 int
ktest_equal_sequence_of_cred_info(krb5_cred_info ** ref,krb5_cred_info ** var)819 ktest_equal_sequence_of_cred_info(krb5_cred_info **ref, krb5_cred_info **var)
820 {
821 array_compare(ktest_equal_cred_info);
822 }
823
824 int
ktest_equal_sequence_of_principal(krb5_principal * ref,krb5_principal * var)825 ktest_equal_sequence_of_principal(krb5_principal *ref, krb5_principal *var)
826 {
827 array_compare(ktest_equal_principal_data);
828 }
829
830 int
ktest_equal_etype_info(krb5_etype_info_entry ** ref,krb5_etype_info_entry ** var)831 ktest_equal_etype_info(krb5_etype_info_entry **ref, krb5_etype_info_entry **var)
832 {
833 array_compare(ktest_equal_krb5_etype_info_entry);
834 }
835
836 int
ktest_equal_sequence_of_checksum(krb5_checksum ** ref,krb5_checksum ** var)837 ktest_equal_sequence_of_checksum(krb5_checksum **ref, krb5_checksum **var)
838 {
839 array_compare(ktest_equal_checksum);
840 }
841
842 int
ktest_equal_sequence_of_algorithm_identifier(krb5_algorithm_identifier ** ref,krb5_algorithm_identifier ** var)843 ktest_equal_sequence_of_algorithm_identifier(krb5_algorithm_identifier **ref,
844 krb5_algorithm_identifier **var)
845 {
846 array_compare(ktest_equal_algorithm_identifier);
847 }
848
849 int
ktest_equal_sequence_of_otp_tokeninfo(krb5_otp_tokeninfo ** ref,krb5_otp_tokeninfo ** var)850 ktest_equal_sequence_of_otp_tokeninfo(krb5_otp_tokeninfo **ref,
851 krb5_otp_tokeninfo **var)
852 {
853 array_compare(ktest_equal_otp_tokeninfo);
854 }
855
856 int
ktest_equal_sequence_of_spake_factor(krb5_spake_factor ** ref,krb5_spake_factor ** var)857 ktest_equal_sequence_of_spake_factor(krb5_spake_factor **ref,
858 krb5_spake_factor **var)
859 {
860 array_compare(ktest_equal_spake_factor);
861 }
862
863 #ifndef DISABLE_PKINIT
864
865 static int
ktest_equal_pk_authenticator(krb5_pk_authenticator * ref,krb5_pk_authenticator * var)866 ktest_equal_pk_authenticator(krb5_pk_authenticator *ref,
867 krb5_pk_authenticator *var)
868 {
869 int p = TRUE;
870 if (ref == var) return TRUE;
871 else if (ref == NULL || var == NULL) return FALSE;
872 p = p && scalar_equal(cusec);
873 p = p && scalar_equal(ctime);
874 p = p && scalar_equal(nonce);
875 p = p && struct_equal(paChecksum, ktest_equal_checksum);
876 return p;
877 }
878
879 static int
ktest_equal_subject_pk_info(krb5_subject_pk_info * ref,krb5_subject_pk_info * var)880 ktest_equal_subject_pk_info(krb5_subject_pk_info *ref,
881 krb5_subject_pk_info *var)
882 {
883 int p = TRUE;
884 if (ref == var) return TRUE;
885 else if (ref == NULL || var == NULL) return FALSE;
886 p = p && struct_equal(algorithm, ktest_equal_algorithm_identifier);
887 p = p && equal_str(subjectPublicKey);
888 return p;
889 }
890
891 static int
ktest_equal_external_principal_identifier(krb5_external_principal_identifier * ref,krb5_external_principal_identifier * var)892 ktest_equal_external_principal_identifier(
893 krb5_external_principal_identifier *ref,
894 krb5_external_principal_identifier *var)
895 {
896 int p = TRUE;
897 if (ref == var) return TRUE;
898 else if (ref == NULL || var == NULL) return FALSE;
899 p = p && equal_str(subjectName);
900 p = p && equal_str(issuerAndSerialNumber);
901 p = p && equal_str(subjectKeyIdentifier);
902 return p;
903 }
904
905 static int
ktest_equal_sequence_of_external_principal_identifier(krb5_external_principal_identifier ** ref,krb5_external_principal_identifier ** var)906 ktest_equal_sequence_of_external_principal_identifier(
907 krb5_external_principal_identifier **ref,
908 krb5_external_principal_identifier **var)
909 {
910 array_compare(ktest_equal_external_principal_identifier);
911 }
912
913 int
ktest_equal_pa_pk_as_req(krb5_pa_pk_as_req * ref,krb5_pa_pk_as_req * var)914 ktest_equal_pa_pk_as_req(krb5_pa_pk_as_req *ref, krb5_pa_pk_as_req *var)
915 {
916 int p = TRUE;
917 if (ref == var) return TRUE;
918 else if (ref == NULL || var == NULL) return FALSE;
919 p = p && equal_str(signedAuthPack);
920 p = p && ptr_equal(trustedCertifiers,
921 ktest_equal_sequence_of_external_principal_identifier);
922 p = p && equal_str(kdcPkId);
923 return p;
924 }
925
926 static int
ktest_equal_dh_rep_info(krb5_dh_rep_info * ref,krb5_dh_rep_info * var)927 ktest_equal_dh_rep_info(krb5_dh_rep_info *ref, krb5_dh_rep_info *var)
928 {
929 int p = TRUE;
930 if (ref == var) return TRUE;
931 else if (ref == NULL || var == NULL) return FALSE;
932 p = p && equal_str(dhSignedData);
933 p = p && equal_str(serverDHNonce);
934 p = p && ptr_equal(kdfID, ktest_equal_data);
935 return p;
936 }
937
938 int
ktest_equal_pa_pk_as_rep(krb5_pa_pk_as_rep * ref,krb5_pa_pk_as_rep * var)939 ktest_equal_pa_pk_as_rep(krb5_pa_pk_as_rep *ref, krb5_pa_pk_as_rep *var)
940 {
941 int p = TRUE;
942 if (ref == var) return TRUE;
943 else if (ref == NULL || var == NULL) return FALSE;
944 if (ref->choice != var->choice) return FALSE;
945 if (ref->choice == choice_pa_pk_as_rep_dhInfo)
946 p = p && struct_equal(u.dh_Info, ktest_equal_dh_rep_info);
947 else if (ref->choice == choice_pa_pk_as_rep_encKeyPack)
948 p = p && equal_str(u.encKeyPack);
949 return p;
950 }
951
952 static int
ktest_equal_sequence_of_data(krb5_data ** ref,krb5_data ** var)953 ktest_equal_sequence_of_data(krb5_data **ref, krb5_data **var)
954 {
955 array_compare(ktest_equal_data);
956 }
957
958 int
ktest_equal_auth_pack(krb5_auth_pack * ref,krb5_auth_pack * var)959 ktest_equal_auth_pack(krb5_auth_pack *ref, krb5_auth_pack *var)
960 {
961 int p = TRUE;
962 if (ref == var) return TRUE;
963 else if (ref == NULL || var == NULL) return FALSE;
964 p = p && struct_equal(pkAuthenticator, ktest_equal_pk_authenticator);
965 p = p && ptr_equal(clientPublicValue, ktest_equal_subject_pk_info);
966 p = p && ptr_equal(supportedCMSTypes,
967 ktest_equal_sequence_of_algorithm_identifier);
968 p = p && equal_str(clientDHNonce);
969 p = p && ptr_equal(supportedKDFs, ktest_equal_sequence_of_data);
970 return p;
971 }
972
973 int
ktest_equal_kdc_dh_key_info(krb5_kdc_dh_key_info * ref,krb5_kdc_dh_key_info * var)974 ktest_equal_kdc_dh_key_info(krb5_kdc_dh_key_info *ref,
975 krb5_kdc_dh_key_info *var)
976 {
977 int p = TRUE;
978 if (ref == var) return TRUE;
979 else if (ref == NULL || var == NULL) return FALSE;
980 p = p && equal_str(subjectPublicKey);
981 p = p && scalar_equal(nonce);
982 p = p && scalar_equal(dhKeyExpiration);
983 return p;
984 }
985
986 int
ktest_equal_reply_key_pack(krb5_reply_key_pack * ref,krb5_reply_key_pack * var)987 ktest_equal_reply_key_pack(krb5_reply_key_pack *ref, krb5_reply_key_pack *var)
988 {
989 int p = TRUE;
990 if (ref == var) return TRUE;
991 else if (ref == NULL || var == NULL) return FALSE;
992 p = p && struct_equal(replyKey, ktest_equal_keyblock);
993 p = p && struct_equal(asChecksum, ktest_equal_checksum);
994 return p;
995 }
996
997 #endif /* not DISABLE_PKINIT */
998
999 int
ktest_equal_kkdcp_message(krb5_kkdcp_message * ref,krb5_kkdcp_message * var)1000 ktest_equal_kkdcp_message(krb5_kkdcp_message *ref, krb5_kkdcp_message *var)
1001 {
1002 int p = TRUE;
1003 if (ref == var) return TRUE;
1004 else if (ref == NULL || var == NULL) return FALSE;
1005 p = p && data_eq(ref->kerb_message, var->kerb_message);
1006 p = p && data_eq(ref->target_domain, var->target_domain);
1007 p = p && scalar_equal(dclocator_hint);
1008 return p;
1009 }
1010
1011 static int
vmac_eq(krb5_verifier_mac * ref,krb5_verifier_mac * var)1012 vmac_eq(krb5_verifier_mac *ref, krb5_verifier_mac *var)
1013 {
1014 int p = TRUE;
1015 if (ref == var) return TRUE;
1016 else if (ref == NULL || var == NULL) return FALSE;
1017 p = p && ptr_equal(princ, ktest_equal_principal_data);
1018 p = p && scalar_equal(kvno);
1019 p = p && scalar_equal(enctype);
1020 p = p && struct_equal(checksum, ktest_equal_checksum);
1021 return p;
1022 }
1023
1024 static int
vmac_list_eq(krb5_verifier_mac ** ref,krb5_verifier_mac ** var)1025 vmac_list_eq(krb5_verifier_mac **ref, krb5_verifier_mac **var)
1026 {
1027 array_compare(vmac_eq);
1028 }
1029
1030 int
ktest_equal_cammac(krb5_cammac * ref,krb5_cammac * var)1031 ktest_equal_cammac(krb5_cammac *ref, krb5_cammac *var)
1032 {
1033 int p = TRUE;
1034 if (ref == var) return TRUE;
1035 else if (ref == NULL || var == NULL) return FALSE;
1036 p = p && ptr_equal(elements, ktest_equal_authorization_data);
1037 p = p && ptr_equal(kdc_verifier, vmac_eq);
1038 p = p && ptr_equal(svc_verifier, vmac_eq);
1039 p = p && ptr_equal(other_verifiers, vmac_list_eq);
1040 return p;
1041 }
1042
1043 int
ktest_equal_secure_cookie(krb5_secure_cookie * ref,krb5_secure_cookie * var)1044 ktest_equal_secure_cookie(krb5_secure_cookie *ref, krb5_secure_cookie *var)
1045 {
1046 int p = TRUE;
1047 if (ref == var) return TRUE;
1048 else if (ref == NULL || var == NULL) return FALSE;
1049 p = p && ktest_equal_sequence_of_pa_data(ref->data, var->data);
1050 p = p && scalar_equal(time);
1051 return p;
1052 }
1053
1054 int
ktest_equal_spake_factor(krb5_spake_factor * ref,krb5_spake_factor * var)1055 ktest_equal_spake_factor(krb5_spake_factor *ref, krb5_spake_factor *var)
1056 {
1057 int p = TRUE;
1058 if (ref == var) return TRUE;
1059 else if (ref == NULL || var == NULL) return FALSE;
1060 p = p && scalar_equal(type);
1061 p = p && ptr_equal(data,ktest_equal_data);
1062 return p;
1063 }
1064
1065 int
ktest_equal_pa_spake(krb5_pa_spake * ref,krb5_pa_spake * var)1066 ktest_equal_pa_spake(krb5_pa_spake *ref, krb5_pa_spake *var)
1067 {
1068 int p = TRUE;
1069 if (ref == var) return TRUE;
1070 else if (ref == NULL || var == NULL) return FALSE;
1071 else if (ref->choice != var->choice) return FALSE;
1072 switch (ref->choice) {
1073 case SPAKE_MSGTYPE_SUPPORT:
1074 p = p && scalar_equal(u.support.ngroups);
1075 p = p && (memcmp(ref->u.support.groups,var->u.support.groups,
1076 ref->u.support.ngroups * sizeof(int32_t)) == 0);
1077 break;
1078 case SPAKE_MSGTYPE_CHALLENGE:
1079 p = p && struct_equal(u.challenge.pubkey,ktest_equal_data);
1080 p = p && ptr_equal(u.challenge.factors,
1081 ktest_equal_sequence_of_spake_factor);
1082 break;
1083 case SPAKE_MSGTYPE_RESPONSE:
1084 p = p && struct_equal(u.response.pubkey,ktest_equal_data);
1085 p = p && struct_equal(u.response.factor,ktest_equal_enc_data);
1086 break;
1087 case SPAKE_MSGTYPE_ENCDATA:
1088 p = p && struct_equal(u.encdata,ktest_equal_enc_data);
1089 break;
1090 default:
1091 break;
1092 }
1093 return p;
1094 }
1095