Kannel: Open Source WAP and SMS gateway  $Revision: 5037 $
wtls_pdusupport.c
Go to the documentation of this file.
1 /* ====================================================================
2  * The Kannel Software License, Version 1.0
3  *
4  * Copyright (c) 2001-2016 Kannel Group
5  * Copyright (c) 1998-2001 WapIT Ltd.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  * notice, this list of conditions and the following disclaimer.
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  * notice, this list of conditions and the following disclaimer in
17  * the documentation and/or other materials provided with the
18  * distribution.
19  *
20  * 3. The end-user documentation included with the redistribution,
21  * if any, must include the following acknowledgment:
22  * "This product includes software developed by the
23  * Kannel Group (http://www.kannel.org/)."
24  * Alternately, this acknowledgment may appear in the software itself,
25  * if and wherever such third-party acknowledgments normally appear.
26  *
27  * 4. The names "Kannel" and "Kannel Group" must not be used to
28  * endorse or promote products derived from this software without
29  * prior written permission. For written permission, please
30  * contact org@kannel.org.
31  *
32  * 5. Products derived from this software may not be called "Kannel",
33  * nor may "Kannel" appear in their name, without prior written
34  * permission of the Kannel Group.
35  *
36  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
37  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
38  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
39  * DISCLAIMED. IN NO EVENT SHALL THE KANNEL GROUP OR ITS CONTRIBUTORS
40  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
41  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
42  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
43  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
44  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
45  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
46  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
47  * ====================================================================
48  *
49  * This software consists of voluntary contributions made by many
50  * individuals on behalf of the Kannel Group. For more information on
51  * the Kannel Group, please see <http://www.kannel.org/>.
52  *
53  * Portions of this software are based upon software originally written at
54  * WapIT Ltd., Helsinki, Finland for the Kannel project.
55  */
56 
57 /*
58  * wtls_support.c: pack and unpack WTLS packets
59  *
60  * Support functions for packing and unpacking PDUs
61  *
62  * Nikos Balkanas, Inaccess Networks (2009)
63  *
64  */
65 
66 #include "gwlib/gwlib.h"
67 
68 #ifdef HAVE_WTLS_OPENSSL
69 
70 #include "wtls_pdu.h"
71 #include "wtls_pdusupport.h"
72 #include "wtls_statesupport.h"
73 
74 extern PublicKeyAlgorithm public_key_algo;
75 extern SignatureAlgorithm signature_algo;
76 
77 /* Function prototypes */
78 
79 void destroy_octstr(Octstr * data);
80 void destroy_octstr16(Octstr * data);
81 void destroy_octstr_fixed(Octstr * data);
82 void destroy_dhparams(DHParameters * dhparams);
83 void destroy_ecparams(ECParameters * ecparams);
84 void destroy_public_key(PublicKey * key);
85 void destroy_rsa_secret(RSASecret * secret);
86 void destroy_key_exchange_id(KeyExchangeId * keyexid);
87 void destroy_signature(Signature * sig);
88 void dump_void16(char *dbg, int level, int i);
89 
90 /*****************************************************************
91  * PACK functions
92  */
93 
94 int pack_int16(Octstr * data, long charpos, int i)
95 {
96  octstr_append_char(data, (i & 0xFF00) >> 8);
97  charpos += 1;
98  octstr_append_char(data, i & 0x00FF);
99  charpos += 1;
100  return charpos;
101 }
102 
103 int pack_int32(Octstr * data, long charpos, long i)
104 {
105  charpos = pack_int16(data, charpos, (i & 0xFFFF0000) >> 16);
106  charpos = pack_int16(data, charpos, i & 0xFFFF);
107  return charpos;
108 }
109 
110 int pack_octstr(Octstr * data, long charpos, Octstr * opaque)
111 {
112  octstr_append_char(data, octstr_len(opaque));
113  charpos += 1;
114  octstr_insert(data, opaque, octstr_len(data));
115  charpos += octstr_len(opaque);
116  return charpos;
117 }
118 
119 int pack_octstr16(Octstr * data, long charpos, Octstr * opaque)
120 {
121  charpos += pack_int16(data, charpos, octstr_len(opaque));
122  octstr_insert(data, opaque, octstr_len(data));
123  charpos += octstr_len(opaque);
124  return charpos;
125 }
126 
127 int pack_octstr_fixed(Octstr * data, long charpos, Octstr * opaque)
128 {
129  octstr_insert(data, opaque, octstr_len(data));
130  charpos += octstr_len(opaque);
131  return charpos;
132 }
133 
134 int pack_random(Octstr * data, long charpos, Random * random)
135 {
136  charpos = pack_int32(data, charpos, random->gmt_unix_time);
137  charpos = pack_octstr_fixed(data, charpos, random->random_bytes);
138  return charpos;
139 }
140 
141 int pack_dhparams(Octstr * data, long charpos, DHParameters * dhparams)
142 {
143  octstr_append_char(data, dhparams->dh_e);
144  charpos += 1;
145  charpos = pack_octstr16(data, charpos, dhparams->dh_p);
146  charpos = pack_octstr16(data, charpos, dhparams->dh_g);
147  return charpos;
148 }
149 
150 int pack_ecparams(Octstr * data, long charpos, ECParameters * ecparams)
151 {
152  /* field */
153  octstr_append_char(data, ecparams->field);
154  charpos += 1;
155  switch (ecparams->field) {
156  case ec_prime_p:
157  charpos = pack_octstr(data, charpos, ecparams->prime_p);
158  break;
160  /* m (16 bits) */
161  charpos = pack_int16(data, charpos, ecparams->m);
162  /* basis */
163  octstr_append_char(data, ecparams->basis);
164  charpos += 1;
165  switch (ecparams->basis) {
166  case ec_basis_onb:
167  break;
168  case ec_basis_trinomial:
169  charpos = pack_int16(data, charpos, ecparams->k);
170  break;
172  charpos = pack_int16(data, charpos, ecparams->k1);
173  charpos = pack_int16(data, charpos, ecparams->k2);
174  charpos = pack_int16(data, charpos, ecparams->k3);
175  break;
176  case ec_basis_polynomial:
177  charpos =
178  pack_octstr(data, charpos, ecparams->irreducible);
179  break;
180  }
181  break;
182  }
183  /* pack the ECCurve */
184  charpos = pack_octstr(data, charpos, ecparams->curve->a);
185  charpos = pack_octstr(data, charpos, ecparams->curve->b);
186  charpos = pack_octstr(data, charpos, ecparams->curve->seed);
187  /* pack the ECPoint */
188  charpos = pack_octstr(data, charpos, ecparams->base->point);
189  /* order and cofactor */
190  charpos = pack_octstr(data, charpos, ecparams->order);
191  charpos = pack_octstr(data, charpos, ecparams->cofactor);
192 
193  return charpos;
194 }
195 
196 int pack_param_spec(Octstr * data, long charpos, ParameterSpecifier * pspec)
197 {
198  if (pspec == NULL) {
199  octstr_append_char(data, 0);
200  charpos += 1;
201  return charpos;
202  }
203 
204  /* index */
205  octstr_append_char(data, pspec->param_index);
206  charpos += 1;
207  /* ParameterSet struct */
208  octstr_append_char(data, pspec->param_set->length);
209  charpos += 1;
210  switch (public_key_algo) {
212  pack_dhparams(data, charpos, pspec->param_set->dhparams);
213  break;
215  pack_ecparams(data, charpos, pspec->param_set->ecparams);
216  break;
217  default:
218  break;
219  }
220  return charpos;
221 }
222 
223 int pack_public_key(Octstr * data, long charpos, PublicKey * key,
224  PublicKeyType key_type)
225 {
226  switch (key_type) {
227  case ecdh_key:
228  charpos = pack_octstr(data, charpos, key->ecdh_pubkey->point);
229  break;
230  case ecdsa_key:
231  charpos = pack_octstr(data, charpos, key->ecdsa_pubkey->point);
232  break;
233  case rsa_key:
234  charpos = pack_rsa_pubkey(data, charpos, key->rsa_pubkey);
235  break;
236  }
237  return charpos;
238 }
239 
240 int pack_rsa_pubkey(Octstr * data, long charpos, RSAPublicKey * key)
241 {
242  charpos = pack_octstr16(data, charpos, key->rsa_exponent);
243  charpos = pack_octstr16(data, charpos, key->rsa_modulus);
244  return charpos;
245 }
246 
247 int pack_ec_pubkey(Octstr * data, long charpos, ECPublicKey * key)
248 {
249  charpos = pack_octstr(data, charpos, key->point);
250  return charpos;
251 }
252 
253 int pack_dh_pubkey(Octstr * data, long charpos, DHPublicKey * key)
254 {
255  charpos = pack_octstr16(data, charpos, key->dh_Y);
256  return charpos;
257 }
258 
259 int pack_rsa_secret(Octstr * data, long charpos, RSASecret * secret)
260 {
261  octstr_append_char(data, secret->client_version);
262  charpos += 1;
263  charpos = pack_array(data, charpos, secret->random);
264  return charpos;
265 }
266 
267 int pack_rsa_encrypted_secret(Octstr * data, long charpos,
268  RSAEncryptedSecret * secret)
269 {
270  charpos = pack_octstr16(data, charpos, secret->encrypted_secret);
271  return charpos;
272 }
273 
274 int pack_key_exchange_id(Octstr * data, long charpos, KeyExchangeId * keyexid)
275 {
276  octstr_set_char(data, charpos, keyexid->key_exchange_suite);
277  charpos += 1;
278  charpos = pack_param_spec(data, charpos, keyexid->param_specif);
279  charpos = pack_identifier(data, charpos, keyexid->identifier);
280  return charpos;
281 }
282 
283 int pack_array(Octstr * data, long charpos, List * array)
284 {
285  int i;
286  long pos = 0;
287  Octstr *buffer;
288 
289  /* we need to know the length in bytes of the list
290  so we pack everything in a buffer for now. */
291  buffer = octstr_create("");
292 
293  /* pack each entry in the buffer */
294  for (i = 0; i < gwlist_len(array); i++) {
295  pos = pack_octstr(buffer, pos, (Octstr *) gwlist_get(array, i));
296  }
297 
298  /* now we know the size of the list */
299  charpos = pack_int16(data, charpos, pos);
300 
301  /* append the buffer */
302  charpos = pack_octstr_fixed(data, charpos, buffer);
303 
304  return charpos;
305 }
306 
307 int pack_key_list(Octstr * data, long charpos, List * key_list)
308 {
309  int i;
310  long pos = 0;
311  Octstr *buffer;
312  KeyExchangeId *keyexid;
313 
314  /* we need to know the length in bytes of the list
315  so we pack everything in a buffer for now. */
316  buffer = octstr_create("");
317 
318  /* pack the KeyExchangeIds */
319  for (i = 0; i < gwlist_len(key_list); i++) {
320  keyexid = (KeyExchangeId *) gwlist_get(key_list, i);
321 
322  pos = pack_key_exchange_id(buffer, pos, keyexid);
323  }
324 
325  /* now we know the size of the list */
326  charpos = pack_int16(data, charpos, pos);
327 
328  /* append the buffer */
329  charpos = pack_octstr_fixed(data, charpos, buffer);
330 
331  return charpos;
332 }
333 
334 int pack_ciphersuite_list(Octstr * data, long charpos, List * ciphersuites)
335 {
336  int i;
337  CipherSuite *cs;
338 
339  /* vector starts with its length
340  Each element uses 2 bytes */
341  octstr_set_char(data, charpos, gwlist_len(ciphersuites) * 2);
342  charpos += 1;
343 
344  /* pack the CipherSuites */
345  for (i = 0; i < gwlist_len(ciphersuites); i++) {
346  cs = (CipherSuite *) gwlist_get(ciphersuites, i);
347  octstr_set_char(data, charpos, cs->bulk_cipher_algo);
348  charpos += 1;
349  octstr_set_char(data, charpos, cs->mac_algo);
350  charpos += 1;
351  }
352 
353  return charpos;
354 }
355 
356 int pack_compression_method_list(Octstr * data, long charpos,
357  List * compmethod_list)
358 {
359  int i;
360 
361  /* vector starts with its length */
362  octstr_set_char(data, charpos, gwlist_len(compmethod_list));
363  charpos += 1;
364 
365  /* pack the CompressionMethods */
366  for (i = 0; i < gwlist_len(compmethod_list); i++) {
367  octstr_set_char(data, charpos,
368  (CompressionMethod) gwlist_get(compmethod_list,
369  i));
370  charpos += 1;
371  }
372 
373  return charpos;
374 }
375 
376 int pack_identifier(Octstr * data, long charpos, Identifier * ident)
377 {
378  switch (ident->id_type) {
379  case text:
380  octstr_set_char(data, charpos, ident->charset);
381  charpos += 1;
382  charpos = pack_octstr(data, charpos, ident->name);
383  break;
384  case binary:
385  charpos = pack_octstr(data, charpos, ident->identifier);
386  break;
387  case key_hash_sha:
388  charpos = pack_octstr(data, charpos, ident->key_hash);
389  break;
390  case x509_name:
391  charpos = pack_octstr(data, charpos, ident->distinguished_name);
392  break;
393  default:
394  break;
395  }
396  return charpos;
397 }
398 
399 int pack_signature(Octstr * data, long charpos, Signature * sig)
400 {
401  switch (signature_algo) {
402  case ecdsa_sha:
403  case rsa_sha:
404  charpos = pack_array(data, charpos, sig->sha_hash);
405  break;
406  default:
407  break;
408  }
409  return charpos;
410 }
411 
412 int pack_wtls_certificate(Octstr * data, long charpos, WTLSCertificate * cert)
413 {
414  /* === pack ToBeSignedCertificate === */
415  /* version */
416  octstr_set_char(data, charpos,
418  charpos += 1;
419  /* sig algo */
420  octstr_set_char(data, charpos, cert->tobesigned_cert->signature_algo);
421  charpos += 1;
422  /* identifier */
423  octstr_set_char(data, charpos, cert->tobesigned_cert->issuer->id_type);
424  charpos += 1;
425  /* issuer Identifier */
426  charpos = pack_identifier(data, charpos, cert->tobesigned_cert->issuer);
427  /* validity periods */
428  charpos =
429  pack_int32(data, charpos, cert->tobesigned_cert->valid_not_before);
430  charpos =
431  pack_int32(data, charpos, cert->tobesigned_cert->valid_not_after);
432  /* subject Identifier */
433  charpos =
434  pack_identifier(data, charpos, cert->tobesigned_cert->subject);
435  /* public_key_type */
436  octstr_set_char(data, charpos, cert->tobesigned_cert->pubkey_type);
437  charpos += 1;
438  /* parameter specifier */
439  charpos =
440  pack_param_spec(data, charpos, cert->tobesigned_cert->param_spec);
441  /* public key */
442  charpos = pack_public_key(data, charpos, cert->tobesigned_cert->pubkey,
444 
445  /* === pack Signature === */
446  charpos = pack_signature(data, charpos, cert->signature);
447  return charpos;
448 }
449 
450 /*****************************************************************
451  * UNPACK functions
452  */
453 
454 int unpack_int16(Octstr * data, long *charpos)
455 {
456  int n;
457 
458  n = octstr_get_char(data, *charpos) << 8;
459  *charpos += 1;
460  n += octstr_get_char(data, *charpos);
461  *charpos += 1;
462  return n;
463 }
464 
465 long unpack_int32(Octstr * data, long *charpos)
466 {
467  int n;
468 
469  n = octstr_get_char(data, *charpos);
470  n = n << 8;
471  *charpos += 1;
472  n += octstr_get_char(data, *charpos);
473  n = n << 8;
474  *charpos += 1;
475  n += octstr_get_char(data, *charpos);
476  n = n << 8;
477  *charpos += 1;
478  n += octstr_get_char(data, *charpos);
479  *charpos += 1;
480  return n;
481 }
482 
483 Octstr *unpack_octstr(Octstr * data, long *charpos)
484 {
485  int length;
486  Octstr *opaque;
487 
488  length = octstr_get_char(data, *charpos);
489  *charpos += 1;
490  opaque = octstr_copy(data, *charpos, length);
491  *charpos += length;
492  return opaque;
493 }
494 
495 Octstr *unpack_octstr16(Octstr * data, long *charpos)
496 {
497  long length;
498  Octstr *opaque;
499 
500  length = unpack_int16(data, charpos);
501  opaque = octstr_copy(data, *charpos, length);
502  *charpos += length;
503  return opaque;
504 }
505 
506 Octstr *unpack_octstr_fixed(Octstr * data, long *charpos, long length)
507 {
508  Octstr *opaque;
509 
510  opaque = octstr_copy(data, *charpos, length);
511  *charpos += length;
512  return opaque;
513 }
514 
515 Random *unpack_random(Octstr * data, long *charpos)
516 {
517  Random *random;
518  /* create the Random structure */
519  random = (Random *) gw_malloc(sizeof(Random));
520 
521  random->gmt_unix_time = unpack_int32(data, charpos);
522  random->random_bytes = unpack_octstr_fixed(data, charpos, 12);
523  return random;
524 }
525 
526 DHParameters *unpack_dhparams(Octstr * data, long *charpos)
527 {
528  DHParameters *dhparams;
529 
530  /* create the DHParameters */
531  dhparams = (DHParameters *) gw_malloc(sizeof(DHParameters));
532 
533  dhparams->dh_e = octstr_get_char(data, *charpos);
534  *charpos += 1;
535  dhparams->dh_p = unpack_octstr16(data, charpos);
536  dhparams->dh_g = unpack_octstr16(data, charpos);
537  return dhparams;
538 }
539 
540 ECParameters *unpack_ecparams(Octstr * data, long *charpos)
541 {
542  ECParameters *ecparams;
543 
544  /* create the ECParameters */
545  ecparams = (ECParameters *) gw_malloc(sizeof(ECParameters));
546 
547  /* field */
548  ecparams->field = octstr_get_char(data, *charpos);
549  *charpos += 1;
550  switch (ecparams->field) {
551  case ec_prime_p:
552  ecparams->prime_p = unpack_octstr(data, charpos);
553  break;
555  /* m (16 bits) */
556  ecparams->m = unpack_int16(data, charpos);
557  /* basis */
558  ecparams->basis = octstr_get_char(data, *charpos);
559  *charpos += 1;
560  switch (ecparams->basis) {
561  case ec_basis_onb:
562  break;
563  case ec_basis_trinomial:
564  ecparams->k = unpack_int16(data, charpos);
565  break;
567  ecparams->k1 = unpack_int16(data, charpos);
568  ecparams->k2 = unpack_int16(data, charpos);
569  ecparams->k3 = unpack_int16(data, charpos);
570  break;
571  case ec_basis_polynomial:
572  ecparams->irreducible = unpack_octstr(data, charpos);
573  break;
574  }
575  break;
576  }
577  /* pack the ECCurve */
578  ecparams->curve->a = unpack_octstr(data, charpos);
579  ecparams->curve->b = unpack_octstr(data, charpos);
580  ecparams->curve->seed = unpack_octstr(data, charpos);
581  /* pack the ECPoint */
582  ecparams->base->point = unpack_octstr(data, charpos);
583  /* order and cofactor */
584  ecparams->order = unpack_octstr(data, charpos);
585  ecparams->cofactor = unpack_octstr(data, charpos);
586 
587  return ecparams;
588 }
589 
590 ParameterSpecifier *unpack_param_spec(Octstr * data, long *charpos)
591 {
592  ParameterSpecifier *pspec;
593 
594  /* create the ParameterSpecifier */
595  pspec = (ParameterSpecifier *) gw_malloc(sizeof(ParameterSpecifier));
596 
597  /* index */
598  pspec->param_index = octstr_get_char(data, *charpos);
599  *charpos += 1;
600  /* ParameterSet struct */
601  if (pspec->param_index == 255) {
602  pspec->param_set =
603  (ParameterSet *) gw_malloc(sizeof(ParameterSet));
604  pspec->param_set->length = octstr_get_char(data, *charpos);
605  *charpos += 1;
606  switch (public_key_algo) {
608  pspec->param_set->dhparams =
609  unpack_dhparams(data, charpos);
610  break;
612  pspec->param_set->ecparams =
613  unpack_ecparams(data, charpos);
614  break;
615  default:
616  break;
617  }
618  }
619  return pspec;
620 }
621 
622 RSAPublicKey *unpack_rsa_pubkey(Octstr * data, long *charpos)
623 {
624  RSAPublicKey *key;
625 
626  /* create the RSAPublicKey */
627  key = (RSAPublicKey *) gw_malloc(sizeof(RSAPublicKey));
628  key->rsa_exponent = unpack_octstr16(data, charpos);
629  key->rsa_modulus = unpack_octstr16(data, charpos);
630  return key;
631 }
632 
633 DHPublicKey *unpack_dh_pubkey(Octstr * data, long *charpos)
634 {
635  DHPublicKey *key;
636 
637  /* create the DHPublicKey */
638  key = (DHPublicKey *) gw_malloc(sizeof(DHPublicKey));
639  key->dh_Y = unpack_octstr16(data, charpos);
640  return key;
641 }
642 
643 ECPublicKey *unpack_ec_pubkey(Octstr * data, long *charpos)
644 {
645  ECPublicKey *key;
646 
647  /* create the ECPublicKey */
648  key = (ECPublicKey *) gw_malloc(sizeof(ECPublicKey));
649  key->point = unpack_octstr(data, charpos);
650  return key;
651 }
652 
653 RSASecret *unpack_rsa_secret(Octstr * data, long *charpos)
654 {
655  RSASecret *secret;
656 
657  /* create the RSASecret */
658  secret = (RSASecret *) gw_malloc(sizeof(RSASecret));
659  secret->client_version = octstr_get_char(data, *charpos);
660  *charpos += 1;
661  secret->random = unpack_array(data, charpos);
662 
663  return secret;
664 }
665 
667 {
668  RSAEncryptedSecret *secret;
669 
670  /* create the RSASecret */
671  secret = (RSAEncryptedSecret *) gw_malloc(sizeof(RSAEncryptedSecret));
672  //secret->encrypted_secret = unpack_octstr16(data, charpos);
673  secret->encrypted_secret =
674  unpack_octstr_fixed(data, charpos, octstr_len(data) - *charpos);
675  return secret;
676 }
677 
678 PublicKey *unpack_public_key(Octstr * data, long *charpos,
679  PublicKeyType key_type)
680 {
681  PublicKey *key;
682 
683  /* create the PublicKey */
684  key = (PublicKey *) gw_malloc(sizeof(PublicKey));
685  switch (key_type) {
686  case ecdh_key:
687  key->ecdh_pubkey = unpack_ec_pubkey(data, charpos);
688  break;
689  case ecdsa_key:
690  key->ecdsa_pubkey = unpack_ec_pubkey(data, charpos);
691  break;
692  case rsa_key:
693  key->rsa_pubkey = unpack_rsa_pubkey(data, charpos);
694  break;
695  }
696  return key;
697 }
698 
699 KeyExchangeId *unpack_key_exchange_id(Octstr * data, long *charpos)
700 {
701  KeyExchangeId *keyexid;
702 
703  /* create the KeyExchangeID */
704  keyexid = (KeyExchangeId *) gw_malloc(sizeof(KeyExchangeId));
705 
706  keyexid->key_exchange_suite = octstr_get_char(data, *charpos);
707  *charpos += 1;
708  keyexid->param_specif = unpack_param_spec(data, charpos);
709  keyexid->identifier = unpack_identifier(data, charpos);
710  return keyexid;
711 }
712 
713 List *unpack_array(Octstr * data, long *charpos)
714 {
715  int i;
716  int array_length;
717  List *array;
718 
719  /* create the list */
720  array = gwlist_create();
721 
722  /* get the size of the array */
723  array_length = octstr_get_char(data, *charpos);
724  *charpos += 1;
725 
726  /* store each entry in the list */
727  for (i = 0; i < array_length; i++) {
728  gwlist_append(array, (void *)unpack_octstr(data, charpos));
729  }
730 
731  return array;
732 }
733 
734 List *unpack_key_list(Octstr * data, long *charpos)
735 {
736  KeyExchangeId *keyexid;
737  List *key_list;
738  int gwlist_length;
739  long endpos;
740 
741  /* create the list */
742  key_list = gwlist_create();
743 
744  /* get the size of the array */
745  gwlist_length = unpack_int16(data, charpos);
746  endpos = *charpos + gwlist_length;
747 
748  /* unpack the KeyExchangeIds */
749  while (*charpos < endpos) {
750  keyexid = unpack_key_exchange_id(data, charpos);
751  gwlist_append(key_list, (void *)keyexid);
752  }
753  return key_list;
754 }
755 
756 List *unpack_ciphersuite_list(Octstr * data, long *charpos)
757 {
758  List *ciphersuites;
759  int gwlist_length;
760  int i;
761  CipherSuite *cs;
762 
763  /* create the list */
764  ciphersuites = gwlist_create();
765 
766  /* get the size of the array (in bytes, not elements) */
767  gwlist_length = octstr_get_char(data, *charpos);
768  *charpos += 1;
769 
770  /* unpack the CipherSuites */
771  for (i = 0; i < gwlist_length; i += 2) {
772  cs = (CipherSuite *) gw_malloc(sizeof(CipherSuite));
773  cs->bulk_cipher_algo = octstr_get_char(data, *charpos);
774  *charpos += 1;
775  cs->mac_algo = octstr_get_char(data, *charpos);
776  *charpos += 1;
777  gwlist_append(ciphersuites, (void *)cs);
778  }
779 
780  return ciphersuites;
781 }
782 
783 List *unpack_compression_method_list(Octstr * data, long *charpos)
784 {
785  List *compmethod_list;
786  int gwlist_length;
787  int i;
788  CompressionMethod *cm;
789 
790  /* create the list */
791  compmethod_list = gwlist_create();
792 
793  /* get the size of the array */
794  gwlist_length = octstr_get_char(data, *charpos);
795  *charpos += 1;
796 
797  /* unpack the CompressionMethods */
798  for (i = 0; i < gwlist_length; i++) {
799  cm = gw_malloc(sizeof(CompressionMethod));
800  *cm = octstr_get_char(data, *charpos);
801  gwlist_append(compmethod_list, (void *)cm);
802  }
803 
804  return compmethod_list;
805 }
806 
807 Identifier *unpack_identifier(Octstr * data, long *charpos)
808 {
809  Identifier *ident;
810 
811  /* create Identifier */
812  ident = (Identifier *) gw_malloc(sizeof(Identifier));
813 
814  ident->id_type = octstr_get_char(data, *charpos);
815  *charpos += 1;
816  switch (ident->id_type) {
817  case text:
818  ident->charset = octstr_get_char(data, *charpos);
819  *charpos += 1;
820  ident->name = unpack_octstr(data, charpos);
821  break;
822  case binary:
823  ident->identifier = unpack_octstr(data, charpos);
824  break;
825  case key_hash_sha:
826  ident->key_hash = unpack_octstr(data, charpos);
827  break;
828  case x509_name:
829  ident->distinguished_name = unpack_octstr(data, charpos);
830  break;
831  default:
832  break;
833  }
834  return ident;
835 }
836 
837 Signature *unpack_signature(Octstr * data, long *charpos)
838 {
839  Signature *sig;
840 
841  /* create Signature */
842  sig = (Signature *) gw_malloc(sizeof(Signature));
843 
844  switch (signature_algo) {
845  case ecdsa_sha:
846  case rsa_sha:
847  sig->sha_hash = unpack_array(data, charpos);
848  break;
849  default:
850  break;
851  }
852  return sig;
853 }
854 
855 WTLSCertificate *unpack_wtls_certificate(Octstr * data, long *charpos)
856 {
857  WTLSCertificate *cert;
858 
859  /* create the Certificate */
860  cert = (WTLSCertificate *) gw_malloc(sizeof(WTLSCertificate));
861 
862  /* === unpack ToBeSignedCertificate === */
863  cert->tobesigned_cert =
864  (ToBeSignedCertificate *) gw_malloc(sizeof(ToBeSignedCertificate));
865  /* version */
867  octstr_get_char(data, *charpos);
868  *charpos += 1;
869  /* sig algo */
870  cert->tobesigned_cert->signature_algo = octstr_get_char(data, *charpos);
871  *charpos += 1;
872  /* identifier */
873  cert->tobesigned_cert->issuer->id_type =
874  octstr_get_char(data, *charpos);
875  *charpos += 1;
876  /* issuer Identifier */
877  cert->tobesigned_cert->issuer = unpack_identifier(data, charpos);
878  /* validity periods */
879  cert->tobesigned_cert->valid_not_before = unpack_int32(data, charpos);
880  cert->tobesigned_cert->valid_not_after = unpack_int32(data, charpos);
881  /* subject Identifier */
882  cert->tobesigned_cert->subject = unpack_identifier(data, charpos);
883  /* public_key_type */
884  cert->tobesigned_cert->pubkey_type = octstr_get_char(data, *charpos);
885  *charpos += 1;
886  /* parameter specifier */
887  cert->tobesigned_cert->param_spec = unpack_param_spec(data, charpos);
888  /* public key */
889  cert->tobesigned_cert->pubkey = unpack_public_key(data, charpos,
890  cert->
891  tobesigned_cert->
892  pubkey_type);
893 
894  /* === pack Signature === */
895  cert->signature = unpack_signature(data, charpos);
896  return cert;
897 }
898 
899 /*****************************************************************
900  * DESTROY functions
901  */
902 
903 void destroy_octstr(Octstr * data)
904 {
905  octstr_destroy(data);
906 }
907 
908 void destroy_octstr16(Octstr * data)
909 {
910  octstr_destroy(data);
911 }
912 
913 void destroy_octstr_fixed(Octstr * data)
914 {
915  octstr_destroy(data);
916 }
917 
918 void destroy_random(Random * random)
919 {
920  octstr_destroy(random->random_bytes);
921  gw_free(random);
922 }
923 
924 void destroy_dhparams(DHParameters * dhparams)
925 {
926  destroy_octstr16(dhparams->dh_p);
927  destroy_octstr16(dhparams->dh_g);
928  gw_free(dhparams);
929 }
930 
931 void destroy_ecparams(ECParameters * ecparams)
932 {
933  /* field */
934  switch (ecparams->field) {
935  case ec_prime_p:
936  octstr_destroy(ecparams->prime_p);
937  break;
939  switch (ecparams->basis) {
940  case ec_basis_onb:
941  break;
942  case ec_basis_trinomial:
943  break;
945  break;
946  case ec_basis_polynomial:
947  octstr_destroy(ecparams->irreducible);
948  break;
949  }
950  break;
951  }
952  /* pack the ECCurve */
953  octstr_destroy(ecparams->curve->a);
954  octstr_destroy(ecparams->curve->b);
955  octstr_destroy(ecparams->curve->seed);
956  /* pack the ECPoint */
957  octstr_destroy(ecparams->base->point);
958  /* order and cofactor */
959  octstr_destroy(ecparams->order);
960  octstr_destroy(ecparams->cofactor);
961 
962  gw_free(ecparams);
963 }
964 
966 {
967  switch (public_key_algo) {
969  destroy_dhparams(pspec->param_set->dhparams);
970  break;
972  destroy_ecparams(pspec->param_set->ecparams);
973  break;
974  default:
975  break;
976  }
977  gw_free(pspec);
978 }
979 
980 void destroy_public_key(PublicKey * key)
981 {
982  if (key->ecdh_pubkey) {
984  gw_free(key->ecdh_pubkey);
985  }
986  if (key->ecdsa_pubkey) {
988  gw_free(key->ecdsa_pubkey);
989  }
990  if (key->rsa_pubkey) {
992  }
993  gw_free(key);
994 }
995 
997 {
1000  gw_free(key);
1001 }
1002 
1003 void destroy_ec_pubkey(ECPublicKey * key)
1004 {
1005  octstr_destroy(key->point);
1006  gw_free(key);
1007 }
1008 
1009 void destroy_dh_pubkey(DHPublicKey * key)
1010 {
1011  octstr_destroy(key->dh_Y);
1012  gw_free(key);
1013 }
1014 
1015 void destroy_rsa_secret(RSASecret * secret)
1016 {
1017  destroy_array(secret->random);
1018  gw_free(secret);
1019 }
1020 
1022 {
1024  gw_free(secret);
1025 }
1026 
1027 void destroy_key_exchange_id(KeyExchangeId * keyexid)
1028 {
1029  destroy_param_spec(keyexid->param_specif);
1030  destroy_identifier(keyexid->identifier);
1031  gw_free(keyexid);
1032 }
1033 
1034 void destroy_array(List * array)
1035 {
1036  int i;
1037 
1038  /* pack each entry in the array */
1039  for (i = 0; i < gwlist_len(array); i++) {
1040  octstr_destroy((Octstr *) gwlist_get(array, i));
1041  }
1042 
1043  gwlist_destroy(array, NULL);
1044 }
1045 
1046 void destroy_key_list(List * key_list)
1047 {
1048  int i;
1049  /* destroy the KeyExchangeIds */
1050  for (i = 0; i < gwlist_len(key_list); i++) {
1051  destroy_key_exchange_id((KeyExchangeId *)
1052  gwlist_get(key_list, i));
1053  }
1054  gwlist_destroy(key_list, NULL);
1055 }
1056 
1057 void destroy_ciphersuite_list(List * ciphersuites)
1058 {
1059  int i;
1060 
1061  /* destroy the CipherSuites */
1062  for (i = 0; i < gwlist_len(ciphersuites); i++) {
1063  gw_free((CipherSuite *) gwlist_get(ciphersuites, i));
1064  }
1065  gwlist_destroy(ciphersuites, NULL);
1066 }
1067 
1068 void destroy_compression_method_list(List * compmethod_list)
1069 {
1070  int i;
1071  CompressionMethod *cm;
1072 
1073  /* destroy the CompressionMethods */
1074  for (i = 0; i < gwlist_len(compmethod_list); i++) {
1075  cm = (CompressionMethod *) gwlist_get(compmethod_list, i);
1076  gw_free(cm);
1077  }
1078 
1079  gw_free(compmethod_list);
1080 }
1081 
1082 void destroy_identifier(Identifier * ident)
1083 {
1084  switch (ident->id_type) {
1085  case text:
1086  octstr_destroy(ident->name);
1087  break;
1088  case binary:
1089  octstr_destroy(ident->identifier);
1090  break;
1091  case key_hash_sha:
1092  octstr_destroy(ident->key_hash);
1093  break;
1094  case x509_name:
1096  break;
1097  default:
1098  break;
1099  }
1100  gw_free(ident);
1101 }
1102 
1103 void destroy_signature(Signature * sig)
1104 {
1105  switch (signature_algo) {
1106  case ecdsa_sha:
1107  case rsa_sha:
1108  destroy_array(sig->sha_hash);
1109  break;
1110  default:
1111  break;
1112  }
1113  gw_free(sig);
1114 }
1115 
1117 {
1118  /* === destroy ToBeSignedCertificate === */
1119  /* issuer Identifier */
1121  /* subject Identifier */
1123  /* parameter specifier */
1125  /* public key */
1126  destroy_public_key(cert->tobesigned_cert->pubkey);
1127 
1128  /* === destroy Signature === */
1129  destroy_signature(cert->signature);
1130  gw_free(cert);
1131 }
1132 
1133 /*****************************************************************
1134  * DUMP functions
1135  */
1136 
1137 void dump_void16(char *dbg, int level, int i)
1138 {
1139  debug(dbg, 0, "%*s16 bit Int: %d", level, "", i);
1140 }
1141 
1142 void dump_int32(char *dbg, int level, long i)
1143 {
1144  debug(dbg, 0, "%*s32 bit Int: %ld", level, "", i);
1145 }
1146 
1147 void dump_octstr(char *dbg, int level, Octstr * opaque)
1148 {
1149  octstr_dump(opaque, 0);
1150 }
1151 
1152 void dump_octstr16(char *dbg, int level, Octstr * opaque)
1153 {
1154  octstr_dump(opaque, 0);
1155 }
1156 
1157 void dump_octstr_fixed(char *dbg, int level, Octstr * opaque)
1158 {
1159  octstr_dump(opaque, 0);
1160 }
1161 
1162 void dump_random(char *dbg, int level, Random * random)
1163 {
1164  debug(dbg, 0, "%*sRandom :", level, "");
1165  debug(dbg, 0, "%*sGMT Unix Time: %ld", level + 1, "",
1166  random->gmt_unix_time);
1167  debug(dbg, 0, "%*sRandom Bytes:", level + 1, "");
1168  dump_octstr_fixed(dbg, level + 2, random->random_bytes);
1169 }
1170 
1171 void dump_dhparams(char *dbg, int level, DHParameters * dhparams)
1172 {
1173  debug(dbg, 0, "%*sDH Parameters :", level, "");
1174  debug(dbg, 0, "%*sdh_e: %d", level + 1, "", dhparams->dh_e);
1175  debug(dbg, 0, "%*sdh_p:", level + 1, "");
1176  dump_octstr16(dbg, level + 2, dhparams->dh_p);
1177  debug(dbg, 0, "%*sdh_g:", level + 1, "");
1178  dump_octstr16(dbg, level + 2, dhparams->dh_g);
1179 }
1180 
1181 void dump_ecparams(char *dbg, int level, ECParameters * ecparams)
1182 {
1183  debug(dbg, 0, "%*sEC Parameters :", level, "");
1184  /* field */
1185  debug(dbg, 0, "%*sField: %d", level + 1, "", ecparams->field);
1186  switch (ecparams->field) {
1187  case ec_prime_p:
1188  debug(dbg, 0, "%*sprime_p :", level + 1, "");
1189  dump_octstr(dbg, level + 1, ecparams->prime_p);
1190  break;
1191  case ec_characteristic_two:
1192  /* m (16 bits) */
1193  debug(dbg, 0, "%*sM: %d", level + 1, "", ecparams->m);
1194  /* basis */
1195  debug(dbg, 0, "%*sBasis: %d", level + 1, "", ecparams->basis);
1196  switch (ecparams->basis) {
1197  case ec_basis_onb:
1198  break;
1199  case ec_basis_trinomial:
1200  debug(dbg, 0, "%*sK: %d", level + 1, "", ecparams->k);
1201  break;
1202  case ec_basis_pentanomial:
1203  debug(dbg, 0, "%*sk1: %d", level + 1, "", ecparams->k1);
1204  debug(dbg, 0, "%*sk2: %d", level + 1, "", ecparams->k2);
1205  debug(dbg, 0, "%*sk3: %d", level + 1, "", ecparams->k3);
1206  break;
1207  case ec_basis_polynomial:
1208  debug(dbg, 0, "%*sirreducible: 0x%p", level + 1, "",
1209  ecparams->irreducible);
1210  dump_octstr(dbg, level + 1, ecparams->irreducible);
1211  break;
1212  }
1213  break;
1214  }
1215  /* pack the ECCurve */
1216  debug(dbg, 0, "%*sEC Curve: 0x%p", level + 1, "", ecparams->curve);
1217  debug(dbg, 0, "%*sa: 0x%p", level + 2, "", ecparams->curve->a);
1218  dump_octstr(dbg, level + 2, ecparams->curve->a);
1219  debug(dbg, 0, "%*sb: 0x%p", level + 2, "", ecparams->curve->b);
1220  dump_octstr(dbg, level + 2, ecparams->curve->b);
1221  debug(dbg, 0, "%*sseed: 0x%p", level + 2, "", ecparams->curve->seed);
1222  dump_octstr(dbg, level + 2, ecparams->curve->seed);
1223  /* pack the ECPoint */
1224  debug(dbg, 0, "%*spoint: 0x%p", level + 2, "", ecparams->base->point);
1225  dump_octstr(dbg, level + 2, ecparams->base->point);
1226  /* order and cofactor */
1227  debug(dbg, 0, "%*sorder: 0x%p", level + 2, "", ecparams->order);
1228  dump_octstr(dbg, level + 2, ecparams->order);
1229  debug(dbg, 0, "%*scofactor: 0x%p", level + 2, "", ecparams->cofactor);
1230  dump_octstr(dbg, level + 2, ecparams->cofactor);
1231 }
1232 
1233 void dump_param_spec(char *dbg, int level, ParameterSpecifier * pspec)
1234 {
1235  debug(dbg, 0, "%*sParameterSpecifier:", level, "");
1236  /* index */
1237  debug(dbg, 0, "%*sParameter Index: %d", level + 1, "",
1238  pspec->param_index);
1239  /* ParameterSet struct */
1240  if (pspec->param_index == 255) {
1241  debug(dbg, 0, "%*sLength: %ld", level + 1, "",
1242  pspec->param_set->length);
1243  switch (public_key_algo) {
1244  case diffie_hellman_pubkey:
1245  dump_dhparams(dbg, level + 1,
1246  pspec->param_set->dhparams);
1247  break;
1248  case elliptic_curve_pubkey:
1249  dump_ecparams(dbg, level + 1,
1250  pspec->param_set->ecparams);
1251  break;
1252  default:
1253  break;
1254  }
1255  }
1256 }
1257 
1258 void dump_public_key(char *dbg, int level, PublicKey * key, PublicKeyType
1259  key_type)
1260 {
1261  switch (key_type) {
1262  case ecdh_key:
1263  debug(dbg, 0, "%*sPublicKey: 0x%p", level, "",
1264  key->ecdh_pubkey);
1265  debug(dbg, 0, "%*sECDH Point: 0x%p", level + 1, "",
1266  key->ecdh_pubkey->point);
1267  dump_octstr(dbg, level + 1, key->ecdh_pubkey->point);
1268  break;
1269  case ecdsa_key:
1270  debug(dbg, 0, "%*sECDSA Point: 0x%p", level + 1, "",
1271  key->ecdsa_pubkey->point);
1272  dump_octstr(dbg, level + 1, key->ecdsa_pubkey->point);
1273  break;
1274  case rsa_key:
1275  dump_rsa_pubkey(dbg, level + 1, key->rsa_pubkey);
1276  break;
1277  }
1278 }
1279 
1280 void dump_rsa_pubkey(char *dbg, int level, RSAPublicKey * key)
1281 {
1282  debug(dbg, 0, "%*sRSA Public Key: 0x%p", level, "", key);
1283  debug(dbg, 0, "%*sRSA Exponent: 0x%p", level + 1, "",
1284  key->rsa_exponent);
1285  dump_octstr(dbg, level + 2, key->rsa_exponent);
1286  debug(dbg, 0, "%*sRSA Modulus: 0x%p", level + 1, "", key->rsa_modulus);
1287  dump_octstr(dbg, level + 2, key->rsa_modulus);
1288 }
1289 
1290 void dump_ec_pubkey(char *dbg, int level, ECPublicKey * key)
1291 {
1292  debug(dbg, 0, "%*sEC Public Key: 0x%p", level, "", key);
1293  debug(dbg, 0, "%*sPoint: 0x%p", level + 1, "", key->point);
1294  dump_octstr(dbg, level + 2, key->point);
1295 }
1296 
1297 void dump_dh_pubkey(char *dbg, int level, DHPublicKey * key)
1298 {
1299  debug(dbg, 0, "%*sDH Public Key: 0x%p", level, "", key->dh_Y);
1300  dump_octstr(dbg, level + 2, key->dh_Y);
1301 }
1302 
1303 void dump_rsa_secret(char *dbg, int level, RSASecret * secret)
1304 {
1305  debug(dbg, 0, "%*sRSA Secret: 0x%p", level, "", secret);
1306  debug(dbg, 0, "%*sClient Version: %d", level + 1, "",
1307  secret->client_version);
1308  debug(dbg, 0, "%*sRandom: 0x%p", level, "", secret->random);
1309  dump_array(dbg, level + 2, secret->random);
1310 }
1311 
1312 void dump_rsa_encrypted_secret(char *dbg, int level, RSAEncryptedSecret
1313  * secret)
1314 {
1315  debug(dbg, 0, "%*sRSA Encrypted Secret: %p", level, "",
1316  secret->encrypted_secret);
1317  dump_octstr(dbg, level + 1, secret->encrypted_secret);
1318 }
1319 
1320 void dump_key_exchange_id(char *dbg, int level, KeyExchangeId * keyexid)
1321 {
1322  debug(dbg, 0, "%*sKey Exchange Id: 0x%p", level, "", keyexid);
1323  debug(dbg, 0, "%*sKey Exch Suite: %d", level + 1, "",
1324  keyexid->key_exchange_suite);
1325  dump_param_spec(dbg, level + 1, keyexid->param_specif);
1326  dump_identifier(dbg, level + 1, keyexid->identifier);
1327 }
1328 
1329 void dump_array(char *dbg, int level, List * array)
1330 {
1331  int i;
1332 
1333  /*debug(dbg, 0, "%*sOctstr Array: %p", level, ""); */
1334 
1335  /* dump each entry in the array */
1336  for (i = 0; i < gwlist_len(array); i++) {
1337  debug(dbg, 0, "%*sElement %d", level, "", i);
1338  dump_octstr(dbg, level + 1, (Octstr *) gwlist_get(array, i));
1339  }
1340 }
1341 
1342 void dump_key_list(char *dbg, int level, List * key_list)
1343 {
1344  int i;
1345  KeyExchangeId *keyexid;
1346 
1347  debug(dbg, 0, "%*sKey List: 0x%p", level, "", key_list);
1348 
1349  /* pack the KeyExchangeIds */
1350  for (i = 0; i < gwlist_len(key_list); i++) {
1351  keyexid = (KeyExchangeId *) gwlist_get(key_list, i);
1352  dump_key_exchange_id(dbg, level + 1, keyexid);
1353  }
1354 }
1355 
1356 void dump_ciphersuite_list(char *dbg, int level, List * ciphersuites)
1357 {
1358  int i;
1359  CipherSuite *cs;
1360 
1361  debug(dbg, 0, "%*sCipherSuite List: 0x%p", level, "", ciphersuites);
1362 
1363  /* dump the CipherSuites */
1364  for (i = 0; i < gwlist_len(ciphersuites); i++) {
1365  cs = (CipherSuite *) gwlist_get(ciphersuites, i);
1366  debug(dbg, 0, "%*sBulk Cipher Algo: %d", level, "",
1367  cs->bulk_cipher_algo);
1368  debug(dbg, 0, "%*sMAC Algo: %d", level, "", cs->mac_algo);
1369  }
1370 }
1371 
1372 void dump_compression_method_list(char *dbg, int level, List * compmethod_list)
1373 {
1374  int i;
1375 
1376  debug(dbg, 0, "%*sCompression Method List: 0x%p", level, "",
1377  compmethod_list);
1378  /* pack the CompressionMethods */
1379  for (i = 0; i < gwlist_len(compmethod_list); i++) {
1380  debug(dbg, 0, "%*sMethod %d: %d", level, "", i,
1381  (CompressionMethod) gwlist_get(compmethod_list, i));
1382  }
1383 }
1384 
1385 void dump_identifier(char *dbg, int level, Identifier * ident)
1386 {
1387  debug(dbg, 0, "%*sIdentifier: 0x%p", level, "", ident);
1388  debug(dbg, 0, "%*sIdent type: %d", level + 1, "", ident->id_type);
1389  switch (ident->id_type) {
1390  case text:
1391  debug(dbg, 0, "%*sCharset: %d", level + 1, "", ident->charset);
1392  debug(dbg, 0, "%*sNamet: %s", level + 1, "",
1393  octstr_get_cstr(ident->name));
1394  break;
1395  case binary:
1396  debug(dbg, 0, "%*sIdentifier: 0x%p", level + 1, "",
1397  ident->identifier);
1398  dump_octstr(dbg, level + 2, ident->identifier);
1399  break;
1400  case key_hash_sha:
1401  debug(dbg, 0, "%*sKey Hash: 0x%p", level + 1, "",
1402  ident->key_hash);
1403  dump_octstr(dbg, level + 2, ident->key_hash);
1404  break;
1405  case x509_name:
1406  debug(dbg, 0, "%*sDistinguished Name: 0x%p", level + 1, "",
1407  ident->distinguished_name);
1408  dump_octstr(dbg, level + 2, ident->distinguished_name);
1409  break;
1410  default:
1411  break;
1412  }
1413 }
1414 
1415 void dump_signature(char *dbg, int level, Signature * sig)
1416 {
1417  debug(dbg, 0, "%*sSignature: 0x%p", level, "", sig);
1418  switch (signature_algo) {
1419  case ecdsa_sha:
1420  case rsa_sha:
1421  dump_array(dbg, level + 1, sig->sha_hash);
1422  break;
1423 
1424  default:
1425  break;
1426  }
1427 }
1428 
1429 void dump_wtls_certificate(char *dbg, int level, WTLSCertificate * cert)
1430 {
1431  debug(dbg, 0, "%*sWTLS Certificate: 0x%p", level, "", cert);
1432  /* === pack ToBeSignedCertificate === */
1433  /* version */
1434  debug(dbg, 0, "%*sCertificate Version: %d", level + 1, "",
1436  /* sig algo */
1437  debug(dbg, 0, "%*sSignature Algo: %d", level + 1, "",
1439  /* identifier */
1440  debug(dbg, 0, "%*sID Type: %d", level + 1, "",
1441  cert->tobesigned_cert->issuer->id_type);
1442  /* issuer Identifier */
1443  dump_identifier(dbg, level + 1, cert->tobesigned_cert->issuer);
1444  /* validity periods */
1445  debug(dbg, 0, "%*sValid not Before: %ld", level + 1, "",
1447  debug(dbg, 0, "%*sValid not After: %ld", level + 1, "",
1449  /* subject Identifier */
1450  dump_identifier(dbg, level + 1, cert->tobesigned_cert->subject);
1451  /* public_key_type */
1452  debug(dbg, 0, "%*sPublic Key Type: %d", level + 1, "",
1453  cert->tobesigned_cert->pubkey_type);
1454  /* parameter specifier */
1455  dump_param_spec(dbg, level + 1, cert->tobesigned_cert->param_spec);
1456  /* public key */
1457  dump_public_key(dbg, level + 1, cert->tobesigned_cert->pubkey,
1458  cert->tobesigned_cert->pubkey_type);
1459 
1460  /* === pack Signature === */
1461  dump_signature(dbg, level + 1, cert->signature);
1462 }
1463 #endif /* HAVE_WTLS_OPENSSL */
void destroy_compression_method_list(List *compmethod_list)
Octstr * dh_Y
Definition: wtls_pdu.h:167
void dump_compression_method_list(char *dbg, int level, List *compmethod_list)
Octstr * order
Definition: wtls_pdu.h:227
long gmt_unix_time
Definition: wtls_pdu.h:156
int certificate_version
Definition: wtls_pdu.h:259
int charset
Definition: wtls_pdu.h:187
Octstr * dh_g
Definition: wtls_pdu.h:206
enum pubkey_algo PublicKeyAlgorithm
void dump_rsa_pubkey(char *dbg, int level, RSAPublicKey *key)
Identifier * issuer
Definition: wtls_pdu.h:261
SignatureAlgorithm signature_algo
Definition: wtls_pdu.h:260
PublicKey * unpack_public_key(Octstr *data, long *charpos, PublicKeyType key_type)
void gwlist_append(List *list, void *item)
Definition: list.c:179
int pack_dhparams(Octstr *data, long charpos, DHParameters *dhparams)
List * sha_hash
Definition: wtls_pdu.h:255
ECPublicKey * ecdsa_pubkey
Definition: wtls_pdu.h:179
void dump_key_exchange_id(char *dbg, int level, KeyExchangeId *keyexid)
long gwlist_len(List *list)
Definition: list.c:166
PublicKeyType pubkey_type
Definition: wtls_pdu.h:265
ToBeSignedCertificate * tobesigned_cert
Definition: wtls_pdu.h:271
void * gwlist_get(List *list, long pos)
Definition: list.c:292
List * random
Definition: wtls_pdu.h:277
int pack_dh_pubkey(Octstr *data, long charpos, DHPublicKey *key)
ECPublicKey * unpack_ec_pubkey(Octstr *data, long *charpos)
void octstr_append_char(Octstr *ostr, int ch)
Definition: octstr.c:1515
Octstr * rsa_exponent
Definition: wtls_pdu.h:171
ECParameters * ecparams
Definition: wtls_pdu.h:237
WTLSCertificate * unpack_wtls_certificate(Octstr *data, long *charpos)
long valid_not_after
Definition: wtls_pdu.h:263
Octstr * b
Definition: wtls_pdu.h:199
int pack_octstr16(Octstr *data, long charpos, Octstr *opaque)
int pack_key_list(Octstr *data, long charpos, List *key_list)
ParameterSpecifier * param_specif
Definition: wtls_pdu.h:247
ECBasisType basis
Definition: wtls_pdu.h:215
Octstr * distinguished_name
Definition: wtls_pdu.h:194
Octstr * seed
Definition: wtls_pdu.h:200
List * unpack_compression_method_list(Octstr *data, long *charpos)
int pack_ecparams(Octstr *data, long charpos, ECParameters *ecparams)
Octstr * unpack_octstr16(Octstr *data, long *charpos)
void destroy_ec_pubkey(ECPublicKey *key)
int pack_public_key(Octstr *data, long charpos, PublicKey *key, PublicKeyType key_type)
Octstr * key_hash
Definition: wtls_pdu.h:192
int pack_random(Octstr *data, long charpos, Random *random)
int pack_int16(Octstr *data, long charpos, int i)
#define octstr_get_cstr(ostr)
Definition: octstr.h:233
void dump_ec_pubkey(char *dbg, int level, ECPublicKey *key)
#define octstr_copy(ostr, from, len)
Definition: octstr.h:178
int pack_rsa_pubkey(Octstr *data, long charpos, RSAPublicKey *key)
Octstr * random_bytes
Definition: wtls_pdu.h:157
int key_exchange_suite
Definition: wtls_pdu.h:246
void dump_signature(char *dbg, int level, Signature *sig)
void dump_public_key(char *dbg, int level, PublicKey *key, PublicKeyType key_type)
void dump_octstr16(char *dbg, int level, Octstr *opaque)
int pack_wtls_certificate(Octstr *data, long charpos, WTLSCertificate *cert)
void dump_octstr_fixed(char *dbg, int level, Octstr *opaque)
Signature * unpack_signature(Octstr *data, long *charpos)
Octstr * a
Definition: wtls_pdu.h:198
long unpack_int32(Octstr *data, long *charpos)
void destroy_rsa_encrypted_secret(RSAEncryptedSecret *secret)
void destroy_param_spec(ParameterSpecifier *pspec)
void octstr_insert(Octstr *ostr1, const Octstr *ostr2, long pos)
Definition: octstr.c:1301
void dump_dhparams(char *dbg, int level, DHParameters *dhparams)
ParameterSpecifier * unpack_param_spec(Octstr *data, long *charpos)
int pack_array(Octstr *data, long charpos, List *array)
Octstr * dh_p
Definition: wtls_pdu.h:205
void dump_array(char *dbg, int level, List *array)
void dump_dh_pubkey(char *dbg, int level, DHPublicKey *key)
ECCurve * curve
Definition: wtls_pdu.h:225
int pack_identifier(Octstr *data, long charpos, Identifier *ident)
void dump_random(char *dbg, int level, Random *random)
int pack_ciphersuite_list(Octstr *data, long charpos, List *ciphersuites)
void dump_wtls_certificate(char *dbg, int level, WTLSCertificate *cert)
char * text
Definition: smsc_cimd2.c:921
void destroy_array(List *array)
int pack_rsa_secret(Octstr *data, long charpos, RSASecret *secret)
void dump_int32(char *dbg, int level, long i)
ECParameters * unpack_ecparams(Octstr *data, long *charpos)
#define octstr_dump(ostr, level,...)
Definition: octstr.h:564
int pack_signature(Octstr *data, long charpos, Signature *sig)
int unpack_int16(Octstr *data, long *charpos)
Random * unpack_random(Octstr *data, long *charpos)
Octstr * cofactor
Definition: wtls_pdu.h:228
DHParameters * dhparams
Definition: wtls_pdu.h:235
void octstr_destroy(Octstr *ostr)
Definition: octstr.c:322
#define octstr_create(cstr)
Definition: octstr.h:125
DHParameters * unpack_dhparams(Octstr *data, long *charpos)
enum sig_algo SignatureAlgorithm
Octstr * unpack_octstr(Octstr *data, long *charpos)
void dump_key_list(char *dbg, int level, List *key_list)
void dump_param_spec(char *dbg, int level, ParameterSpecifier *pspec)
Identifier * identifier
Definition: wtls_pdu.h:248
Octstr * irreducible
Definition: wtls_pdu.h:224
List * unpack_key_list(Octstr *data, long *charpos)
ParameterSpecifier * param_spec
Definition: wtls_pdu.h:266
void dump_ecparams(char *dbg, int level, ECParameters *ecparams)
int client_version
Definition: wtls_pdu.h:276
void destroy_identifier(Identifier *ident)
RSAPublicKey * rsa_pubkey
Definition: wtls_pdu.h:181
void destroy_dh_pubkey(DHPublicKey *key)
KeyExchangeId * unpack_key_exchange_id(Octstr *data, long *charpos)
RSAEncryptedSecret * unpack_rsa_encrypted_secret(Octstr *data, long *charpos)
int pack_rsa_encrypted_secret(Octstr *data, long charpos, RSAEncryptedSecret *secret)
long octstr_len(const Octstr *ostr)
Definition: octstr.c:340
void dump_octstr(char *dbg, int level, Octstr *opaque)
ECPoint * base
Definition: wtls_pdu.h:226
int pack_compression_method_list(Octstr *data, long charpos, List *compmethod_list)
Definition: octstr.c:118
void destroy_key_list(List *key_list)
long valid_not_before
Definition: wtls_pdu.h:262
DHPublicKey * unpack_dh_pubkey(Octstr *data, long *charpos)
Octstr * prime_p
Definition: wtls_pdu.h:212
void debug(const char *place, int err, const char *fmt,...)
Definition: log.c:690
ParameterSet * param_set
Definition: wtls_pdu.h:242
int pack_octstr_fixed(Octstr *data, long charpos, Octstr *opaque)
ECPublicKey * ecdh_pubkey
Definition: wtls_pdu.h:177
Identifier * subject
Definition: wtls_pdu.h:264
void destroy_rsa_pubkey(RSAPublicKey *key)
void dump_identifier(char *dbg, int level, Identifier *ident)
void dump_rsa_encrypted_secret(char *dbg, int level, RSAEncryptedSecret *secret)
int mac_algo
Definition: wtls_pdu.h:286
List * unpack_array(Octstr *data, long *charpos)
List * unpack_ciphersuite_list(Octstr *data, long *charpos)
void destroy_random(Random *random)
void destroy_wtls_certificate(WTLSCertificate *cert)
int pack_int32(Octstr *data, long charpos, long i)
#define gwlist_create()
Definition: list.h:136
ECField field
Definition: wtls_pdu.h:210
int pack_octstr(Octstr *data, long charpos, Octstr *opaque)
Identifier * unpack_identifier(Octstr *data, long *charpos)
int pack_param_spec(Octstr *data, long charpos, ParameterSpecifier *pspec)
Octstr * rsa_modulus
Definition: wtls_pdu.h:172
RSAPublicKey * unpack_rsa_pubkey(Octstr *data, long *charpos)
enum compmethod CompressionMethod
int pack_key_exchange_id(Octstr *data, long charpos, KeyExchangeId *keyexid)
int octstr_get_char(const Octstr *ostr, long pos)
Definition: octstr.c:404
Octstr * identifier
Definition: wtls_pdu.h:190
IdentifierType id_type
Definition: wtls_pdu.h:185
void octstr_set_char(Octstr *ostr, long pos, int ch)
Definition: octstr.c:413
Octstr * unpack_octstr_fixed(Octstr *data, long *charpos, long length)
void dump_rsa_secret(char *dbg, int level, RSASecret *secret)
Octstr * point
Definition: wtls_pdu.h:161
int bulk_cipher_algo
Definition: wtls_pdu.h:285
PublicKey * pubkey
Definition: wtls_pdu.h:267
Definition: list.c:102
int pack_ec_pubkey(Octstr *data, long charpos, ECPublicKey *key)
Signature * signature
Definition: wtls_pdu.h:272
enum public_key_type PublicKeyType
void dump_ciphersuite_list(char *dbg, int level, List *ciphersuites)
RSASecret * unpack_rsa_secret(Octstr *data, long *charpos)
Octstr * name
Definition: wtls_pdu.h:188
Octstr * encrypted_secret
Definition: wtls_pdu.h:281
void destroy_ciphersuite_list(List *ciphersuites)
void gwlist_destroy(List *list, gwlist_item_destructor_t *destructor)
Definition: list.c:145
See file LICENSE for details about the license agreement for using, modifying, copying or deriving work from this software.