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

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

手机WAP编程

开发平台：

WINDOWS

wtls_pdu.c：源码内容
  1. /* 
  2.  * wtls_pdu.c: pack and unpack WTLS packets
  3.  *
  4.  * Generates packing and unpacking code from wtls_pdu.def.
  5.  *
  6.  */
  8. #include "gwlib/gwlib.h"
  10. #if (HAVE_WTLS_OPENSSL)
  12. #include "gwlib/octstr.h"
  13. #include "wtls_pdu.h"
  14. #include "wtls_pdusupport.h"
  15. #include "wtls_statesupport.h"
  17. KeyExchangeSuite client_key_exchange_algo = rsa_anon;
  18. PublicKeyAlgorithm public_key_algo;
  19. SignatureAlgorithm signature_algo;
  20. int seqnum;
  22. wtls_Payload* wtls_payload_unpack_from_offset (Octstr *data, int *offset);
  24. wtls_PDU *wtls_pdu_create(int type) {
  25.         wtls_PDU *pdu;
  26.         
  27.         pdu = gw_malloc(sizeof(*pdu));
  28.         pdu->type = type;
  29.         pdu->reserved = 0;
  30.         pdu->cipher = 0;
  31.         pdu->seqnum = 0;
  32.         pdu->rlen = 0;
  33.         
  34.         switch (pdu->type) {
  35.         case ChangeCipher_PDU:
  36.                 pdu->u.cc.change = 1;
  37. break;
  38.         case Alert_PDU:
  39.                 pdu->u.alert.level = 0;
  40.                 pdu->u.alert.desc = 0;
  41.                 pdu->u.alert.chksum = 0;
  42. break;
  43.         case Handshake_PDU:
  44.                 pdu->u.handshake.msg_type = 0;
  45.                 pdu->u.handshake.length = 0;
  46. break;
  47.         case Application_PDU:
  48.                 pdu->u.application.data = NULL;
  49. break;
  50.         default:
  51.                 warning(0, "Cannot create unknown WTLS PDU type %d", pdu->type);
  52.                 break;
  53.         }
  55.         return pdu;
  56. }
  58. void wtls_payload_destroy(wtls_Payload *payload) {
  59. octstr_destroy(payload->data);
  60. gw_free(payload);
  61. }
  63. void wtls_pdu_destroy(wtls_PDU *pdu) {
  64.         if (pdu == NULL)
  65.                 return;
  67.         switch (pdu->type) {
  68.         case ChangeCipher_PDU:
  69. /* no memory was allocated for ChangeCipher_PDU */
  70.   break;
  71.         case Alert_PDU:
  72. octstr_destroy(pdu->u.alert.chksum );
  73. break;
  74.         case Handshake_PDU:
  75.                 switch (pdu->u.handshake.msg_type) {
  76.                 case hello_request:
  77. break;
  78.                 case client_hello:
  79. destroy_random(pdu->u.handshake.client_hello->random);
  80. octstr_destroy(pdu->u.handshake.client_hello->session_id);
  81. destroy_key_list(pdu->u.handshake.client_hello->client_key_ids);
  82. destroy_key_list(pdu->u.handshake.client_hello->trusted_key_ids);
  83. destroy_ciphersuite_list(pdu->u.handshake.client_hello->ciphersuites);
  84. destroy_compression_method_list(pdu->u.handshake.client_hello->comp_methods);
  85. /* destroy the client_hello struct */
  86. gw_free(pdu->u.handshake.client_hello);
  87. break;
  88.                 case server_hello:
  89. destroy_random(pdu->u.handshake.server_hello->random);
  90. octstr_destroy(pdu->u.handshake.server_hello->session_id);
  91. /* destroy the server_hello struct */
  92. gw_free(pdu->u.handshake.server_hello);
  93. break;
  94.                 case certificate:
  95.                         switch (pdu->u.handshake.certificate->certificateformat) {
  96.                         case WTLSCert:
  97. destroy_wtls_certificate(pdu->u.handshake.certificate->wtls_certificate);
  98.                                 break;
  99.                         case X509Cert:
  100. octstr_destroy(pdu->u.handshake.certificate->x509_certificate);
  101.                                 break;
  102.                         case X968Cert:
  103. octstr_destroy(pdu->u.handshake.certificate->x968_certificate);
  104.                                 break;
  105.                         }
  106. gw_free(pdu->u.handshake.certificate);
  107. break;
  108.                 case server_key_exchange:
  109. destroy_param_spec(pdu->u.handshake.server_key_exchange->param_spec);
  110.                         switch (client_key_exchange_algo) {
  111.                         case rsa_anon:
  112. destroy_rsa_pubkey(pdu->u.handshake.server_key_exchange->rsa_params);
  113. break;
  114.                         case dh_anon:
  115.                                 destroy_dh_pubkey(pdu->u.handshake.server_key_exchange->dh_params);
  116. break;
  117.                         case ecdh_anon:
  118.                                 destroy_ec_pubkey(pdu->u.handshake.server_key_exchange->ecdh_params);
  119. break;
  120. }
  121. gw_free(pdu->u.handshake.server_key_exchange);
  122. break;
  123.                 case client_key_exchange:
  124.                         switch (client_key_exchange_algo) {
  125.                         case rsa:
  126.                         case rsa_anon:
  127.                                 destroy_rsa_encrypted_secret(pdu->u.handshake.client_key_exchange->rsa_params);
  128.                                 break;
  129.                         case dh_anon:
  130.                                 destroy_dh_pubkey(pdu->u.handshake.client_key_exchange->dh_anon_params);
  131.                                 break;
  132.                         case ecdh_anon:
  133.                         case ecdh_ecdsa:
  134.                                 destroy_ec_pubkey(pdu->u.handshake.client_key_exchange->ecdh_params);
  135. break;
  136. }
  137. gw_free(pdu->u.handshake.client_key_exchange);
  138. break;
  139.                 case server_hello_done:
  140. /* nothing to do here */
  141.                      break;
  142.                 }
  143. break;
  144.         case Application_PDU:
  145. octstr_destroy(pdu->u.application.data);
  146. break;
  147.         }
  149.         gw_free(pdu);
  150. }
  152. /* This function will pack a list of WTLS PDUs into a single Octstr, and return
  153.    that Octstr. */
  154. Octstr* wtls_pack_payloadlist (List* payloadlist) {
  156.         Octstr *returnData=0, *tempData1=0, *tempData2 = 0;
  157.         wtls_Payload* retrievedPDU;
  158.         
  159.         /* Assert that our payloadlist is not NULL */
  160.         gw_assert (payloadlist != NULL);
  162.         /* Initialise our return Octstr */
  163.         returnData = octstr_create("");
  164.         
  165.         /* While there are PDUs remaining in our list */
  166.         while (list_len(payloadlist) > 0) {                
  167.                 /* Retrieve the next payload from the payloadlist */
  168.                 retrievedPDU = (wtls_Payload*) list_extract_first (payloadlist);
  170.                 /* Pack the PDU */
  171.                 tempData2 = wtls_payload_pack(retrievedPDU);
  173.                 /* Shift the current stuff in returnData to a temporary pointer */
  174.                 tempData1 = returnData;
  175.                 
  176.                 /* Tack it onto our Octstr */
  177.                 returnData = octstr_cat(tempData1, tempData2);
  179.                 /* And now, we can get rid of both tempData1 and tempData2 */
  180.                 octstr_destroy (tempData1);
  181.                 octstr_destroy (tempData2);                
  182.         }
  183.         
  184.         /* Is the Octstr we finish with of length > 0? */
  185.         if (octstr_len(returnData) > 0) {        
  186.                 /* Return the Octstr */
  187.                 return returnData;
  188.         }
  189.         
  190.         /* Otherwise, return NULL */
  191.         return NULL;
  192. }
  194. /* This function will unpack an Octstr and return a list of all PDUs contained
  195.    within that Octstr. If the contents of the packet are garbled in some fashion,
  196.    and one packet fails to be decoded correctly, we will continue regardless, and
  197.    a partial list will be returned. NULL is returned if no PDUs can be successfully
  198.    decoded from the supplied data */
  199. List* wtls_unpack_payloadlist (Octstr *data) {
  201.         List* payloadlist = NULL;
  202.         int offset = 0;
  203.         int dataLength = 0;
  204.         wtls_Payload* tempPayload;
  205.         
  206.         /* Has somebody passed in an unpack of a null pointer ? */
  207.         gw_assert(data != NULL);
  208.         
  209.         /* Initialise our list */
  210.         payloadlist = list_create();
  211.         dataLength = octstr_len(data);
  212.         
  213.         /* While offset is less than the size of the data */
  214.         while( offset < dataLength) {
  216.                 debug("wtls:wtls_unpack_payloadlist",0,"Offset is now : %d", offset);
  217.                 /* Unpack from the supplied offset. This will bump up the value of offset */
  218.                 tempPayload = wtls_payload_unpack_from_offset (data, &offset);
  219.                 
  220.                 /* If the packet returned is not NULL */
  221.                 if (tempPayload != NULL) {
  222.                         /* Add the returned packet to the current list of packets */
  223.                         list_append(payloadlist, (void*) tempPayload);
  224.                 }
  225.         }
  227.         debug("wtls:wtls_unpack_payloadlist",0,"Finished, found %d PDUs", list_len(payloadlist));
  228.         
  229.         /* If the length of the list is greater than 0 */
  230.         if (list_len(payloadlist) > 0) {
  231.                 /* Return the List */
  232.                 return payloadlist;
  233.         }
  234.         
  235.         /* Otherwise return NULL */
  236.         return NULL;
  237. }
  239. /* This function tries to determine the length of the PDU at the start of the
  240.    supplied Octstr using (somewhat) intelligent means. If the packet is screwed
  241.    up in some fashion, returns length -1. Returns an int. */
  243. int wtls_payload_guess_length(Octstr* data) {
  245.         int type = 0, lengthFlag = 0, lengthSize = 0, pdu_length = 0;
  246.         long lengthOffset = 1;
  247.         
  248.         /* Is the fragment length indicator on? */
  249.         lengthFlag = octstr_get_bits(data, 0, 1);
  250.         if (lengthFlag) {
  251.                 lengthSize = 2;
  252.         }
  253.         
  254.         /* Is the sequence number indicator on? */
  255.         if (octstr_get_bits(data, 1, 1)) {
  256.                 /* Yes, so hop over two extra bytes when reading the length */
  257.                 lengthOffset += 2;
  258.         }
  259.         /* the message type */
  260.         type = octstr_get_bits(data, 4, 4);
  261.         
  262.         /* If fragment length is turned on, jump to the necessary spot */
  263.         if (lengthFlag == 1) {
  264.                 /* After this, lengthOffset + pdu_length == the total length of the PDU */
  265.                 pdu_length = unpack_int16(data, &lengthOffset);             
  266.         }
  268.         /* Oh great, so it's not switched on. How considerate. We'll have to make
  269.            a reasonable guess as to what it might be. */
  270.         else {
  271.                 switch (type) {
  272.                 case ChangeCipher_PDU:
  273.                         /* They're really short */
  274.                         pdu_length = 1;
  275.                         break;
  276.                         
  277.                 case Alert_PDU:
  278.                         /* They're a bit longer */
  279.                         pdu_length = 6;
  280.                         break;
  282.                 default:
  283.                         /* Otherwise just give up and play dead */
  284.                         pdu_length = -1;
  285.                         break;
  286.                 }
  287.         }
  289.         /* And that's the length of the contents, now just add the other doodads on */
  290.         if (pdu_length == -1) {
  291.                 return -1;
  292.         }
  293.         else {
  294.                 /* The pdu length, plus the sequence number, plus the length of the length value,
  295.                    plus the actual header byte */
  296.                 return (pdu_length + lengthOffset);
  297.         }
  298. }
  300. /* This function will unpack an Octstr, starting at the specified offset, and
  301.    return the corresponding wtls_PDU* which was generated from that offset. Offset
  302.    is changed during the running of this function, and ends up as the octet at the start of the
  303.    next pdu */
  305. wtls_Payload* wtls_payload_unpack_from_offset (Octstr *data, int *offset) {
  306.         int guessedPayloadLength = 0;
  307.         int dataLength = 0;
  308.         Octstr* dataFromOffset = 0;
  309.         Octstr* dataFromOffsetToLength = 0;
  310.         wtls_Payload* returnPayload = 0;
  311.         
  312.         /* This would be a sure sign of trouble */
  313.         gw_assert (offset != NULL);
  314.         gw_assert (data != NULL);
  315.         gw_assert (octstr_len(data) >= *offset);
  317.         dataLength = octstr_len(data);
  318.         
  319.         /* First, we need to figure out how long a PDU starting from
  320.            the specified offset is going to be. We need to peek quickly into the
  321.            PDU to check this */
  322.         dataFromOffset = octstr_copy(data, *offset, dataLength);
  323.         guessedPayloadLength = wtls_payload_guess_length(dataFromOffset);
  325.         /* Ooops. Something's wrong. This requested PDU is screwed up. */
  326.         if (guessedPayloadLength == -1) {
  327.                 *offset = dataLength;
  328.                 return NULL;
  329.         }
  330.         
  331.         /* Quit if we discover that the PDU length plus the requested offset is
  332.            larger than the length of the data supplied - this would mean that we
  333.            would overrun our data, and therefore something is corrupt in this PDU.
  334.            Set the offset as the data length, which will indicate we've gone as far
  335.            as we can */
  336.         if ((*offset + guessedPayloadLength) > dataLength) {
  337.                 *offset = dataLength;
  338.                 return NULL;
  339.         }
  340.         
  341.         /* If we pass that test, set offset to the correct return value */
  342.         *offset += guessedPayloadLength;
  343.         
  344.         /* Copy the octstr again, so that we end up with an octstr containing
  345.            just the PDU we want */
  346.         dataFromOffsetToLength = octstr_copy(dataFromOffset, 0, guessedPayloadLength);
  347.         
  348.         /* Submit that octstr to the wtls_message_unpack function */
  349.         returnPayload = wtls_payload_unpack(dataFromOffsetToLength);
  350.         
  351.         /* Test to make sure the returned PDU is good */
  352.         if (returnPayload != NULL) {        
  353.                 /* And return the PDU to our caller */
  354.                 return returnPayload;
  355.         }
  356.         
  357.         /* Otherwise return NULL */
  358.         return NULL;
  359. }        
  361. wtls_Payload *wtls_payload_unpack(Octstr *data) {
  362.         wtls_Payload *payload = NULL;
  363. Octstr *buffer;
  364.         long bitpos = 0, charpos = 0;
  365.         int msg_length;
  366.         
  367.         gw_assert(data != NULL);
  369.         payload = gw_malloc(sizeof(wtls_Payload));
  371.         /* the record field length flag */
  372.         payload->rlen = octstr_get_bits(data, bitpos, 1);
  373.         bitpos += 1;
  374.         /* the sequence number flag */
  375.         payload->seqnum = octstr_get_bits(data, bitpos, 1);
  376.         bitpos += 1;
  377.         /* the cipher usage flag */
  378.         payload->cipher = octstr_get_bits(data, bitpos, 1);
  379.         bitpos += 1;
  380.         /* the reserved bit */
  381.         payload->reserved = octstr_get_bits(data, bitpos, 1);
  382.         bitpos += 1;
  383.         /* the message type */
  384.         payload->type = octstr_get_bits(data, bitpos, 4);
  385.         bitpos += 4;
  386.         charpos += 1;
  387.         
  388.         /* get the sequence number if present */
  389.         if(payload->seqnum) {
  390.                 seqnum = unpack_int16(data, &charpos);
  391.         }
  392.         
  393.         /* get the WTLS plaintext length if present */
  394.         if(payload->rlen) {
  395.                 msg_length = unpack_int16(data, &charpos);
  396.         }
  398. /* the part of data that has just been processed is not
  399.    needed anymore. We delete it. What is left of data is
  400.    the payload. */
  401. octstr_delete(data, 0, charpos);
  402. payload->data = data;
  404. return payload;
  405. }
  407. void *wtls_payloadlist_destroy(List* payloadList) {
  408. wtls_Payload* currentPayload;
  409. int listLen, i;
  411. listLen = list_len(payloadList);
  412. for( i=0; i<listLen; i++) {
  413. currentPayload = (wtls_Payload *)list_get(payloadList, i);
  414. wtls_payload_destroy(currentPayload);
  415. }
  417. /* delete the list itself */
  418. gw_free(payloadList);
  419. }
  421. wtls_PDU *wtls_pdu_unpack(wtls_Payload *payload, WTLSMachine* wtls_machine) {
  422.         wtls_PDU *pdu = NULL;
  423.         Octstr *buffer;
  424.         long bitpos = 0, charpos = 0;
  425.         int msg_length;
  426.         
  427.         gw_assert(payload->data != NULL);
  429.         pdu = gw_malloc(sizeof(*pdu));
  431. pdu->type = payload->type;
  432. pdu->reserved = payload->reserved;
  433. pdu->cipher = payload->cipher;
  434. pdu->seqnum = payload->seqnum;
  435. pdu->rlen = payload->rlen;
  438. /* is the PDU encrypted ? */
  439. /*
  440. if(pdu->cipher) {
  441. buffer = wtls_decrypt(payload->data, wtls_machine);
  442. }
  443. else {
  444. */
  445. buffer = payload->data;
  446. /*
  447. }
  448. */
  450.         switch (pdu->type) {
  451.         case ChangeCipher_PDU:
  452.                 pdu->u.cc.change = octstr_get_char(buffer, charpos);
  453.                 charpos += 1;
  454.                 break;
  455.         case Alert_PDU:
  456.                 pdu->u.alert.level = octstr_get_char(buffer, charpos);
  457.                 charpos += 1;
  458.                 pdu->u.alert.desc = octstr_get_char(buffer, charpos);
  459.                 charpos += 1;
  460.                 pdu->u.alert.chksum = unpack_octstr_fixed(buffer, &charpos, 4);
  461.                 break;  
  462.         case Handshake_PDU:
  463.                 pdu->u.handshake.msg_type = octstr_get_char(buffer, charpos);
  464.                 charpos += 1;
  465.                 pdu->u.handshake.length = unpack_int16(buffer, &charpos);
  466.                 switch (pdu->u.handshake.msg_type) {
  467.                 case hello_request:
  468.                         break;
  469.                 case client_hello:
  470.                         pdu->u.handshake.client_hello = (ClientHello *)gw_malloc(sizeof(ClientHello));
  471.                         pdu->u.handshake.client_hello->clientversion = octstr_get_char(buffer, charpos);
  472.                         charpos += 1;
  473.                         pdu->u.handshake.client_hello->random = unpack_random(buffer, &charpos);
  474.                         pdu->u.handshake.client_hello->session_id = unpack_octstr(buffer, &charpos);
  476.                         /* pack the list of keys */
  477.                         pdu->u.handshake.client_hello->client_key_ids = unpack_key_list(buffer, &charpos);
  478.                         pdu->u.handshake.client_hello->trusted_key_ids = unpack_key_list(buffer, &charpos);
  480.                         /* pack the list of CipherSuites */
  481.                         pdu->u.handshake.client_hello->ciphersuites = unpack_ciphersuite_list(buffer, &charpos);
  483.                         /* CompressionMethods */
  484.                         pdu->u.handshake.client_hello->comp_methods = unpack_compression_method_list(buffer, &charpos);
  486.                         pdu->u.handshake.client_hello->snmode = octstr_get_char(buffer, charpos);
  487.                         charpos += 1;
  488.                         pdu->u.handshake.client_hello->krefresh = octstr_get_char(buffer, charpos);
  489.                         charpos += 1;
  490.                         break;
  491.                 case server_hello:
  492.                         pdu->u.handshake.server_hello = (ServerHello *)gw_malloc(sizeof(ServerHello));
  493.                         pdu->u.handshake.server_hello->serverversion = octstr_get_char(buffer, charpos);
  494.                         charpos += 1;
  495.                         pdu->u.handshake.server_hello->random = unpack_random(buffer, &charpos);
  496.                         pdu->u.handshake.server_hello->session_id = unpack_octstr(buffer, &charpos);
  497.                         charpos += 1;
  498.                         pdu->u.handshake.server_hello->client_key_id
  499.                                 = octstr_get_char(buffer, charpos);
  500.                         charpos += 1;
  501.                         /* CypherSuite */
  502.                         pdu->u.handshake.server_hello->ciphersuite->bulk_cipher_algo
  503.                                 = octstr_get_char(buffer, charpos);
  504.                         charpos += 1;
  505.                         pdu->u.handshake.server_hello->ciphersuite->mac_algo
  506.                                 = octstr_get_char(buffer, charpos);
  507.                         charpos += 1;
  509.                         /* CompressionMethod */
  510.                         pdu->u.handshake.server_hello->comp_method = octstr_get_char(buffer, charpos);
  511.                         charpos += 1;
  513.                         pdu->u.handshake.server_hello->snmode = octstr_get_char(buffer, charpos);
  514.                         charpos += 1;
  515.                         pdu->u.handshake.server_hello->krefresh = octstr_get_char(buffer, charpos);
  516.                         charpos += 1;
  517.                         break;
  518.                 case certificate:
  519.                         pdu->u.handshake.certificate = (Certificate *)gw_malloc(sizeof(Certificate));
  520.                         pdu->u.handshake.certificate->certificateformat = octstr_get_char(buffer, charpos);
  521.                         charpos += 1;
  522.                         switch (pdu->u.handshake.certificate->certificateformat) {
  523.                         case WTLSCert:
  524.                                 pdu->u.handshake.certificate->wtls_certificate = unpack_wtls_certificate(buffer, &charpos);
  525.                                 break;
  526.                         case X509Cert:
  527.                                 pdu->u.handshake.certificate->x509_certificate = unpack_octstr16(buffer, &charpos);
  528.                                 break;
  529.                         case X968Cert:
  530.                                 pdu->u.handshake.certificate->x968_certificate = unpack_octstr16(buffer, &charpos);
  531.                                 break;
  532.                         }
  533.                         break;
  534.                 case server_key_exchange:
  535.                         pdu->u.handshake.server_key_exchange = (ServerKeyExchange *)gw_malloc(sizeof(ServerKeyExchange));
  536.                         /* unpack the ParameterSpecifier  and ParameterSet*/
  537.                         pdu->u.handshake.server_key_exchange->param_spec
  538.                                 = unpack_param_spec(buffer, &charpos);
  539.                         switch (client_key_exchange_algo) {
  540.                         case rsa_anon:
  541.                                 pdu->u.handshake.server_key_exchange->rsa_params
  542.                                         = unpack_rsa_pubkey(buffer, &charpos);
  543.                                 break;
  544.                         case dh_anon:
  545.                                 pdu->u.handshake.server_key_exchange->dh_params
  546.                                         = unpack_dh_pubkey(buffer, &charpos);
  547.                                 break;
  548.                         case ecdh_anon:
  549.                                 pdu->u.handshake.server_key_exchange->ecdh_params
  550.                                         = unpack_ec_pubkey(buffer, &charpos);
  551.                                 break;
  552.                         }
  553.                         break;
  554.                 case client_key_exchange:
  555.                         pdu->u.handshake.client_key_exchange = (ClientKeyExchange *)gw_malloc(sizeof(ClientKeyExchange));
  556.                         switch (client_key_exchange_algo) {
  557.                         case rsa:
  558.                         case rsa_anon:
  559.                                 pdu->u.handshake.client_key_exchange->rsa_params
  560.                                         = unpack_rsa_encrypted_secret(buffer, &charpos);
  561.                                 break;
  562.                         case dh_anon:
  563.                                 pdu->u.handshake.client_key_exchange->dh_anon_params
  564.                                         = unpack_dh_pubkey(buffer, &charpos);
  565.                                 break;
  566.                         case ecdh_anon:
  567.                         case ecdh_ecdsa:
  568.                                 pdu->u.handshake.client_key_exchange->ecdh_params
  569.                                         = unpack_ec_pubkey(buffer, &charpos);
  570.                                 break;
  571.                         }
  572.                         break;
  573.                 case server_hello_done:
  574.                         /* empty */
  575.                         break;
  576.                 case finished:
  577.                         pdu->u.handshake.finished = (Finished *)gw_malloc(sizeof(Finished));
  578.                         pdu->u.handshake.finished->verify_data
  579.                                         = unpack_octstr_fixed(buffer, &charpos, 12);
  580. octstr_dump(pdu->u.handshake.finished->verify_data, 0);
  581.                         break;
  582.                 }
  583.                 break;
  584.         case Application_PDU:
  585.                 /* application message */
  586.                 pdu->u.application.data = octstr_duplicate(buffer);
  587.                 break;
  588.         default:
  589.                 debug("wap.wtls", 0, "%*sPDU: ", 0, "");
  590.                 octstr_dump(buffer, 0);
  591.                 panic(0, "Unpacking unknown WTLS PDU type %ld", (long) pdu->type);
  592.         }
  594.         return pdu;
  595. }
  598. Octstr *wtls_payload_pack(wtls_Payload *payload) {
  599.         Octstr *data;
  600.         long bitpos, charpos;
  601.         long messageSizePos, sizepos;
  602.         /* Used for length calculations */
  603.         int size;
  604.         
  605.         /* We rely on octstr_set_bits to lengthen our octstr as needed. */
  606.         data = octstr_create("");
  607.         bitpos = 0;
  608.         charpos = 0;
  609.         sizepos = 0;
  610.         
  611.         /* the record field length flag - always present*/
  612.         octstr_set_bits(data, bitpos, 1, 1);
  613.         bitpos += 1;
  614.         /* the sequence number flag */
  615.         octstr_set_bits(data, bitpos, 1, payload->seqnum);
  616.         bitpos += 1;
  617.         /* the cipher usage flag */
  618.         octstr_set_bits(data, bitpos, 1, payload->cipher);
  619.         bitpos += 1;
  620.         /* the reserved bit */
  621.         octstr_set_bits(data, bitpos, 1, payload->reserved);
  622.         bitpos += 1;
  624.         /* set the message type */
  625.         octstr_set_bits(data, bitpos, 4, payload->type);
  626.         bitpos += 4;
  627.         charpos += 1;
  629.         /* set the sequence number if present */
  630.         if(payload->seqnum) {
  631.                 charpos = pack_int16(data, charpos, payload->seqnum);
  632.         }
  634.         /* set the WTLS length  */
  635.         charpos = pack_int16(data, charpos, payload->rlen);
  636.         
  637.         /* append the data from the wtls_PDU */
  638.         octstr_insert(data, payload->data, octstr_len(data)); 
  639.         
  640.         return data;
  641. }
  644. wtls_Payload *wtls_pdu_pack(wtls_PDU *pdu, WTLSMachine* wtls_machine) {
  645.         Octstr *data, *buffer, *encryptedbuffer;
  646.         wtls_Payload *payload;
  647.         long bitpos, charpos;
  648.         long messageSizePos, sizepos;
  649.         /* Used for length calculations */
  650.         int size, recordType;
  651.         
  652. /* create the wtls_PDU */
  653. payload = (wtls_Payload *)gw_malloc(sizeof(wtls_Payload));
  654. payload->type = pdu->type;
  655. payload->reserved = pdu->reserved;
  656. payload->cipher = pdu->cipher;
  657. payload->seqnum = pdu->seqnum;
  659.         /* We rely on octstr_set_bits to lengthen our octstr as needed. */
  660.         data = octstr_create("");
  661.         buffer = octstr_create("");
  662.         bitpos = 0;
  663.         charpos = 0;
  664.         sizepos = 0;
  665.         
  666.         switch (pdu->type) {
  667.         case ChangeCipher_PDU:
  668.                 octstr_append_char(buffer, pdu->u.cc.change);
  669.                 charpos += 1;
  670.                 break;
  671.         case Alert_PDU:
  672.                 octstr_append_char(buffer, pdu->u.alert.level);
  673.                 charpos += 1;
  674.                 octstr_append_char(buffer, pdu->u.alert.desc);
  675.                 charpos += 1;
  676.                 charpos = pack_octstr_fixed(buffer, charpos, pdu->u.alert.chksum);
  677.                 charpos += 1;
  678.                 break;  
  679.         case Handshake_PDU:
  680.                 octstr_append_char(buffer, pdu->u.handshake.msg_type);
  681.                 charpos += 1;
  682.                 /* Save the location of the message size */
  683.                 messageSizePos = charpos;
  684.                 charpos = pack_int16 (buffer, charpos, pdu->u.handshake.length);
  685.                 switch (pdu->u.handshake.msg_type) {
  686.                 case hello_request:
  687.                         break;
  688.                 case client_hello:
  689.                         octstr_append_char(buffer, pdu->u.handshake.client_hello->clientversion);
  690.                         charpos += 1;
  691.                         charpos = pack_random(buffer, charpos, pdu->u.handshake.client_hello->random);
  692.                         octstr_append_char(buffer, octstr_len(
  693.                                 pdu->u.handshake.client_hello->session_id));
  694.                         charpos += 1;
  695.                         charpos = pack_octstr(buffer, charpos, pdu->u.handshake.client_hello->session_id);
  697.                         /* pack the list of keys */
  698.                         charpos = pack_key_list(buffer, charpos,
  699.                                                 pdu->u.handshake.client_hello->client_key_ids);
  700.                         charpos = pack_key_list(buffer, charpos,
  701.                                                 pdu->u.handshake.client_hello->trusted_key_ids);
  703.                         /* pack the list of CipherSuites */
  704.                         charpos = pack_ciphersuite_list(buffer, charpos,
  705.                                                         pdu->u.handshake.client_hello->ciphersuites);
  707.                         /* CompressionMethods */
  708.                         charpos = pack_compression_method_list(buffer, charpos,
  709.                                                                pdu->u.handshake.client_hello->comp_methods);
  711.                         octstr_append_char(buffer, pdu->u.handshake.client_hello->snmode);
  712.                         charpos += 1;
  713.                         octstr_append_char(buffer, pdu->u.handshake.client_hello->krefresh);
  714.                         charpos += 1;
  715.                         break;
  716.                 case server_hello:
  717.                         octstr_append_char(buffer, pdu->u.handshake.server_hello->serverversion);
  718.                         charpos += 1;
  719.                         charpos = pack_random(buffer,  charpos, pdu->u.handshake.server_hello->random);
  720.                         charpos = pack_octstr(buffer, charpos, pdu->u.handshake.server_hello->session_id);
  721.                         charpos += 1;
  722.                         octstr_append_char(buffer, pdu->u.handshake.server_hello->
  723.                                            client_key_id);
  724.                         charpos += 1;
  725.                         /* CypherSuite */
  726.                         octstr_append_char(buffer, pdu->u.handshake.server_hello->
  727.                                            ciphersuite->bulk_cipher_algo);
  728.                         charpos += 1;
  729.                         octstr_append_char(buffer, pdu->u.handshake.server_hello->
  730.                                            ciphersuite->mac_algo);
  731.                         charpos += 1;
  733.                         /* CompressionMethod */
  734.                         octstr_append_char(buffer, pdu->u.handshake.server_hello->comp_method);
  735.                         charpos += 1;
  737.                         octstr_append_char(buffer, pdu->u.handshake.server_hello->snmode);
  738.                         charpos += 1;
  739.                         octstr_append_char(buffer, pdu->u.handshake.server_hello->krefresh);
  740.                         charpos += 1;
  742.                         break;
  743.                 case certificate:
  744.                         octstr_append_char(buffer, pdu->u.handshake.certificate->certificateformat);
  745.                         charpos += 1;
  746.                         switch (pdu->u.handshake.certificate->certificateformat) {
  747.                         case WTLSCert:
  748.                                 charpos = pack_wtls_certificate(buffer, charpos, pdu->u.handshake.certificate->wtls_certificate);
  749.                                 break;
  750.                         case X509Cert:
  751.                                 charpos = pack_octstr16(buffer, charpos, pdu->u.handshake.certificate->x509_certificate);
  752.                                 break;
  753.                         case X968Cert:
  754.                                 charpos = pack_octstr16(buffer, charpos, pdu->u.handshake.certificate->x968_certificate);
  755.                                 break;
  756.                         }
  757.                         break;
  758.                 case server_key_exchange:
  759.             debug("wtls: ", 0,"Packing ServerKeyExchange");
  760.                         /* pack the ParameterSpecifier */
  761.                         charpos = pack_param_spec(buffer, charpos, pdu->u.handshake.server_key_exchange->param_spec);
  763.                         switch (client_key_exchange_algo) {
  764.                         case rsa_anon:
  765.                                 charpos = pack_rsa_pubkey(buffer, charpos, pdu->u.handshake.server_key_exchange->rsa_params);
  766.                                 break;
  767.                         case dh_anon:
  768.                                 charpos = pack_dh_pubkey(buffer, charpos, pdu->u.handshake.server_key_exchange->dh_params);
  769.                                 break;
  770.                         case ecdh_anon:
  771.                                 charpos = pack_ec_pubkey(buffer, charpos, pdu->u.handshake.server_key_exchange->ecdh_params);
  772.                                 break;
  773.                         }
  774.                         break;
  775.                 case client_key_exchange:
  776.                         switch (client_key_exchange_algo) {
  777.                         case rsa:
  778.                         case rsa_anon:
  779.                                 charpos = pack_rsa_encrypted_secret(buffer, charpos, pdu->u.handshake.client_key_exchange->rsa_params);
  780.                                 break;
  781.                         case dh_anon:
  782.                                 charpos = pack_dh_pubkey(buffer, charpos, pdu->u.handshake.client_key_exchange->dh_anon_params);
  783.                                 break;
  784.                         case ecdh_anon:
  785.                         case ecdh_ecdsa:
  786.                                 charpos = pack_ec_pubkey(buffer, charpos, pdu->u.handshake.client_key_exchange->ecdh_params);
  787.                                 break;
  788.                         }
  789.                         break;
  790.                 case server_hello_done:
  791.                         /* empty */
  792.                         break;
  793. case finished:
  794. charpos = pack_octstr_fixed(buffer, charpos, pdu->u.handshake.finished->verify_data);
  795. debug("wtls", 0, "verify_data (in pack)");
  796. octstr_dump(pdu->u.handshake.finished->verify_data,0 );
  797. break;
  798.                 }
  799.                 /* Change the length */
  800.                 size = octstr_len(buffer) - messageSizePos - 2;
  801.                 debug("wtls_msg.c:length",0,"Setting msg size to : %d",size);
  802.                 octstr_set_char(buffer, messageSizePos, (size & 0xFF00) >> 8);
  803. messageSizePos += 1;
  804. octstr_set_char(buffer, messageSizePos, (size & 0x00FF));
  806. /* we keep the handshake data to create the Finished PDU */
  807. octstr_append(wtls_machine->handshake_data, buffer);
  808.                 break;                
  809.         case Application_PDU:
  810.                 /* application message */
  811.                 charpos += pack_octstr(data, charpos, pdu->u.application.data);
  812.                 break;
  813.      default:
  814.                 panic(0, "Packing unknown WTLS PDU type %ld", (long) pdu->type);
  815.         }
  816.         
  817.         /* encrypt the buffer if needed */
  818.         if(pdu->cipher) {
  819. /* the MAC is calculated with the record type so we need it now */
  820. recordType = 1 << 7; /* length, always present */
  821. recordType |= pdu->seqnum << 6;
  822. recordType |= pdu->cipher << 5;
  823. recordType |= pdu->reserved << 4;
  824. recordType |= pdu->type;
  825.                 encryptedbuffer = wtls_encrypt(buffer, wtls_machine, recordType);
  827.                 payload->data = encryptedbuffer;
  828.         }
  829.         else {
  830.                 payload->data = buffer;
  831.         }
  833.         payload->rlen = octstr_len(payload->data);
  834.         debug("wtls", 0, "Packed PDU Length: %d", payload->rlen);
  835.         
  836.         return payload;
  837. }
  839. void wtls_pdu_dump(wtls_PDU *pdu, int level) {
  840. unsigned char *dbg = "wap.wtls";
  842. /* the message type */
  843. debug(dbg, 0, "%*sPDU type: %p", level, "", pdu->type);
  844. /* the reserved bit */
  845. debug(dbg, 0, "%*sReserved bit: %p", level, "", pdu->reserved);
  846. /* cipher usage flag */
  847. debug(dbg, 0, "%*sCipher in use: %p", level, "", pdu->cipher);
  848. /* the sequence number flag */
  849. debug(dbg, 0, "%*sSequence number in use: %p", level, "", pdu->seqnum);
  850. /* the record field length flag */
  851. debug(dbg, 0, "%*sRecord field length present: %p", level, "", pdu->rlen);
  853. switch (pdu->type) {
  854. case ChangeCipher_PDU:
  855. debug(dbg, 0, "%*sChangeCipher:", level, "");
  856. debug(dbg, 0, "%*sChange: %d", level+1, "", pdu->u.cc.change);
  857. break;
  858. case Alert_PDU:
  859. debug(dbg, 0, "%*sAlert:", level, "");
  860. debug(dbg, 0, "%*sLevel: %p", level+1, "", pdu->u.alert.level);
  861. debug(dbg, 0, "%*sDescription: %d", level+1, "", pdu->u.alert.desc);
  862. debug(dbg, 0, "%*sChecksum: %p", level+1, "", pdu->u.alert.chksum);
  863. break;
  864. case Handshake_PDU:
  865. debug(dbg, 0, "%*sHandshake:", level, "");
  866. debug(dbg, 0, "%*sMessage Type: %d", level+1, "", pdu->u.handshake.msg_type);
  867. debug(dbg, 0, "%*sLength: %d", level+1, "", pdu->u.handshake.length);
  868. switch (pdu->u.handshake.msg_type) {
  869. case hello_request:
  870. debug(dbg, 0, "%*sHelloRequest.", level, "");
  871. break;
  872. case client_hello:
  873. debug(dbg, 0, "%*sClientHello :", level, "");
  874. debug(dbg, 0, "%*sClient version: %d", level+1, "", pdu->u.handshake.client_hello->clientversion);
  875. debug(dbg, 0, "%*sRandom:", level+1, "");
  876. dump_random(dbg, level+2,
  877. pdu->u.handshake.client_hello->random);
  878. debug(dbg, 0, "%*sSessionId: ", level, "");
  879. octstr_dump(pdu->u.handshake.client_hello->session_id, level + 2);
  881. /* pack the list of keys */
  882. debug(dbg, 0, "%*sClient Key IDs: ", level+1, "");
  883. dump_key_list(dbg, level+2,
  884. pdu->u.handshake.client_hello->client_key_ids);
  885. debug(dbg, 0, "%*sTrusted Key IDs: ", level+1, "");
  886. dump_key_list(dbg, level+2,
  887. pdu->u.handshake.client_hello->trusted_key_ids);
  889. /* pack the list of CipherSuites */
  890. debug(dbg, 0, "%*sCipherSuite List: ", level+1, "");
  891. dump_ciphersuite_list(dbg, level+2,
  892. pdu->u.handshake.client_hello->ciphersuites);
  894. /* CompressionMethods */
  895. debug(dbg, 0, "%*sCompression Method List: ", level+1, "");
  896. dump_compression_method_list(dbg, level+2,
  897. pdu->u.handshake.client_hello->comp_methods);
  899. debug(dbg, 0, "%*sSeq Number Mode: %d", level+1, "", pdu->u.handshake.client_hello->snmode);
  900. debug(dbg, 0, "%*sKey Refresh: %p", level+1, "", pdu->u.handshake.client_hello->krefresh);
  901. break;
  902. case server_hello:
  903. debug(dbg, 0, "%*sServerHello :", level, "");
  904. debug(dbg, 0, "%*sServer version: %d", level+1, "", pdu->u.handshake.server_hello->serverversion);
  905. debug(dbg, 0, "%*sRandom:", level+1, "");
  906. dump_random(dbg, level+2,
  907. pdu->u.handshake.server_hello->random);
  908. debug(dbg, 0, "%*sSession ID: %d", level+1, "", pdu->u.handshake.server_hello->session_id);
  909. debug(dbg, 0, "%*sClient Key ID: %p", level+1, "", pdu->u.handshake.server_hello->client_key_id);
  910. /* CypherSuite */
  911. debug(dbg, 0, "%*sBulk Cipher Algo: %p", level+1, "", pdu->u.handshake.server_hello->ciphersuite->bulk_cipher_algo);
  912. debug(dbg, 0, "%*sMAC Algo: %p", level+1, "", pdu->u.handshake.server_hello->ciphersuite->mac_algo);
  914. /* CompressionMethod */
  915. debug(dbg, 0, "%*sCompression Method: %p", level+1, "", pdu->u.handshake.server_hello->comp_method);
  917. debug(dbg, 0, "%*sSeq Number Mode: %p", level+1, "", pdu->u.handshake.server_hello->snmode);
  918. debug(dbg, 0, "%*sKey Refresh: %p", level+1, "", pdu->u.handshake.server_hello->krefresh);
  919. break;
  920. case certificate:
  921. debug(dbg, 0, "%*sCertificate :", level, "");
  922. debug(dbg, 0, "%*sCertificate Format: %p", level+1, "", pdu->u.handshake.certificate->certificateformat);
  923. switch (pdu->u.handshake.certificate->certificateformat) {
  924. case WTLSCert:
  925. debug(dbg, 0, "%*sWTLS Certificate: %p", level+1, "");
  926. dump_wtls_certificate(dbg, level+2, pdu->u.handshake.certificate->wtls_certificate);
  927. break;
  928. case X509Cert:
  929. debug(dbg, 0, "%*sX509 Certificate: %p", level+1, "");
  930. octstr_dump(pdu->u.handshake.certificate->x509_certificate, level+2);
  931. break;
  932. case X968Cert:
  933. debug(dbg, 0, "%*sX968 Certificate: %p", level+1, "");
  934. octstr_dump(pdu->u.handshake.certificate->x968_certificate, level+2);
  935. break;
  936. }
  937. break;
  938. case server_key_exchange:
  939. debug(dbg, 0, "%*sServerKeyExchange :", level, "");
  940. /* ParameterSpecifier */
  941. debug(dbg, 0, "%*sParameter Index: %p", level+1, "", pdu->u.handshake.server_key_exchange->param_spec->param_index);
  942. if(pdu->u.handshake.server_key_exchange->param_spec->param_index == 255) {
  943. /* ParameterSet */
  944. debug(dbg, 0, "%*sParameter Set: %p", level+1, "", pdu->u.handshake.server_key_exchange->param_spec->param_set);
  945. }
  946. switch (client_key_exchange_algo) {
  947. case rsa_anon:
  948. dump_rsa_pubkey(dbg, level+1, pdu->u.handshake.server_key_exchange->rsa_params);
  949. break;
  950. case dh_anon:
  951. dump_dh_pubkey(dbg, level+1, pdu->u.handshake.server_key_exchange->dh_params);
  952. break;
  953. case ecdh_anon:
  954. dump_ec_pubkey(dbg, level+1, pdu->u.handshake.server_key_exchange->ecdh_params);
  955. break;
  956. }
  957. break;
  958. case client_key_exchange:
  959. debug(dbg, 0, "%*sClientKeyExchange :", level, "");
  960. switch (client_key_exchange_algo) {
  961. case rsa:
  962. case rsa_anon:
  963. dump_rsa_encrypted_secret(dbg, level+1, pdu->u.handshake.client_key_exchange->rsa_params);
  964. break;
  965. case dh_anon:
  966. dump_dh_pubkey(dbg, level+1, pdu->u.handshake.client_key_exchange->dh_anon_params);
  967. break;
  968. case ecdh_anon:
  969. case ecdh_ecdsa:
  970. dump_ec_pubkey(dbg, level+1, pdu->u.handshake.client_key_exchange->ecdh_params);
  971. break;
  972. }
  973. break;
  974. case server_hello_done:
  975. debug(dbg, 0, "%*sClientHelloDone.", level, "");
  976. /* empty */
  977. break;
  978. case finished:
  979. debug(dbg, 0, "%*sFinished :", level, "");
  980. debug(dbg, 0, "%*sverify_data :", level+1, "");
  981. octstr_dump(pdu->u.handshake.finished->verify_data, level+2);
  982. break;
  983. }
  984. break;
  985. case Application_PDU:
  986. debug(dbg, 0, "%*sApplication :", level, "");
  987. /* application message */
  988. octstr_dump(pdu->u.application.data, level+1);
  989. break;
  990. default:
  991. debug(dbg, 0, "%*sWTLS PDU at %p:", level, "", (void *)pdu);
  992. debug(dbg, 0, "%*s unknown type %u", level, "", pdu->type);
  993. }
  995. }
  997. #endif