开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 手机WAP编程 > 查看源码
wtls_pdusupport.c
资源名称：gateway-1.2.1　[点击查看]
上传用户：gzpyjq
上传日期：2013-01-31
资源大小：1852k
文件大小：34k
源码类别：

手机WAP编程

开发平台：

WINDOWS

wtls_pdusupport.c：源码内容
  1. /* 
  2.  * wtls_support.c: pack and unpack WTLS packets
  3.  *
  4.  * Support functions for packing and unpacking PDUs
  5.  * 
  6.  */
  8. #include "gwlib/gwlib.h"
  10. #if (HAVE_WTLS_OPENSSL)
  12. #include "wtls_pdu.h"
  13. #include "wtls_pdusupport.h"
  14. #include "wtls_statesupport.h"
  16. // Change this later !!!!
  17. extern PublicKeyAlgorithm public_key_algo;
  18. extern SignatureAlgorithm signature_algo;
  20. /*****************************************************************
  21.  * PACK functions
  22.  */
  24. int pack_int16(Octstr *data, long charpos, int i) {
  25. octstr_append_char(data, (i & 0xFF00) >> 8);
  26. charpos += 1;
  27. octstr_append_char(data, i & 0x00FF);
  28. charpos += 1;
  29. return charpos;
  30. }
  32. int pack_int32(Octstr *data, long charpos, long i) {
  33. charpos = pack_int16(data, charpos, (i & 0xFFFF0000) >> 16);
  34. charpos = pack_int16(data, charpos, i & 0xFFFF);
  35. return charpos;
  36. }
  38. int pack_octstr(Octstr *data, long charpos, Octstr *opaque) {
  39. octstr_append_char(data, octstr_len(opaque));
  40. charpos += 1;
  41. octstr_insert(data, opaque, octstr_len(data));
  42. charpos += octstr_len(opaque);
  43. return charpos;
  44. }
  46. int pack_octstr16(Octstr *data, long charpos, Octstr *opaque) {
  47. charpos += pack_int16(data, charpos, octstr_len(opaque));
  48. octstr_insert(data, opaque, octstr_len(data));
  49. charpos += octstr_len(opaque);
  50. return charpos;
  51. }
  53. int pack_octstr_fixed(Octstr *data, long charpos, Octstr *opaque) {
  54. octstr_insert(data, opaque, octstr_len(data));
  55. charpos += octstr_len(opaque);
  56. return charpos;
  57. }
  59. int pack_random(Octstr *data, long charpos, Random *random) {
  60. charpos = pack_int32(data, charpos, random->gmt_unix_time);
  61. charpos = pack_octstr_fixed(data, charpos, random->random_bytes);
  62. return charpos;
  63. }
  65. int pack_dhparams(Octstr *data, long charpos, DHParameters *dhparams) {
  66. octstr_append_char(data, dhparams->dh_e);
  67. charpos += 1;
  68. charpos = pack_octstr16(data, charpos, dhparams->dh_p);
  69. charpos = pack_octstr16(data, charpos, dhparams->dh_g);
  70. return charpos;
  71. }
  73. int pack_ecparams(Octstr *data, long charpos, ECParameters *ecparams) {
  74. /* field */
  75. octstr_append_char(data, ecparams->field);
  76. charpos += 1;
  77. switch (ecparams->field) {
  78. case ec_prime_p:
  79. charpos = pack_octstr(data, charpos, ecparams->prime_p);
  80. break;
  81. case ec_characteristic_two:
  82. /* m (16 bits) */
  83. charpos = pack_int16(data, charpos, ecparams->m);
  84. /* basis */
  85. octstr_append_char(data, ecparams->basis);
  86. charpos += 1;
  87. switch (ecparams->basis) {
  88. case ec_basis_onb:
  89. break;
  90. case ec_basis_trinomial:
  91. charpos = pack_int16(data, charpos, ecparams->k);
  92. break;
  93. case ec_basis_pentanomial:
  94. charpos = pack_int16(data, charpos, ecparams->k1);
  95. charpos = pack_int16(data, charpos, ecparams->k2);
  96. charpos = pack_int16(data, charpos, ecparams->k3);
  97. break;
  98. case ec_basis_polynomial:
  99. charpos = pack_octstr(data, charpos, ecparams->irreducible);
  100. break;
  101. }
  102. break;
  103. }
  104. /* pack the ECCurve */
  105. charpos = pack_octstr(data, charpos, ecparams->curve->a);
  106. charpos = pack_octstr(data, charpos, ecparams->curve->b);
  107. charpos = pack_octstr(data, charpos, ecparams->curve->seed);
  108. /* pack the ECPoint */
  109. charpos = pack_octstr(data, charpos, ecparams->base->point);
  110. /* order and cofactor */
  111. charpos = pack_octstr(data, charpos, ecparams->order);
  112. charpos = pack_octstr(data, charpos, ecparams->cofactor);
  114. return charpos;
  115. }
  117. int pack_param_spec(Octstr *data, long charpos, ParameterSpecifier *pspec) {
  118.         if (pspec == NULL)
  119.         {
  120. octstr_append_char(data, 0);
  121. charpos += 1;
  122.         return charpos;
  123.         }        
  125.         /* index */
  126. octstr_append_char(data, pspec->param_index);
  127. charpos += 1;
  128. /* ParameterSet struct */
  129. octstr_append_char(data, pspec->param_set->length);
  130. charpos += 1;
  131. switch (public_key_algo) {
  132. case diffie_hellman_pubkey:
  133. pack_dhparams(data, charpos, pspec->param_set->dhparams);
  134. break;
  135. case elliptic_curve_pubkey:
  136. pack_ecparams(data, charpos, pspec->param_set->ecparams);
  137. break;
  138. }
  139. return charpos;
  140. }
  142. int pack_public_key(Octstr *data, long charpos, PublicKey *key, PublicKeyType key_type) {
  143. switch (key_type) {
  144. case ecdh_key:
  145. charpos = pack_octstr(data, charpos, key->ecdh_pubkey->point);
  146. break;
  147. case ecdsa_key:
  148. charpos = pack_octstr(data, charpos, key->ecdsa_pubkey->point);
  149. break;
  150. case rsa_key:
  151. charpos = pack_rsa_pubkey(data, charpos, key->rsa_pubkey);
  152. break;
  153. }
  154. return charpos;
  155. }
  157. int pack_rsa_pubkey(Octstr *data, long charpos, RSAPublicKey *key) {
  158. charpos = pack_octstr16(data, charpos, key->rsa_exponent);
  159. charpos = pack_octstr16(data, charpos, key->rsa_modulus);
  160. return charpos;
  161. }
  163. int pack_ec_pubkey(Octstr *data, long charpos, ECPublicKey *key) {
  164. charpos = pack_octstr(data, charpos, key->point);
  165. return charpos;
  166. }
  168. int pack_dh_pubkey(Octstr *data, long charpos, DHPublicKey *key) {
  169. charpos = pack_octstr16(data, charpos, key->dh_Y);
  170. return charpos;
  171. }
  173. int pack_rsa_secret(Octstr *data, long charpos, RSASecret *secret) {
  174. octstr_append_char(data, secret->client_version);
  175. charpos += 1;
  176. charpos = pack_array(data, charpos, secret->random);
  177. return charpos;
  178. }
  180. int pack_rsa_encrypted_secret(Octstr *data, long charpos, RSAEncryptedSecret *secret) {
  181. charpos = pack_octstr16(data, charpos, secret->encrypted_secret);
  182. return charpos;
  183. }
  185. int pack_key_exchange_id(Octstr *data, long charpos, KeyExchangeId *keyexid) {
  186. octstr_set_char(data, charpos, keyexid->key_exchange_suite);
  187. charpos += 1;
  188. charpos = pack_param_spec(data, charpos, keyexid->param_specif);
  189. charpos = pack_identifier(data, charpos, keyexid->identifier);
  190. return charpos;
  191. }
  193. int pack_array(Octstr *data, long charpos, List *array) {
  194. int i;
  195. long pos = 0;
  196. Octstr *buffer;
  198. /* we need to know the length in bytes of the list
  199.    so we pack everything in a buffer for now. */
  200. buffer = octstr_create("");
  202. /* pack each entry in the buffer */
  203. for (i=0; i<list_len(array); i++)
  204. {
  205. pos = pack_octstr(buffer, pos, (Octstr *) list_get(array, i));
  206. }
  208. /* now we know the size of the list */
  209. charpos = pack_int16(data, charpos, pos);
  211. /* append the buffer */
  212. charpos = pack_octstr_fixed(data, charpos, buffer);
  214. return charpos;
  215. }
  217. int pack_key_list(Octstr *data, long charpos, List *key_list) {
  218. int i;
  219. long pos = 0;
  220. Octstr *buffer;
  221. KeyExchangeId *keyexid;
  223. /* we need to know the length in bytes of the list
  224.    so we pack everything in a buffer for now. */
  225. buffer = octstr_create("");
  227. /* pack the KeyExchangeIds */
  228. for (i=0; i<list_len(key_list); i++) {
  229. keyexid = (KeyExchangeId *) list_get(key_list, i);
  231. pos = pack_key_exchange_id(buffer, pos, keyexid);
  232. }
  234. /* now we know the size of the list */
  235. charpos = pack_int16(data, charpos, pos);
  237. /* append the buffer */
  238. charpos = pack_octstr_fixed(data, charpos, buffer);
  240. return charpos;
  241. }
  243. int pack_ciphersuite_list(Octstr *data, long charpos, List *ciphersuites) {
  244. int i;
  245. CipherSuite *cs;
  247. /* vector starts with its length 
  248.    Each element uses 2 bytes */
  249. octstr_set_char(data, charpos, list_len(ciphersuites)*2);
  250. charpos += 1;
  252. /* pack the CipherSuites */
  253. for (i=0; i<list_len(ciphersuites); i++) {
  254. cs = (CipherSuite *) list_get(ciphersuites, i);
  255. octstr_set_char(data, charpos, cs->bulk_cipher_algo);
  256. charpos += 1;
  257. octstr_set_char(data, charpos, cs->mac_algo);
  258. charpos += 1;
  259. }
  261. return charpos;
  262. }
  264. int pack_compression_method_list(Octstr *data, long charpos, List *compmethod_list) {
  265. int i;
  267. /* vector starts with its length */
  268. octstr_set_char(data, charpos, list_len(compmethod_list));
  269. charpos += 1;
  271. /* pack the CompressionMethods */
  272. for (i=0; i<list_len(compmethod_list); i++) {
  273. octstr_set_char(data, charpos, 
  274. (CompressionMethod) list_get(compmethod_list, i));
  275. charpos += 1;
  276. }
  278. return charpos;
  279. }
  281. int pack_identifier(Octstr *data, long charpos, Identifier *ident) {
  282. switch (ident->id_type) {
  283. case text:
  284. octstr_set_char(data, charpos, ident->charset);
  285. charpos += 1;
  286. charpos = pack_octstr(data, charpos, ident->name);
  287. break;
  288. case binary:
  289. charpos = pack_octstr(data, charpos, ident->identifier);
  290. break;
  291. case key_hash_sha:
  292. charpos = pack_octstr(data, charpos, ident->key_hash);
  293. break;
  294. case x509_name:
  295. charpos = pack_octstr(data, charpos, ident->distinguished_name);
  296. break;
  297. }
  298. return charpos;
  299. }
  301. int pack_signature(Octstr *data, long charpos, Signature *sig) {
  302. switch (signature_algo) {
  303. case ecdsa_sha:
  304. case rsa_sha:
  305. charpos = pack_array(data, charpos, sig->sha_hash);
  306. break;
  307. }
  308. return charpos;
  309. }
  311. int pack_wtls_certificate(Octstr *data, long charpos, WTLSCertificate *cert) {
  312. /* === pack ToBeSignedCertificate === */
  313. /* version */
  314. octstr_set_char(data, charpos, cert->tobesigned_cert->certificate_version);
  315. charpos += 1;
  316. /* sig algo */
  317. octstr_set_char(data, charpos, cert->tobesigned_cert->signature_algo);
  318. charpos += 1;
  319. /* identifier */
  320. octstr_set_char(data, charpos, cert->tobesigned_cert->issuer->id_type);
  321. charpos += 1;
  322. /* issuer Identifier */
  323. charpos = pack_identifier(data, charpos, cert->tobesigned_cert->issuer);
  324. /* validity periods */
  325. charpos = pack_int32(data, charpos, cert->tobesigned_cert->valid_not_before);
  326. charpos = pack_int32(data, charpos, cert->tobesigned_cert->valid_not_after);
  327. /* subject Identifier */
  328. charpos = pack_identifier(data, charpos, cert->tobesigned_cert->subject);
  329. /* public_key_type */
  330. octstr_set_char(data, charpos, cert->tobesigned_cert->pubkey_type);
  331. charpos += 1;
  332. /* parameter specifier */
  333. charpos = pack_param_spec(data, charpos, cert->tobesigned_cert->param_spec);
  334. /* public key */
  335. charpos = pack_public_key(data, charpos, cert->tobesigned_cert->pubkey,
  336. cert->tobesigned_cert->pubkey_type);
  338. /* === pack Signature === */
  339. charpos = pack_signature(data, charpos, cert->signature);
  340. return charpos;
  341. }
  344. /*****************************************************************
  345.  * UNPACK functions
  346.  */
  347.  
  348. int unpack_int16(Octstr *data, long *charpos) {
  349. int n;
  351. n =  octstr_get_char(data, *charpos) << 8;
  352. *charpos += 1;
  353. n += octstr_get_char(data, *charpos);
  354. *charpos += 1;
  355. return n;
  356. }
  358. long unpack_int32(Octstr *data, long *charpos) {
  359. int n;
  361. n =  octstr_get_char(data, *charpos);
  362. n = n << 8;
  363. *charpos += 1;
  364. n += octstr_get_char(data, *charpos);
  365. n = n << 8;
  366. *charpos += 1;
  367. n += octstr_get_char(data, *charpos);
  368. n = n << 8;
  369. *charpos += 1;
  370. n += octstr_get_char(data, *charpos);
  371. *charpos += 1;
  372. return n;
  373. }
  375. Octstr * unpack_octstr(Octstr *data, long *charpos) {
  376. int length;
  377. Octstr *opaque;
  379. length = octstr_get_char(data, *charpos);
  380. *charpos += 1;
  381. opaque = octstr_copy(data, *charpos, length);
  382. *charpos += length;
  383. return opaque;
  384. }
  386. Octstr * unpack_octstr16(Octstr *data, long *charpos) {
  387. long length;
  388. Octstr *opaque;
  390. length = unpack_int16(data, charpos);
  391. opaque = octstr_copy(data, *charpos, length);
  392. *charpos += length;
  393. return opaque;
  394. }
  396. Octstr * unpack_octstr_fixed(Octstr *data, long *charpos, long length) {
  397. Octstr *opaque;
  399. opaque = octstr_copy(data, *charpos, length);
  400. *charpos += length;
  401. return opaque;
  402. }
  404. Random * unpack_random(Octstr *data, long *charpos) {
  405. Random *random;
  406. /* create the Random structure */
  407. random = (Random *)gw_malloc(sizeof(Random));
  409. random->gmt_unix_time = unpack_int32(data, charpos);
  410. random->random_bytes = unpack_octstr_fixed(data, charpos, 12);
  411. return random;
  412. }
  414. DHParameters * unpack_dhparams(Octstr *data, long *charpos) {
  415. DHParameters *dhparams;
  417. /* create the DHParameters */
  418. dhparams = (DHParameters *)gw_malloc(sizeof(DHParameters));
  420. dhparams->dh_e = octstr_get_char(data, *charpos);
  421. *charpos += 1;
  422. dhparams->dh_p = unpack_octstr16(data, charpos);
  423. dhparams->dh_g = unpack_octstr16(data, charpos);
  424. return dhparams;
  425. }
  427. ECParameters * unpack_ecparams(Octstr *data, long *charpos) {
  428. ECParameters *ecparams;
  430. /* create the ECParameters */
  431. ecparams = (ECParameters *)gw_malloc(sizeof(ECParameters));
  433. /* field */
  434. ecparams->field = octstr_get_char(data, *charpos);
  435. *charpos += 1;
  436. switch (ecparams->field) {
  437. case ec_prime_p:
  438. ecparams->prime_p = unpack_octstr(data, charpos);
  439. break;
  440. case ec_characteristic_two:
  441. /* m (16 bits) */
  442. ecparams->m = unpack_int16(data, charpos);
  443. /* basis */
  444. ecparams->basis = octstr_get_char(data, *charpos);
  445. *charpos += 1;
  446. switch (ecparams->basis) {
  447. case ec_basis_onb:
  448. break;
  449. case ec_basis_trinomial:
  450. ecparams->k = unpack_int16(data, charpos);
  451. break;
  452. case ec_basis_pentanomial:
  453. ecparams->k1 = unpack_int16(data, charpos);
  454. ecparams->k2 = unpack_int16(data, charpos);
  455. ecparams->k3 = unpack_int16(data, charpos);
  456. break;
  457. case ec_basis_polynomial:
  458. ecparams->irreducible = unpack_octstr(data, charpos);
  459. break;
  460. }
  461. break;
  462. }
  463. /* pack the ECCurve */
  464. ecparams->curve->a = unpack_octstr(data, charpos);
  465. ecparams->curve->b = unpack_octstr(data, charpos);
  466. ecparams->curve->seed = unpack_octstr(data, charpos);
  467. /* pack the ECPoint */
  468. ecparams->base->point = unpack_octstr(data, charpos);
  469. /* order and cofactor */
  470. ecparams->order = unpack_octstr(data, charpos);
  471. ecparams->cofactor = unpack_octstr(data, charpos);
  473. return ecparams;
  474. }
  476. ParameterSpecifier * unpack_param_spec(Octstr *data, long *charpos) {
  477. ParameterSpecifier *pspec;
  479. /* create the ParameterSpecifier */
  480. pspec = (ParameterSpecifier *)gw_malloc(sizeof(ParameterSpecifier));
  482. /* index */
  483. pspec->param_index = octstr_get_char(data, *charpos);
  484. *charpos += 1;
  485. /* ParameterSet struct */
  486. if(pspec->param_index == 255) {
  487. pspec->param_set = (ParameterSet *)gw_malloc(sizeof(ParameterSet));
  488. pspec->param_set->length = octstr_get_char(data, *charpos);
  489. *charpos += 1;
  490. switch (public_key_algo) {
  491. case diffie_hellman_pubkey:
  492. pspec->param_set->dhparams = unpack_dhparams(data, charpos);
  493. break;
  494. case elliptic_curve_pubkey:
  495. pspec->param_set->ecparams = unpack_ecparams(data, charpos);
  496. break;
  497. }
  498. }
  499. return pspec;
  500. }
  502. RSAPublicKey * unpack_rsa_pubkey(Octstr *data, long *charpos) {
  503. RSAPublicKey *key;
  505. /* create the RSAPublicKey */
  506. key = (RSAPublicKey *)gw_malloc(sizeof(RSAPublicKey));
  507. key->rsa_exponent = unpack_octstr16( data, charpos);
  508. key->rsa_modulus = unpack_octstr16( data, charpos);
  509. return key;
  510. }
  512. DHPublicKey * unpack_dh_pubkey(Octstr *data, long *charpos) {
  513. DHPublicKey *key;
  515. /* create the DHPublicKey */
  516. key = (DHPublicKey *)gw_malloc(sizeof(DHPublicKey));
  517. key->dh_Y = unpack_octstr16( data, charpos);
  518. return key;
  519. }
  521. ECPublicKey * unpack_ec_pubkey(Octstr *data, long *charpos) {
  522. ECPublicKey *key;
  524. /* create the ECPublicKey */
  525. key = (ECPublicKey *)gw_malloc(sizeof(ECPublicKey));
  526. key->point = unpack_octstr( data, charpos);
  527. return key;
  528. }
  530. RSASecret * unpack_rsa_secret(Octstr *data, long *charpos) {
  531. RSASecret *secret;
  533. /* create the RSASecret */
  534. secret = (RSASecret *)gw_malloc(sizeof(RSASecret));
  535. secret->client_version = octstr_get_char(data, *charpos);
  536. *charpos += 1;
  537. secret->random = unpack_array(data, charpos);
  539. return secret;
  540. }
  542. RSAEncryptedSecret * unpack_rsa_encrypted_secret(Octstr *data, long *charpos) {
  543. RSAEncryptedSecret *secret;
  545. /* create the RSASecret */
  546. secret = (RSAEncryptedSecret *)gw_malloc(sizeof(RSAEncryptedSecret));
  547. //secret->encrypted_secret = unpack_octstr16(data, charpos);
  548. secret->encrypted_secret = unpack_octstr_fixed(data, charpos, octstr_len(data) - *charpos);
  549. return secret;
  550. }
  552. PublicKey * unpack_public_key(Octstr *data, long *charpos, PublicKeyType key_type) {
  553. PublicKey *key;
  555. /* create the PublicKey */
  556. key = (PublicKey *)gw_malloc(sizeof(PublicKey));
  557. switch (key_type) {
  558. case ecdh_key:
  559. key->ecdh_pubkey = unpack_ec_pubkey(data, charpos);
  560. break;
  561. case ecdsa_key:
  562. key->ecdsa_pubkey = unpack_ec_pubkey(data, charpos);
  563. break;
  564. case rsa_key:
  565. key->rsa_pubkey = unpack_rsa_pubkey(data, charpos);
  566. break;
  567. }
  568. return key;
  569. }
  571. KeyExchangeId * unpack_key_exchange_id(Octstr *data, long *charpos) {
  572. KeyExchangeId *keyexid;
  574. /* create the KeyExchangeID */
  575. keyexid = (KeyExchangeId *)gw_malloc(sizeof(KeyExchangeId));
  577. keyexid->key_exchange_suite = octstr_get_char(data, *charpos);
  578. *charpos += 1;
  579. keyexid->param_specif = unpack_param_spec(data, charpos);
  580. keyexid->identifier = unpack_identifier(data, charpos);
  581. return keyexid;
  582. }
  584. List * unpack_array(Octstr *data, long *charpos) {
  585. int i;
  586. int array_length;
  587. List *array;
  589. /* create the list */
  590. array = list_create();
  592. /* get the size of the array */
  593. array_length = octstr_get_char(data, *charpos);
  594. *charpos += 1;
  596. /* store each entry in the list */
  597. for (i=0; i<array_length; i++)  {
  598. list_append(array, (void *)unpack_octstr(data, charpos));
  599. }
  601. return array;
  602. }
  604. List * unpack_key_list(Octstr *data, long *charpos) {
  605. KeyExchangeId *keyexid;
  606. List *key_list;
  607. int list_length;
  608. long endpos;
  610. /* create the list */
  611. key_list = list_create();
  613. /* get the size of the array */
  614. list_length = unpack_int16(data, charpos);
  615. endpos = *charpos + list_length;
  617. /* unpack the KeyExchangeIds */
  618. while (*charpos < endpos)
  619. {
  620. keyexid = unpack_key_exchange_id(data, charpos);
  621. list_append(key_list, (void *)keyexid);
  622. }
  623. return key_list;
  624. }
  626. List * unpack_ciphersuite_list(Octstr *data, long *charpos)
  627. {
  628. List *ciphersuites;
  629. int list_length;
  630. int i;
  631. CipherSuite *cs;
  633. /* create the list */
  634. ciphersuites = list_create();
  636. /* get the size of the array (in bytes, not elements)*/
  637. list_length = octstr_get_char(data, *charpos);
  638. *charpos += 1;
  640. /* unpack the CipherSuites */
  641. for (i=0; i<list_length; i+=2)
  642. {
  643. cs = (CipherSuite *)gw_malloc(sizeof(CipherSuite));
  644. cs->bulk_cipher_algo = octstr_get_char(data, *charpos);
  645. *charpos += 1;
  646. cs->mac_algo = octstr_get_char(data, *charpos);
  647. *charpos += 1;
  648. list_append(ciphersuites, (void *)cs);
  649. }
  651. return ciphersuites;
  652. }
  654. List * unpack_compression_method_list(Octstr *data, long *charpos) {
  655. List *compmethod_list;
  656. int list_length;
  657. int i;
  658. CompressionMethod *cm;
  660. /* create the list */
  661. compmethod_list = list_create();
  663. /* get the size of the array */
  664. list_length = octstr_get_char(data, *charpos);
  665. *charpos += 1;
  667. /* unpack the CompressionMethods */
  668. for (i=0; i<list_length; i++)
  669. {
  670. cm = gw_malloc(sizeof(CompressionMethod));
  671. *cm = octstr_get_char(data, *charpos);
  672. list_append(compmethod_list, (void *)cm);
  673. }
  675. return compmethod_list;
  676. }
  678. Identifier * unpack_identifier(Octstr *data, long *charpos) {
  679. Identifier *ident;
  681. /* create Identifier */
  682. ident = (Identifier *)gw_malloc(sizeof(Identifier));
  684. ident->id_type = octstr_get_char(data, *charpos);
  685. *charpos += 1;
  686. switch (ident->id_type) {
  687. case text:
  688. ident->charset = octstr_get_char(data, *charpos);
  689. *charpos += 1;
  690. ident->name = unpack_octstr(data, charpos);
  691. break;
  692. case binary:
  693. ident->identifier = unpack_octstr(data, charpos);
  694. break;
  695. case key_hash_sha:
  696. ident->key_hash = unpack_octstr(data, charpos);
  697. break;
  698. case x509_name:
  699. ident->distinguished_name = unpack_octstr(data, charpos);
  700. break;
  701. }
  702. return ident;
  703. }
  706. Signature * unpack_signature(Octstr *data, long *charpos) {
  707. Signature *sig;
  709. /* create Signature */
  710. sig = (Signature *)gw_malloc(sizeof(Signature));
  712. switch (signature_algo) {
  713. case ecdsa_sha:
  714. case rsa_sha:
  715. sig->sha_hash = unpack_array(data, charpos);
  716. break;
  717. }
  718. return sig;
  719. }
  721. WTLSCertificate * unpack_wtls_certificate(Octstr *data, long *charpos) {
  722. WTLSCertificate *cert;
  724. /* create the Certificate */
  725. cert = (WTLSCertificate *)gw_malloc(sizeof(WTLSCertificate));
  727. /* === unpack ToBeSignedCertificate === */
  728. cert->tobesigned_cert = (ToBeSignedCertificate *)gw_malloc(sizeof(ToBeSignedCertificate));
  729. /* version */
  730. cert->tobesigned_cert->certificate_version = octstr_get_char(data, *charpos);
  731. *charpos += 1;
  732. /* sig algo */
  733. cert->tobesigned_cert->signature_algo = octstr_get_char(data, *charpos);
  734. *charpos += 1;
  735. /* identifier */
  736. cert->tobesigned_cert->issuer->id_type = octstr_get_char(data, *charpos);
  737. *charpos += 1;
  738. /* issuer Identifier */
  739. cert->tobesigned_cert->issuer = unpack_identifier(data, charpos);
  740. /* validity periods */
  741. cert->tobesigned_cert->valid_not_before = unpack_int32(data, charpos);
  742. cert->tobesigned_cert->valid_not_after = unpack_int32(data, charpos);
  743. /* subject Identifier */
  744. cert->tobesigned_cert->subject = unpack_identifier(data, charpos);
  745. /* public_key_type */
  746. cert->tobesigned_cert->pubkey_type = octstr_get_char(data, *charpos);
  747. *charpos += 1;
  748. /* parameter specifier */
  749. cert->tobesigned_cert->param_spec = unpack_param_spec(data, charpos);
  750. /* public key */
  751. cert->tobesigned_cert->pubkey = unpack_public_key(data, charpos,
  752. cert->tobesigned_cert->pubkey_type);
  754. /* === pack Signature === */
  755. cert->signature = unpack_signature(data, charpos);
  756. return cert;
  757. }
  760. /*****************************************************************
  761.  * DESTROY functions
  762.  */
  763.  
  765. void destroy_octstr(Octstr *data) {
  766. octstr_destroy(data);
  767. }
  769. void destroy_octstr16(Octstr *data) {
  770. octstr_destroy(data);
  771. }
  773. void destroy_octstr_fixed(Octstr *data) {
  774. octstr_destroy(data);
  775. }
  777. void destroy_random(Random *random) {
  778. octstr_destroy(random->random_bytes);
  779. gw_free(random);
  780. }
  782. void destroy_dhparams(DHParameters *dhparams) {
  783. destroy_octstr16(dhparams->dh_p);
  784. destroy_octstr16(dhparams->dh_g);
  785. gw_free(dhparams);
  786. }
  788. void destroy_ecparams(ECParameters *ecparams) {
  789. /* field */
  790. switch (ecparams->field) {
  791. case ec_prime_p:
  792. octstr_destroy(ecparams->prime_p);
  793. break;
  794. case ec_characteristic_two:
  795. switch (ecparams->basis) {
  796. case ec_basis_onb:
  797. break;
  798. case ec_basis_trinomial:
  799. break;
  800. case ec_basis_pentanomial:
  801. break;
  802. case ec_basis_polynomial:
  803. octstr_destroy(ecparams->irreducible);
  804. break;
  805. }
  806. break;
  807. }
  808. /* pack the ECCurve */
  809. octstr_destroy(ecparams->curve->a);
  810. octstr_destroy(ecparams->curve->b);
  811. octstr_destroy(ecparams->curve->seed);
  812. /* pack the ECPoint */
  813. octstr_destroy(ecparams->base->point);
  814. /* order and cofactor */
  815. octstr_destroy(ecparams->order);
  816. octstr_destroy(ecparams->cofactor);
  818. gw_free(ecparams);
  819. }
  821. void destroy_param_spec(ParameterSpecifier *pspec) {
  822.   switch (public_key_algo) {
  823. case diffie_hellman_pubkey:
  824. destroy_dhparams(pspec->param_set->dhparams);
  825. break;
  826. case elliptic_curve_pubkey:
  827. destroy_ecparams(pspec->param_set->ecparams);
  828. break;
  829. }
  830. gw_free(pspec);
  831. }
  833. void destroy_public_key(PublicKey *key) {
  834. if(key->ecdh_pubkey)
  835. {
  836. octstr_destroy(key->ecdh_pubkey->point);
  837. gw_free(key->ecdh_pubkey);
  838. }
  839. if(key->ecdsa_pubkey)
  840. {
  841. octstr_destroy(key->ecdsa_pubkey->point);
  842. gw_free(key->ecdsa_pubkey);
  843. }
  844. if(key->rsa_pubkey)
  845. {
  846. destroy_rsa_pubkey(key->rsa_pubkey);
  847. }
  848. gw_free(key);
  849. }
  851. void destroy_rsa_pubkey(RSAPublicKey *key) {
  852. octstr_destroy(key->rsa_exponent);
  853. octstr_destroy(key->rsa_modulus);
  854. gw_free(key);
  855. }
  857. void destroy_ec_pubkey(ECPublicKey *key) {
  858. octstr_destroy(key->point);
  859. gw_free(key);
  860. }
  862. void destroy_dh_pubkey(DHPublicKey *key) {
  863. octstr_destroy(key->dh_Y);
  864. gw_free(key);
  865. }
  867. void destroy_rsa_secret(RSASecret *secret) {
  868. destroy_array(secret->random);
  869. gw_free(secret);
  870. }
  872. void destroy_rsa_encrypted_secret(RSAEncryptedSecret *secret) {
  873. octstr_destroy(secret->encrypted_secret);
  874. gw_free(secret);
  875. }
  877. void destroy_key_exchange_id(KeyExchangeId *keyexid) {
  878. destroy_param_spec(keyexid->param_specif);
  879. destroy_identifier(keyexid->identifier);
  880. gw_free(keyexid);
  881. }
  883. void destroy_array(List *array) {
  884. int i;
  886. /* pack each entry in the array */
  887. for (i=0; i<list_len(array); i++)
  888. {
  889. octstr_destroy((Octstr *) list_get(array, i));
  890. }
  892. list_destroy(array, NULL);
  893. }
  895. void destroy_key_list(List *key_list) {
  896. int i;
  897. /* destroy the KeyExchangeIds */
  898. for (i=0; i<list_len(key_list); i++) {
  899. destroy_key_exchange_id((KeyExchangeId *) list_get(key_list, i));
  900. }
  901. list_destroy(key_list, NULL);
  902. }
  904. void destroy_ciphersuite_list(List *ciphersuites) {
  905. int i;
  906. CipherSuite *cs;
  908. /* destroy the CipherSuites */
  909. for (i=0; i<list_len(ciphersuites); i++) {
  910. gw_free( (CipherSuite *) list_get(ciphersuites, i) );
  911. }
  913. list_destroy(ciphersuites, NULL);
  914. }
  916. void destroy_compression_method_list(List *compmethod_list) {
  917. int i;
  918. CompressionMethod *cm;
  920. /* destroy the CompressionMethods */
  921. for (i=0; i<list_len(compmethod_list); i++) {
  922. cm = (CompressionMethod*) list_get(compmethod_list, i);
  923. gw_free(cm);
  924. }
  926. gw_free(compmethod_list);
  927. }
  929. void destroy_identifier(Identifier *ident) {
  930. switch (ident->id_type) {
  931. case text:
  932. octstr_destroy(ident->name);
  933. break;
  934. case binary:
  935. octstr_destroy(ident->identifier);
  936. break;
  937. case key_hash_sha:
  938. octstr_destroy(ident->key_hash);
  939. break;
  940. case x509_name:
  941. octstr_destroy(ident->distinguished_name);
  942. break;
  943. }
  944. gw_free(ident);
  945. }
  947. void destroy_signature(Signature *sig) {
  948. switch (signature_algo) {
  949. case ecdsa_sha:
  950. case rsa_sha:
  951. destroy_array(sig->sha_hash);
  952. break;
  953. }
  954. gw_free(sig);
  955. }
  957. void destroy_wtls_certificate(WTLSCertificate *cert) {
  958. /* === destroy ToBeSignedCertificate === */
  959. /* issuer Identifier */
  960. destroy_identifier(cert->tobesigned_cert->issuer);
  961. /* subject Identifier */
  962. destroy_identifier(cert->tobesigned_cert->subject);
  963. /* parameter specifier */
  964. destroy_param_spec(cert->tobesigned_cert->param_spec);
  965. /* public key */
  966. destroy_public_key(cert->tobesigned_cert->pubkey);
  968. /* === destroy Signature === */
  969. destroy_signature(cert->signature);
  970. gw_free(cert);
  971. }
  974. /*****************************************************************
  975.  * DUMP functions
  976.  */
  977.  
  978. void dump_void16(unsigned char *dbg, int level, int i) {
  979. debug(dbg, 0, "%*s16 bit Int: %p", level, "", i);
  980. }
  982. void dump_int32(unsigned char *dbg, int level, long i) {
  983. debug(dbg, 0, "%*s32 bit Int: %p", level, "", i);
  984. }
  986. void dump_octstr(unsigned char *dbg, int level, Octstr *opaque) {
  987. octstr_dump(opaque, 0);
  988. }
  990. void dump_octstr16(unsigned char *dbg, int level, Octstr *opaque) {
  991. octstr_dump(opaque, 0);
  992. }
  994. void dump_octstr_fixed(unsigned char *dbg, int level, Octstr *opaque) {
  995. octstr_dump(opaque, 0);
  996. }
  998. void dump_random(unsigned char *dbg, int level, Random *random) {
  999. debug(dbg, 0, "%*sRandom :", level, "");
  1000. debug(dbg, 0, "%*sGMT Unix Time: %p", level+1, "", random->gmt_unix_time);
  1001. debug(dbg, 0, "%*sRandom Bytes:", level+1, "");
  1002. dump_octstr_fixed(dbg, level+2, random->random_bytes);
  1003. }
  1005. void dump_dhparams(unsigned char *dbg, int level, DHParameters *dhparams) {
  1006. debug(dbg, 0, "%*sDH Parameters :", level, "");
  1007. debug(dbg, 0, "%*sdh_e: %p", level+1, "", dhparams->dh_e);
  1008. debug(dbg, 0, "%*sdh_p:", level+1, "");
  1009. dump_octstr16(dbg, level+2, dhparams->dh_p);
  1010. debug(dbg, 0, "%*sdh_g:", level+1, "");
  1011. dump_octstr16(dbg, level+2, dhparams->dh_g);
  1012. }
  1014. void dump_ecparams(unsigned char *dbg, int level, ECParameters *ecparams) {
  1015. debug(dbg, 0, "%*sEC Parameters :", level, "");
  1016. /* field */
  1017. debug(dbg, 0, "%*sField: %p", level+1, "", ecparams->field);
  1018. switch (ecparams->field) {
  1019. case ec_prime_p:
  1020. debug(dbg, 0, "%*sprime_p :", level+1, "");
  1021. dump_octstr(dbg, level+1, ecparams->prime_p);
  1022. break;
  1023. case ec_characteristic_two:
  1024. /* m (16 bits) */
  1025. debug(dbg, 0, "%*sM: %p", level+1, "", ecparams->m);
  1026. /* basis */
  1027. debug(dbg, 0, "%*sBasis: %p", level+1, "", ecparams->basis);
  1028. switch (ecparams->basis) {
  1029. case ec_basis_onb:
  1030. break;
  1031. case ec_basis_trinomial:
  1032. debug(dbg, 0, "%*sK: %p", level+1, "", ecparams->k);
  1033. break;
  1034. case ec_basis_pentanomial:
  1035. debug(dbg, 0, "%*sk1: %p", level+1, "", ecparams->k1);
  1036. debug(dbg, 0, "%*sk2: %p", level+1, "", ecparams->k2);
  1037. debug(dbg, 0, "%*sk3: %p", level+1, "", ecparams->k3);
  1038. break;
  1039. case ec_basis_polynomial:
  1040. debug(dbg, 0, "%*sirreducible: %p", level+1, "");
  1041. dump_octstr(dbg, level+1, ecparams->irreducible);
  1042. break;
  1043. }
  1044. break;
  1045. }
  1046. /* pack the ECCurve */
  1047. debug(dbg, 0, "%*sEC Curve: %p", level+1, "");
  1048. debug(dbg, 0, "%*sa: %p", level+2, "");
  1049. dump_octstr(dbg, level+2, ecparams->curve->a);
  1050. debug(dbg, 0, "%*sb: %p", level+2, "");
  1051. dump_octstr(dbg, level+2, ecparams->curve->b);
  1052. debug(dbg, 0, "%*sseed: %p", level+2, "");
  1053. dump_octstr(dbg, level+2, ecparams->curve->seed);
  1054. /* pack the ECPoint */
  1055. debug(dbg, 0, "%*spoint: %p", level+2, "");
  1056. dump_octstr(dbg, level+2, ecparams->base->point);
  1057. /* order and cofactor */
  1058. debug(dbg, 0, "%*sorder: %p", level+2, "");
  1059. dump_octstr(dbg, level+2, ecparams->order);
  1060. debug(dbg, 0, "%*scofactor: %p", level+2, "");
  1061. dump_octstr(dbg, level+2, ecparams->cofactor);
  1062. }
  1064. void dump_param_spec(unsigned char *dbg, int level, ParameterSpecifier *pspec) {
  1065. debug(dbg, 0, "%*sParameterSpecifier:", level, "");
  1066. /* index */
  1067. debug(dbg, 0, "%*sParameter Index: %d", level+1, "", pspec->param_index);
  1068. /* ParameterSet struct */
  1069. if(pspec->param_index == 255) {
  1070. debug(dbg, 0, "%*sLength: %p", level+1, "", pspec->param_set->length);
  1071. switch (public_key_algo) {
  1072. case diffie_hellman_pubkey:
  1073. dump_dhparams(dbg, level+1, pspec->param_set->dhparams);
  1074. break;
  1075. case elliptic_curve_pubkey:
  1076. dump_ecparams(dbg, level+1, pspec->param_set->ecparams);
  1077. break;
  1078. }
  1079. }
  1080. }
  1082. void dump_public_key(unsigned char *dbg, int level, PublicKey *key, PublicKeyType key_type) {
  1083. switch (key_type) {
  1084. case ecdh_key:
  1085. debug(dbg, 0, "%*sPublicKey: %p", level, "");
  1086. debug(dbg, 0, "%*sECDH Point: %p", level+1, "");
  1087. dump_octstr(dbg, level+1, key->ecdh_pubkey->point);
  1088. break;
  1089. case ecdsa_key:
  1090. debug(dbg, 0, "%*sECDSA Point: %p", level+1, "");
  1091. dump_octstr(dbg, level+1, key->ecdsa_pubkey->point);
  1092. break;
  1093. case rsa_key:
  1094. dump_rsa_pubkey(dbg, level+1, key->rsa_pubkey);
  1095. break;
  1096. }
  1097. }
  1099. void dump_rsa_pubkey(unsigned char *dbg, int level, RSAPublicKey *key) {
  1100. debug(dbg, 0, "%*sRSA Public Key: %p", level, "");
  1101. debug(dbg, 0, "%*sRSA Exponent: %p", level+1, "");
  1102. dump_octstr(dbg, level+2, key->rsa_exponent);
  1103. debug(dbg, 0, "%*sRSA Modulus: %p", level+1, "");
  1104. dump_octstr(dbg, level+2, key->rsa_modulus);
  1105. }
  1107. void dump_ec_pubkey(unsigned char *dbg, int level, ECPublicKey *key) {
  1108. debug(dbg, 0, "%*sEC Public Key: %p", level, "");
  1109. debug(dbg, 0, "%*sPoint: %p", level+1, "");
  1110. dump_octstr(dbg, level+2, key->point);
  1111. }
  1113. void dump_dh_pubkey(unsigned char *dbg, int level, DHPublicKey *key) {
  1114. debug(dbg, 0, "%*sDH Public Key: %p", level, "");
  1115. dump_octstr(dbg, level+2, key->dh_Y);
  1116. }
  1118. void dump_rsa_secret(unsigned char *dbg, int level, RSASecret *secret) {
  1119. debug(dbg, 0, "%*sRSA Secret: %p", level, "");
  1120. debug(dbg, 0, "%*sClient Version: %p", level+1, "", secret->client_version);
  1121. debug(dbg, 0, "%*sRandom: %p", level, "");
  1122. dump_array(dbg, level+2, secret->random);
  1123. }
  1125. void dump_rsa_encrypted_secret(unsigned char *dbg, int level, RSAEncryptedSecret *secret) {
  1126. debug(dbg, 0, "%*sRSA Encrypted Secret: %p", level, "");
  1127. dump_octstr(dbg, level+1, secret->encrypted_secret);
  1128. }
  1130. void dump_key_exchange_id(unsigned char *dbg, int level, KeyExchangeId *keyexid) {
  1131. debug(dbg, 0, "%*sKey Exchange Id:", level, "");
  1132. debug(dbg, 0, "%*sKey Exch Suite: %d", level+1, "", keyexid->key_exchange_suite);
  1133. dump_param_spec(dbg, level+1, keyexid->param_specif);
  1134. dump_identifier(dbg, level+1, keyexid->identifier);
  1135. }
  1137. void dump_array(unsigned char *dbg, int level, List *array) {
  1138. int i;
  1140. /*debug(dbg, 0, "%*sOctstr Array: %p", level, "");*/
  1142. /* dump each entry in the array */
  1143. for (i=0; i<list_len(array); i++)
  1144. {
  1145. debug(dbg, 0, "%*sElement %d", level, "", i);
  1146. dump_octstr(dbg, level+1, (Octstr *) list_get(array, i));
  1147. }
  1148. }
  1150. void dump_key_list(unsigned char *dbg, int level, List *key_list) {
  1151. int i;
  1152. long pos = 0;
  1153. Octstr *buffer;
  1154. KeyExchangeId *keyexid;
  1156. debug(dbg, 0, "%*sKey List: %p", level, "");
  1158. /* pack the KeyExchangeIds */
  1159. for (i=0; i<list_len(key_list); i++) {
  1160. keyexid = (KeyExchangeId *) list_get(key_list, i);
  1162. dump_key_exchange_id(dbg, level+1, keyexid);
  1163. }
  1164. }
  1166. void dump_ciphersuite_list(unsigned char *dbg, int level, List *ciphersuites) {
  1167. int i;
  1168. CipherSuite *cs;
  1170. debug(dbg, 0, "%*sCipherSuite List: %p", level, "");
  1172. /* dump the CipherSuites */
  1173. for (i=0; i<list_len(ciphersuites); i++) {
  1174. cs = (CipherSuite *) list_get(ciphersuites, i);
  1175. debug(dbg, 0, "%*sBulk Cipher Algo: %p", level, "", cs->bulk_cipher_algo);
  1176. debug(dbg, 0, "%*sMAC Algo: %p", level, "", cs->mac_algo);
  1177. }
  1178. }
  1180. void dump_compression_method_list(unsigned char *dbg, int level, List *compmethod_list) {
  1181. int i;
  1183. debug(dbg, 0, "%*sCompression Method List: %p", level, "");
  1184. /* pack the CompressionMethods */
  1185. for (i=0; i<list_len(compmethod_list); i++) {
  1186. debug(dbg, 0, "%*sMethod %d: %p", level, "", i, 
  1187. (CompressionMethod) list_get(compmethod_list, i));
  1188. }
  1189. }
  1191. void dump_identifier(unsigned char *dbg, int level, Identifier *ident) {
  1192. debug(dbg, 0, "%*sIdentifier:", level, "");
  1193. debug(dbg, 0, "%*sIdent type: %d", level+1, "", ident->id_type);
  1194. switch (ident->id_type) {
  1195. case text:
  1196. debug(dbg, 0, "%*sCharset: %p", level+1, "", ident->charset);
  1197. debug(dbg, 0, "%*sNamet: %p", level+1, "", ident->name);
  1198. break;
  1199. case binary:
  1200. debug(dbg, 0, "%*sIdentifier: %p", level+1, "");
  1201. dump_octstr(dbg, level+2, ident->identifier);
  1202. break;
  1203. case key_hash_sha:
  1204. debug(dbg, 0, "%*sKey Hash: %p", level+1, "");
  1205. dump_octstr(dbg, level+2, ident->key_hash);
  1206. break;
  1207. case x509_name:
  1208. debug(dbg, 0, "%*sDistinguished Name: %p", level+1, "");
  1209. dump_octstr(dbg, level+2, ident->distinguished_name);
  1210. break;
  1211. }
  1212. }
  1214. void dump_signature(unsigned char *dbg, int level, Signature *sig) {
  1215. debug(dbg, 0, "%*sSignature: %p", level, "");
  1216. switch (signature_algo) {
  1217. case ecdsa_sha:
  1218. case rsa_sha:
  1219. dump_array(dbg, level+1, sig->sha_hash);
  1220. break;
  1221. }
  1222. }
  1224. void dump_wtls_certificate(unsigned char *dbg, int level, WTLSCertificate *cert) {
  1225. debug(dbg, 0, "%*sWTLS Certificate: %p", level, "");
  1226. /* === pack ToBeSignedCertificate === */
  1227. /* version */
  1228. debug(dbg, 0, "%*sCertificate Version: %p", level+1, "", cert->tobesigned_cert->certificate_version);
  1229. /* sig algo */
  1230. debug(dbg, 0, "%*sSignature Algo: %p", level+1, "", cert->tobesigned_cert->signature_algo);
  1231. /* identifier */
  1232. debug(dbg, 0, "%*sID Type: %p", level+1, "", cert->tobesigned_cert->issuer->id_type);
  1233. /* issuer Identifier */
  1234. dump_identifier(dbg, level+1, cert->tobesigned_cert->issuer);
  1235. /* validity periods */
  1236. debug(dbg, 0, "%*sValid not Before: %p", level+1, "", cert->tobesigned_cert->valid_not_before);
  1237. debug(dbg, 0, "%*sValid not After: %p", level+1, "", cert->tobesigned_cert->valid_not_after);
  1238. /* subject Identifier */
  1239. dump_identifier(dbg, level+1, cert->tobesigned_cert->subject);
  1240. /* public_key_type */
  1241. debug(dbg, 0, "%*sPublic Key Type: %p", level+1, "", cert->tobesigned_cert->pubkey_type);
  1242. /* parameter specifier */
  1243. dump_param_spec(dbg, level+1, cert->tobesigned_cert->param_spec);
  1244. /* public key */
  1245. dump_public_key(dbg, level+1, cert->tobesigned_cert->pubkey,
  1246. cert->tobesigned_cert->pubkey_type);
  1248. /* === pack Signature === */
  1249. dump_signature(dbg, level+1, cert->signature);
  1250. }
  1253. #endif