wtls_pdusupport.c

Go to the documentation of this file.

/* ==================================================================== 
 * The Kannel Software License, Version 1.0 
 * 
 * Copyright (c) 2001-2018 Kannel Group  
 * Copyright (c) 1998-2001 WapIT Ltd.   
 * All rights reserved. 
 * 
 * Redistribution and use in source and binary forms, with or without 
 * modification, are permitted provided that the following conditions 
 * are met: 
 * 
 * 1. Redistributions of source code must retain the above copyright 
 *    notice, this list of conditions and the following disclaimer. 
 * 
 * 2. Redistributions in binary form must reproduce the above copyright 
 *    notice, this list of conditions and the following disclaimer in 
 *    the documentation and/or other materials provided with the 
 *    distribution. 
 * 
 * 3. The end-user documentation included with the redistribution, 
 *    if any, must include the following acknowledgment: 
 *       "This product includes software developed by the 
 *        Kannel Group (http://www.kannel.org/)." 
 *    Alternately, this acknowledgment may appear in the software itself, 
 *    if and wherever such third-party acknowledgments normally appear. 
 * 
 * 4. The names "Kannel" and "Kannel Group" must not be used to 
 *    endorse or promote products derived from this software without 
 *    prior written permission. For written permission, please  
 *    contact org@kannel.org. 
 * 
 * 5. Products derived from this software may not be called "Kannel", 
 *    nor may "Kannel" appear in their name, without prior written 
 *    permission of the Kannel Group. 
 * 
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED 
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
 * DISCLAIMED.  IN NO EVENT SHALL THE KANNEL GROUP OR ITS CONTRIBUTORS 
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,  
 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT  
 * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR  
 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,  
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE  
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,  
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 * ==================================================================== 
 * 
 * This software consists of voluntary contributions made by many 
 * individuals on behalf of the Kannel Group.  For more information on  
 * the Kannel Group, please see <http://www.kannel.org/>. 
 * 
 * Portions of this software are based upon software originally written at  
 * WapIT Ltd., Helsinki, Finland for the Kannel project.  
 */ 

/* 
 * wtls_support.c: pack and unpack WTLS packets
 *
 * Support functions for packing and unpacking PDUs
 * 
 * Nikos Balkanas, Inaccess Networks (2009)
 *
 */

#include "gwlib/gwlib.h"

#ifdef HAVE_WTLS_OPENSSL

#include "wtls_pdu.h"
#include "wtls_pdusupport.h"
#include "wtls_statesupport.h"

extern PublicKeyAlgorithm public_key_algo;
extern SignatureAlgorithm signature_algo;

/* Function prototypes */

void destroy_octstr(Octstr * data);
void destroy_octstr16(Octstr * data);
void destroy_octstr_fixed(Octstr * data);
void destroy_dhparams(DHParameters * dhparams);
void destroy_ecparams(ECParameters * ecparams);
void destroy_public_key(PublicKey * key);
void destroy_rsa_secret(RSASecret * secret);
void destroy_key_exchange_id(KeyExchangeId * keyexid);
void destroy_signature(Signature * sig);
void dump_void16(char *dbg, int level, int i);

/*****************************************************************
 * PACK functions
 */

int pack_int16(Octstr * data, long charpos, int i)
{
    octstr_append_char(data, (i & 0xFF00) >> 8);
    charpos += 1;
    octstr_append_char(data, i & 0x00FF);
    charpos += 1;
    return charpos;
}

int pack_int32(Octstr * data, long charpos, long i)
{
    charpos = pack_int16(data, charpos, (i & 0xFFFF0000) >> 16);
    charpos = pack_int16(data, charpos, i & 0xFFFF);
    return charpos;
}

int pack_octstr(Octstr * data, long charpos, Octstr * opaque)
{
    octstr_append_char(data, octstr_len(opaque));
    charpos += 1;
    octstr_insert(data, opaque, octstr_len(data));
    charpos += octstr_len(opaque);
    return charpos;
}

int pack_octstr16(Octstr * data, long charpos, Octstr * opaque)
{
    charpos += pack_int16(data, charpos, octstr_len(opaque));
    octstr_insert(data, opaque, octstr_len(data));
    charpos += octstr_len(opaque);
    return charpos;
}

int pack_octstr_fixed(Octstr * data, long charpos, Octstr * opaque)
{
    octstr_insert(data, opaque, octstr_len(data));
    charpos += octstr_len(opaque);
    return charpos;
}

int pack_random(Octstr * data, long charpos, Random * random)
{
    charpos = pack_int32(data, charpos, random->gmt_unix_time);
    charpos = pack_octstr_fixed(data, charpos, random->random_bytes);
    return charpos;
}

int pack_dhparams(Octstr * data, long charpos, DHParameters * dhparams)
{
    octstr_append_char(data, dhparams->dh_e);
    charpos += 1;
    charpos = pack_octstr16(data, charpos, dhparams->dh_p);
    charpos = pack_octstr16(data, charpos, dhparams->dh_g);
    return charpos;
}

int pack_ecparams(Octstr * data, long charpos, ECParameters * ecparams)
{
    /* field */
    octstr_append_char(data, ecparams->field);
    charpos += 1;
    switch (ecparams->field) {
    case ec_prime_p:
        charpos = pack_octstr(data, charpos, ecparams->prime_p);
        break;
    case ec_characteristic_two:
        /* m (16 bits) */
        charpos = pack_int16(data, charpos, ecparams->m);
        /* basis */
        octstr_append_char(data, ecparams->basis);
        charpos += 1;
        switch (ecparams->basis) {
        case ec_basis_onb:
            break;
        case ec_basis_trinomial:
            charpos = pack_int16(data, charpos, ecparams->k);
            break;
        case ec_basis_pentanomial:
            charpos = pack_int16(data, charpos, ecparams->k1);
            charpos = pack_int16(data, charpos, ecparams->k2);
            charpos = pack_int16(data, charpos, ecparams->k3);
            break;
        case ec_basis_polynomial:
         charpos =
             pack_octstr(data, charpos, ecparams->irreducible);
            break;
        }
        break;
    }
    /* pack the ECCurve */
    charpos = pack_octstr(data, charpos, ecparams->curve->a);
    charpos = pack_octstr(data, charpos, ecparams->curve->b);
    charpos = pack_octstr(data, charpos, ecparams->curve->seed);
    /* pack the ECPoint */
    charpos = pack_octstr(data, charpos, ecparams->base->point);
    /* order and cofactor */
    charpos = pack_octstr(data, charpos, ecparams->order);
    charpos = pack_octstr(data, charpos, ecparams->cofactor);

    return charpos; 
}

int pack_param_spec(Octstr * data, long charpos, ParameterSpecifier * pspec)
{
   if (pspec == NULL) {
    octstr_append_char(data, 0);
    charpos += 1;
        return charpos;
        }        

        /* index */
    octstr_append_char(data, pspec->param_index);
    charpos += 1;
    /* ParameterSet struct */
    octstr_append_char(data, pspec->param_set->length);
    charpos += 1;
    switch (public_key_algo) {
    case diffie_hellman_pubkey:
        pack_dhparams(data, charpos, pspec->param_set->dhparams);
        break;
    case elliptic_curve_pubkey:
        pack_ecparams(data, charpos, pspec->param_set->ecparams);
        break;
   default:
      break;
    }
    return charpos;
}

int pack_public_key(Octstr * data, long charpos, PublicKey * key,
          PublicKeyType key_type)
{
    switch (key_type) {
    case ecdh_key:
        charpos = pack_octstr(data, charpos, key->ecdh_pubkey->point);
        break;
    case ecdsa_key:
        charpos = pack_octstr(data, charpos, key->ecdsa_pubkey->point);
        break;
    case rsa_key:
        charpos = pack_rsa_pubkey(data, charpos, key->rsa_pubkey);
        break;
    }
    return charpos;
}

int pack_rsa_pubkey(Octstr * data, long charpos, RSAPublicKey * key)
{
    charpos = pack_octstr16(data, charpos, key->rsa_exponent);
    charpos = pack_octstr16(data, charpos, key->rsa_modulus);
    return charpos;
}

int pack_ec_pubkey(Octstr * data, long charpos, ECPublicKey * key)
{
    charpos = pack_octstr(data, charpos, key->point);
    return charpos;
}

int pack_dh_pubkey(Octstr * data, long charpos, DHPublicKey * key)
{
    charpos = pack_octstr16(data, charpos, key->dh_Y);
    return charpos;
}

int pack_rsa_secret(Octstr * data, long charpos, RSASecret * secret)
{
    octstr_append_char(data, secret->client_version);
    charpos += 1;
    charpos = pack_array(data, charpos, secret->random);
    return charpos;
}

int pack_rsa_encrypted_secret(Octstr * data, long charpos,
    RSAEncryptedSecret * secret)
{
    charpos = pack_octstr16(data, charpos, secret->encrypted_secret);
    return charpos;
}

int pack_key_exchange_id(Octstr * data, long charpos, KeyExchangeId * keyexid)
{
    octstr_set_char(data, charpos, keyexid->key_exchange_suite);
    charpos += 1;
    charpos = pack_param_spec(data, charpos, keyexid->param_specif);
    charpos = pack_identifier(data, charpos, keyexid->identifier);
    return charpos;
}

int pack_array(Octstr * data, long charpos, List * array)
{
    int i;
    long pos = 0;
    Octstr *buffer;
    
    /* we need to know the length in bytes of the list
       so we pack everything in a buffer for now. */
    buffer = octstr_create("");
    
    /* pack each entry in the buffer */
   for (i = 0; i < gwlist_len(array); i++) {
        pos = pack_octstr(buffer, pos, (Octstr *) gwlist_get(array, i));
    }
    
    /* now we know the size of the list */
    charpos = pack_int16(data, charpos, pos);
    
    /* append the buffer */
    charpos = pack_octstr_fixed(data, charpos, buffer);

    return charpos;
}

int pack_key_list(Octstr * data, long charpos, List * key_list)
{
    int i;
    long pos = 0;
    Octstr *buffer;
    KeyExchangeId *keyexid;
    
    /* we need to know the length in bytes of the list
       so we pack everything in a buffer for now. */
    buffer = octstr_create("");
    
    /* pack the KeyExchangeIds */
   for (i = 0; i < gwlist_len(key_list); i++) {
        keyexid = (KeyExchangeId *) gwlist_get(key_list, i);
        
        pos = pack_key_exchange_id(buffer, pos, keyexid);
    }
    
    /* now we know the size of the list */
    charpos = pack_int16(data, charpos, pos);
    
    /* append the buffer */
    charpos = pack_octstr_fixed(data, charpos, buffer);
    
    return charpos;
}

int pack_ciphersuite_list(Octstr * data, long charpos, List * ciphersuites)
{
    int i;
    CipherSuite *cs;
    
    /* vector starts with its length 
       Each element uses 2 bytes */
   octstr_set_char(data, charpos, gwlist_len(ciphersuites) * 2);
    charpos += 1;
    
    /* pack the CipherSuites */
   for (i = 0; i < gwlist_len(ciphersuites); i++) {
        cs = (CipherSuite *) gwlist_get(ciphersuites, i);
        octstr_set_char(data, charpos, cs->bulk_cipher_algo);
        charpos += 1;
        octstr_set_char(data, charpos, cs->mac_algo);
        charpos += 1;
    }
        
    return charpos;
}

int pack_compression_method_list(Octstr * data, long charpos,
             List * compmethod_list)
{
    int i;
    
    /* vector starts with its length */
    octstr_set_char(data, charpos, gwlist_len(compmethod_list));
    charpos += 1;
    
    /* pack the CompressionMethods */
   for (i = 0; i < gwlist_len(compmethod_list); i++) {
        octstr_set_char(data, charpos, 
            (CompressionMethod) gwlist_get(compmethod_list,
                            i));
        charpos += 1;
    }
        
    return charpos;
}

int pack_identifier(Octstr * data, long charpos, Identifier * ident)
{
    switch (ident->id_type) {
    case text:
        octstr_set_char(data, charpos, ident->charset);
        charpos += 1;
        charpos = pack_octstr(data, charpos, ident->name);
        break;
    case binary:
        charpos = pack_octstr(data, charpos, ident->identifier);
        break;
    case key_hash_sha:
        charpos = pack_octstr(data, charpos, ident->key_hash);
        break;
    case x509_name:
        charpos = pack_octstr(data, charpos, ident->distinguished_name);
        break;
   default:
      break;
    }
    return charpos;
}

int pack_signature(Octstr * data, long charpos, Signature * sig)
{
    switch (signature_algo) {
    case ecdsa_sha:
    case rsa_sha:
        charpos = pack_array(data, charpos, sig->sha_hash);
        break;
   default:
      break;
    }
    return charpos;
}

int pack_wtls_certificate(Octstr * data, long charpos, WTLSCertificate * cert)
{
    /* === pack ToBeSignedCertificate === */
    /* version */
   octstr_set_char(data, charpos,
         cert->tobesigned_cert->certificate_version);
    charpos += 1;
    /* sig algo */
    octstr_set_char(data, charpos, cert->tobesigned_cert->signature_algo);
    charpos += 1;
    /* identifier */
    octstr_set_char(data, charpos, cert->tobesigned_cert->issuer->id_type);
    charpos += 1;
    /* issuer Identifier */
    charpos = pack_identifier(data, charpos, cert->tobesigned_cert->issuer);
    /* validity periods */
   charpos =
       pack_int32(data, charpos, cert->tobesigned_cert->valid_not_before);
   charpos =
       pack_int32(data, charpos, cert->tobesigned_cert->valid_not_after);
    /* subject Identifier */
   charpos =
       pack_identifier(data, charpos, cert->tobesigned_cert->subject);
    /* public_key_type */
    octstr_set_char(data, charpos, cert->tobesigned_cert->pubkey_type);
    charpos += 1;
    /* parameter specifier */
   charpos =
       pack_param_spec(data, charpos, cert->tobesigned_cert->param_spec);
    /* public key */
    charpos = pack_public_key(data, charpos, cert->tobesigned_cert->pubkey,
                    cert->tobesigned_cert->pubkey_type);

    /* === pack Signature === */
    charpos = pack_signature(data, charpos, cert->signature);
    return charpos;
}

/*****************************************************************
 * UNPACK functions
 */
 
int unpack_int16(Octstr * data, long *charpos)
{
    int n;
    
    n =  octstr_get_char(data, *charpos) << 8;
    *charpos += 1;
    n += octstr_get_char(data, *charpos);
    *charpos += 1;
    return n;
}

long unpack_int32(Octstr * data, long *charpos)
{
    int n;
    
    n =  octstr_get_char(data, *charpos);
    n = n << 8;
    *charpos += 1;
    n += octstr_get_char(data, *charpos);
    n = n << 8;
    *charpos += 1;
    n += octstr_get_char(data, *charpos);
    n = n << 8;
    *charpos += 1;
    n += octstr_get_char(data, *charpos);
    *charpos += 1;
    return n;
}

Octstr *unpack_octstr(Octstr * data, long *charpos)
{
    int length;
    Octstr *opaque;
    
    length = octstr_get_char(data, *charpos);
    *charpos += 1;
    opaque = octstr_copy(data, *charpos, length);
    *charpos += length;
    return opaque;
}

Octstr *unpack_octstr16(Octstr * data, long *charpos)
{
    long length;
    Octstr *opaque;
    
    length = unpack_int16(data, charpos);
    opaque = octstr_copy(data, *charpos, length);
    *charpos += length;
    return opaque;
}

Octstr *unpack_octstr_fixed(Octstr * data, long *charpos, long length)
{
    Octstr *opaque;

    opaque = octstr_copy(data, *charpos, length);
    *charpos += length;
    return opaque;
}

Random *unpack_random(Octstr * data, long *charpos)
{
    Random *random;
    /* create the Random structure */
   random = (Random *) gw_malloc(sizeof(Random));
    
    random->gmt_unix_time = unpack_int32(data, charpos);
    random->random_bytes = unpack_octstr_fixed(data, charpos, 12);
    return random;
}
    
DHParameters *unpack_dhparams(Octstr * data, long *charpos)
{
    DHParameters *dhparams;
    
    /* create the DHParameters */
   dhparams = (DHParameters *) gw_malloc(sizeof(DHParameters));
    
    dhparams->dh_e = octstr_get_char(data, *charpos);
    *charpos += 1;
    dhparams->dh_p = unpack_octstr16(data, charpos);
    dhparams->dh_g = unpack_octstr16(data, charpos);
    return dhparams;
}

ECParameters *unpack_ecparams(Octstr * data, long *charpos)
{
    ECParameters *ecparams;
    
    /* create the ECParameters */
   ecparams = (ECParameters *) gw_malloc(sizeof(ECParameters));
    
    /* field */
    ecparams->field = octstr_get_char(data, *charpos);
    *charpos += 1;
    switch (ecparams->field) {
    case ec_prime_p:
        ecparams->prime_p = unpack_octstr(data, charpos);
        break;
    case ec_characteristic_two:
        /* m (16 bits) */
        ecparams->m = unpack_int16(data, charpos);
        /* basis */
        ecparams->basis = octstr_get_char(data, *charpos);
        *charpos += 1;
        switch (ecparams->basis) {
        case ec_basis_onb:
            break;
        case ec_basis_trinomial:
            ecparams->k = unpack_int16(data, charpos);
            break;
        case ec_basis_pentanomial:
            ecparams->k1 = unpack_int16(data, charpos);
            ecparams->k2 = unpack_int16(data, charpos);
            ecparams->k3 = unpack_int16(data, charpos);
            break;
        case ec_basis_polynomial:
            ecparams->irreducible = unpack_octstr(data, charpos);
            break;
        }
        break;
    }
    /* pack the ECCurve */
    ecparams->curve->a = unpack_octstr(data, charpos);
    ecparams->curve->b = unpack_octstr(data, charpos);
    ecparams->curve->seed = unpack_octstr(data, charpos);
    /* pack the ECPoint */
    ecparams->base->point = unpack_octstr(data, charpos);
    /* order and cofactor */
    ecparams->order = unpack_octstr(data, charpos);
    ecparams->cofactor = unpack_octstr(data, charpos);

    return ecparams;    
}

ParameterSpecifier *unpack_param_spec(Octstr * data, long *charpos)
{
    ParameterSpecifier *pspec;

    /* create the ParameterSpecifier */
   pspec = (ParameterSpecifier *) gw_malloc(sizeof(ParameterSpecifier));
    
    /* index */
    pspec->param_index = octstr_get_char(data, *charpos);
    *charpos += 1;
    /* ParameterSet struct */
   if (pspec->param_index == 255) {
      pspec->param_set =
          (ParameterSet *) gw_malloc(sizeof(ParameterSet));
        pspec->param_set->length = octstr_get_char(data, *charpos);
        *charpos += 1;
        switch (public_key_algo) {
        case diffie_hellman_pubkey:
         pspec->param_set->dhparams =
             unpack_dhparams(data, charpos);
            break;
        case elliptic_curve_pubkey:
         pspec->param_set->ecparams =
             unpack_ecparams(data, charpos);
         break;
      default:
            break;
        }
    }
    return pspec;
}

RSAPublicKey *unpack_rsa_pubkey(Octstr * data, long *charpos)
{
    RSAPublicKey *key;
    
    /* create the RSAPublicKey */
   key = (RSAPublicKey *) gw_malloc(sizeof(RSAPublicKey));
   key->rsa_exponent = unpack_octstr16(data, charpos);
   key->rsa_modulus = unpack_octstr16(data, charpos);
    return key;
}

DHPublicKey *unpack_dh_pubkey(Octstr * data, long *charpos)
{
    DHPublicKey *key;
    
    /* create the DHPublicKey */
   key = (DHPublicKey *) gw_malloc(sizeof(DHPublicKey));
   key->dh_Y = unpack_octstr16(data, charpos);
    return key;
}

ECPublicKey *unpack_ec_pubkey(Octstr * data, long *charpos)
{
    ECPublicKey *key;
    
    /* create the ECPublicKey */
   key = (ECPublicKey *) gw_malloc(sizeof(ECPublicKey));
   key->point = unpack_octstr(data, charpos);
    return key;
}

RSASecret *unpack_rsa_secret(Octstr * data, long *charpos)
{
    RSASecret *secret;
    
    /* create the RSASecret */
   secret = (RSASecret *) gw_malloc(sizeof(RSASecret));
    secret->client_version = octstr_get_char(data, *charpos);
    *charpos += 1;
    secret->random = unpack_array(data, charpos);
    
    return secret;
}

RSAEncryptedSecret *unpack_rsa_encrypted_secret(Octstr * data, long *charpos)
{
    RSAEncryptedSecret *secret;
    
    /* create the RSASecret */
   secret = (RSAEncryptedSecret *) gw_malloc(sizeof(RSAEncryptedSecret));
    //secret->encrypted_secret = unpack_octstr16(data, charpos);
   secret->encrypted_secret =
       unpack_octstr_fixed(data, charpos, octstr_len(data) - *charpos);
    return secret;
}

PublicKey *unpack_public_key(Octstr * data, long *charpos,
              PublicKeyType key_type)
{
    PublicKey *key;
    
    /* create the PublicKey */
   key = (PublicKey *) gw_malloc(sizeof(PublicKey));
    switch (key_type) {
    case ecdh_key:
        key->ecdh_pubkey = unpack_ec_pubkey(data, charpos);
        break;
    case ecdsa_key:
        key->ecdsa_pubkey = unpack_ec_pubkey(data, charpos);
        break;
    case rsa_key:
        key->rsa_pubkey = unpack_rsa_pubkey(data, charpos);
        break;
    }
    return key;
}

KeyExchangeId *unpack_key_exchange_id(Octstr * data, long *charpos)
{
    KeyExchangeId *keyexid;
    
    /* create the KeyExchangeID */
   keyexid = (KeyExchangeId *) gw_malloc(sizeof(KeyExchangeId));
    
    keyexid->key_exchange_suite = octstr_get_char(data, *charpos);
    *charpos += 1;
    keyexid->param_specif = unpack_param_spec(data, charpos);
    keyexid->identifier = unpack_identifier(data, charpos);
    return keyexid;
}

List *unpack_array(Octstr * data, long *charpos)
{
    int i;
    int array_length;
    List *array;
    
    /* create the list */
    array = gwlist_create();
    
    /* get the size of the array */
    array_length = octstr_get_char(data, *charpos);
    *charpos += 1;
    
    /* store each entry in the list */
   for (i = 0; i < array_length; i++) {
        gwlist_append(array, (void *)unpack_octstr(data, charpos));
    }
    
    return array;
}

List *unpack_key_list(Octstr * data, long *charpos)
{
    KeyExchangeId *keyexid;
    List *key_list;
    int gwlist_length;
    long endpos;
    
    /* create the list */
    key_list = gwlist_create();
    
    /* get the size of the array */
    gwlist_length = unpack_int16(data, charpos);
    endpos = *charpos + gwlist_length;
    
    /* unpack the KeyExchangeIds */
   while (*charpos < endpos) {
        keyexid = unpack_key_exchange_id(data, charpos);
        gwlist_append(key_list, (void *)keyexid);
    }
    return key_list;
}

List *unpack_ciphersuite_list(Octstr * data, long *charpos)
{
    List *ciphersuites;
    int gwlist_length;
    int i;
    CipherSuite *cs;
    
    /* create the list */
    ciphersuites = gwlist_create();
    
   /* get the size of the array (in bytes, not elements) */
    gwlist_length = octstr_get_char(data, *charpos);
    *charpos += 1;
    
    /* unpack the CipherSuites */
   for (i = 0; i < gwlist_length; i += 2) {
      cs = (CipherSuite *) gw_malloc(sizeof(CipherSuite));
        cs->bulk_cipher_algo = octstr_get_char(data, *charpos);
        *charpos += 1;
        cs->mac_algo = octstr_get_char(data, *charpos);
        *charpos += 1;
        gwlist_append(ciphersuites, (void *)cs);
    }
        
    return ciphersuites;
}

List *unpack_compression_method_list(Octstr * data, long *charpos)
{
    List *compmethod_list;
    int gwlist_length;
    int i;
    CompressionMethod *cm;
    
    /* create the list */
    compmethod_list = gwlist_create();
    
    /* get the size of the array */
    gwlist_length = octstr_get_char(data, *charpos);
    *charpos += 1;
    
    /* unpack the CompressionMethods */
   for (i = 0; i < gwlist_length; i++) {
        cm = gw_malloc(sizeof(CompressionMethod));
        *cm = octstr_get_char(data, *charpos);
        gwlist_append(compmethod_list, (void *)cm);
    }
        
    return compmethod_list;
}

Identifier *unpack_identifier(Octstr * data, long *charpos)
{
    Identifier *ident;
    
    /* create Identifier */
   ident = (Identifier *) gw_malloc(sizeof(Identifier));
    
    ident->id_type = octstr_get_char(data, *charpos);
    *charpos += 1;
    switch (ident->id_type) {
    case text:
        ident->charset = octstr_get_char(data, *charpos);
        *charpos += 1;
        ident->name = unpack_octstr(data, charpos);
        break;
    case binary:
        ident->identifier = unpack_octstr(data, charpos);
        break;
    case key_hash_sha:
        ident->key_hash = unpack_octstr(data, charpos);
        break;
    case x509_name:
        ident->distinguished_name = unpack_octstr(data, charpos);
        break;
   default:
      break;
    }
    return ident;
}

Signature *unpack_signature(Octstr * data, long *charpos)
{
    Signature *sig;
    
    /* create Signature */
   sig = (Signature *) gw_malloc(sizeof(Signature));
    
    switch (signature_algo) {
    case ecdsa_sha:
    case rsa_sha:
        sig->sha_hash = unpack_array(data, charpos);
        break;
   default:
      break;
    }
    return sig;
}

WTLSCertificate *unpack_wtls_certificate(Octstr * data, long *charpos)
{
    WTLSCertificate *cert;

    /* create the Certificate */
   cert = (WTLSCertificate *) gw_malloc(sizeof(WTLSCertificate));
    
    /* === unpack ToBeSignedCertificate === */
   cert->tobesigned_cert =
       (ToBeSignedCertificate *) gw_malloc(sizeof(ToBeSignedCertificate));
    /* version */
   cert->tobesigned_cert->certificate_version =
       octstr_get_char(data, *charpos);
    *charpos += 1;
    /* sig algo */
    cert->tobesigned_cert->signature_algo = octstr_get_char(data, *charpos);
    *charpos += 1;
    /* identifier */
   cert->tobesigned_cert->issuer->id_type =
       octstr_get_char(data, *charpos);
    *charpos += 1;
    /* issuer Identifier */
    cert->tobesigned_cert->issuer = unpack_identifier(data, charpos);
    /* validity periods */
    cert->tobesigned_cert->valid_not_before = unpack_int32(data, charpos);
    cert->tobesigned_cert->valid_not_after = unpack_int32(data, charpos);
    /* subject Identifier */
    cert->tobesigned_cert->subject = unpack_identifier(data, charpos);
    /* public_key_type */
    cert->tobesigned_cert->pubkey_type = octstr_get_char(data, *charpos);
    *charpos += 1;
    /* parameter specifier */
    cert->tobesigned_cert->param_spec = unpack_param_spec(data, charpos);
    /* public key */
    cert->tobesigned_cert->pubkey = unpack_public_key(data, charpos,
                       cert->
                       tobesigned_cert->
                       pubkey_type);

    /* === pack Signature === */
    cert->signature = unpack_signature(data, charpos);
    return cert;
}

/*****************************************************************
 * DESTROY functions
 */
 
void destroy_octstr(Octstr * data)
{
    octstr_destroy(data);
}

void destroy_octstr16(Octstr * data)
{
    octstr_destroy(data);
}

void destroy_octstr_fixed(Octstr * data)
{
    octstr_destroy(data);
}

void destroy_random(Random * random)
{
    octstr_destroy(random->random_bytes);
    gw_free(random);
}

void destroy_dhparams(DHParameters * dhparams)
{
    destroy_octstr16(dhparams->dh_p);
    destroy_octstr16(dhparams->dh_g);
    gw_free(dhparams);
}

void destroy_ecparams(ECParameters * ecparams)
{
    /* field */
    switch (ecparams->field) {
    case ec_prime_p:
        octstr_destroy(ecparams->prime_p);
        break;
    case ec_characteristic_two:
        switch (ecparams->basis) {
        case ec_basis_onb:
            break;
        case ec_basis_trinomial:
            break;
        case ec_basis_pentanomial:
            break;
        case ec_basis_polynomial:
            octstr_destroy(ecparams->irreducible);
            break;
        }
        break;
    }
    /* pack the ECCurve */
    octstr_destroy(ecparams->curve->a);
    octstr_destroy(ecparams->curve->b);
    octstr_destroy(ecparams->curve->seed);
    /* pack the ECPoint */
    octstr_destroy(ecparams->base->point);
    /* order and cofactor */
    octstr_destroy(ecparams->order);
    octstr_destroy(ecparams->cofactor);

    gw_free(ecparams);  
}

void destroy_param_spec(ParameterSpecifier * pspec)
{
    switch (public_key_algo) {
    case diffie_hellman_pubkey:
        destroy_dhparams(pspec->param_set->dhparams);
        break;
    case elliptic_curve_pubkey:
        destroy_ecparams(pspec->param_set->ecparams);
        break;
   default:
      break;
    }
    gw_free(pspec);
}

void destroy_public_key(PublicKey * key)
{
   if (key->ecdh_pubkey) {
        octstr_destroy(key->ecdh_pubkey->point);
        gw_free(key->ecdh_pubkey);
    }
   if (key->ecdsa_pubkey) {
        octstr_destroy(key->ecdsa_pubkey->point);
        gw_free(key->ecdsa_pubkey);
    }
   if (key->rsa_pubkey) {
        destroy_rsa_pubkey(key->rsa_pubkey);
    }
    gw_free(key);
}

void destroy_rsa_pubkey(RSAPublicKey * key)
{
    octstr_destroy(key->rsa_exponent);
    octstr_destroy(key->rsa_modulus);
    gw_free(key);
}

void destroy_ec_pubkey(ECPublicKey * key)
{
    octstr_destroy(key->point);
    gw_free(key);
}

void destroy_dh_pubkey(DHPublicKey * key)
{
    octstr_destroy(key->dh_Y);
    gw_free(key);
}

void destroy_rsa_secret(RSASecret * secret)
{
    destroy_array(secret->random);
    gw_free(secret);
}

void destroy_rsa_encrypted_secret(RSAEncryptedSecret * secret)
{
    octstr_destroy(secret->encrypted_secret);
    gw_free(secret);
}

void destroy_key_exchange_id(KeyExchangeId * keyexid)
{
    destroy_param_spec(keyexid->param_specif);
    destroy_identifier(keyexid->identifier);
    gw_free(keyexid);
}

void destroy_array(List * array)
{
    int i;
    
    /* pack each entry in the array */
   for (i = 0; i < gwlist_len(array); i++) {
        octstr_destroy((Octstr *) gwlist_get(array, i));
    }
    
    gwlist_destroy(array, NULL);
}

void destroy_key_list(List * key_list)
{
    int i;
    /* destroy the KeyExchangeIds */
   for (i = 0; i < gwlist_len(key_list); i++) {
      destroy_key_exchange_id((KeyExchangeId *)
               gwlist_get(key_list, i));
    }
    gwlist_destroy(key_list, NULL);
}

void destroy_ciphersuite_list(List * ciphersuites)
{
    int i;
    
    /* destroy the CipherSuites */
   for (i = 0; i < gwlist_len(ciphersuites); i++) {
      gw_free((CipherSuite *) gwlist_get(ciphersuites, i));
    }
    gwlist_destroy(ciphersuites, NULL);
}

void destroy_compression_method_list(List * compmethod_list)
{
    int i;
    CompressionMethod *cm;
    
    /* destroy the CompressionMethods */
   for (i = 0; i < gwlist_len(compmethod_list); i++) {
      cm = (CompressionMethod *) gwlist_get(compmethod_list, i);
        gw_free(cm);
    }
        
    gw_free(compmethod_list);
}

void destroy_identifier(Identifier * ident)
{
    switch (ident->id_type) {
    case text:
        octstr_destroy(ident->name);
        break;
    case binary:
        octstr_destroy(ident->identifier);
        break;
    case key_hash_sha:
        octstr_destroy(ident->key_hash);
        break;
    case x509_name:
        octstr_destroy(ident->distinguished_name);
        break;
   default:
      break;
    }
    gw_free(ident);
}

void destroy_signature(Signature * sig)
{
    switch (signature_algo) {
    case ecdsa_sha:
    case rsa_sha:
        destroy_array(sig->sha_hash);
        break;
   default:
      break;
    }
    gw_free(sig);
}

void destroy_wtls_certificate(WTLSCertificate * cert)
{
    /* === destroy ToBeSignedCertificate === */
    /* issuer Identifier */
    destroy_identifier(cert->tobesigned_cert->issuer);
    /* subject Identifier */
    destroy_identifier(cert->tobesigned_cert->subject);
    /* parameter specifier */
    destroy_param_spec(cert->tobesigned_cert->param_spec);
    /* public key */
    destroy_public_key(cert->tobesigned_cert->pubkey);

    /* === destroy Signature === */
    destroy_signature(cert->signature);
    gw_free(cert);
}

/*****************************************************************
 * DUMP functions
 */
 
void dump_void16(char *dbg, int level, int i)
{
   debug(dbg, 0, "%*s16 bit Int: %d", level, "", i);
}

void dump_int32(char *dbg, int level, long i)
{
   debug(dbg, 0, "%*s32 bit Int: %ld", level, "", i);
}

void dump_octstr(char *dbg, int level, Octstr * opaque)
{
    octstr_dump(opaque, 0);
}

void dump_octstr16(char *dbg, int level, Octstr * opaque)
{
    octstr_dump(opaque, 0);
}

void dump_octstr_fixed(char *dbg, int level, Octstr * opaque)
{
    octstr_dump(opaque, 0);
}

void dump_random(char *dbg, int level, Random * random)
{
    debug(dbg, 0, "%*sRandom :", level, "");
   debug(dbg, 0, "%*sGMT Unix Time: %ld", level + 1, "",
         random->gmt_unix_time);
   debug(dbg, 0, "%*sRandom Bytes:", level + 1, "");
   dump_octstr_fixed(dbg, level + 2, random->random_bytes);
}

void dump_dhparams(char *dbg, int level, DHParameters * dhparams)
{
    debug(dbg, 0, "%*sDH Parameters :", level, "");
   debug(dbg, 0, "%*sdh_e: %d", level + 1, "", dhparams->dh_e);
   debug(dbg, 0, "%*sdh_p:", level + 1, "");
   dump_octstr16(dbg, level + 2, dhparams->dh_p);
   debug(dbg, 0, "%*sdh_g:", level + 1, "");
   dump_octstr16(dbg, level + 2, dhparams->dh_g);
}

void dump_ecparams(char *dbg, int level, ECParameters * ecparams)
{
    debug(dbg, 0, "%*sEC Parameters :", level, "");
    /* field */
   debug(dbg, 0, "%*sField: %d", level + 1, "", ecparams->field);
    switch (ecparams->field) {
    case ec_prime_p:
      debug(dbg, 0, "%*sprime_p :", level + 1, "");
      dump_octstr(dbg, level + 1, ecparams->prime_p);
        break;
    case ec_characteristic_two:
        /* m (16 bits) */
      debug(dbg, 0, "%*sM: %d", level + 1, "", ecparams->m);
        /* basis */
      debug(dbg, 0, "%*sBasis: %d", level + 1, "", ecparams->basis);
        switch (ecparams->basis) {
        case ec_basis_onb:
            break;
        case ec_basis_trinomial:
         debug(dbg, 0, "%*sK: %d", level + 1, "", ecparams->k);
            break;
        case ec_basis_pentanomial:
         debug(dbg, 0, "%*sk1: %d", level + 1, "", ecparams->k1);
         debug(dbg, 0, "%*sk2: %d", level + 1, "", ecparams->k2);
         debug(dbg, 0, "%*sk3: %d", level + 1, "", ecparams->k3);
            break;
        case ec_basis_polynomial:
         debug(dbg, 0, "%*sirreducible: 0x%p", level + 1, "",
               ecparams->irreducible);
         dump_octstr(dbg, level + 1, ecparams->irreducible);
            break;
        }
        break;
    }
    /* pack the ECCurve */
   debug(dbg, 0, "%*sEC Curve: 0x%p", level + 1, "", ecparams->curve);
   debug(dbg, 0, "%*sa: 0x%p", level + 2, "", ecparams->curve->a);
   dump_octstr(dbg, level + 2, ecparams->curve->a);
   debug(dbg, 0, "%*sb: 0x%p", level + 2, "", ecparams->curve->b);
   dump_octstr(dbg, level + 2, ecparams->curve->b);
   debug(dbg, 0, "%*sseed: 0x%p", level + 2, "", ecparams->curve->seed);
   dump_octstr(dbg, level + 2, ecparams->curve->seed);
    /* pack the ECPoint */
   debug(dbg, 0, "%*spoint: 0x%p", level + 2, "", ecparams->base->point);
   dump_octstr(dbg, level + 2, ecparams->base->point);
    /* order and cofactor */
   debug(dbg, 0, "%*sorder: 0x%p", level + 2, "", ecparams->order);
   dump_octstr(dbg, level + 2, ecparams->order);
   debug(dbg, 0, "%*scofactor: 0x%p", level + 2, "", ecparams->cofactor);
   dump_octstr(dbg, level + 2, ecparams->cofactor);
}

void dump_param_spec(char *dbg, int level, ParameterSpecifier * pspec)
{
    debug(dbg, 0, "%*sParameterSpecifier:", level, "");
    /* index */
   debug(dbg, 0, "%*sParameter Index: %d", level + 1, "",
         pspec->param_index);
    /* ParameterSet struct */
   if (pspec->param_index == 255) {
      debug(dbg, 0, "%*sLength: %ld", level + 1, "",
            pspec->param_set->length);
        switch (public_key_algo) {
        case diffie_hellman_pubkey:
         dump_dhparams(dbg, level + 1,
                  pspec->param_set->dhparams);
            break;
        case elliptic_curve_pubkey:
         dump_ecparams(dbg, level + 1,
                  pspec->param_set->ecparams);
         break;
      default:
            break;
        }
    }
}

void dump_public_key(char *dbg, int level, PublicKey * key, PublicKeyType
           key_type)
{
    switch (key_type) {
    case ecdh_key:
      debug(dbg, 0, "%*sPublicKey: 0x%p", level, "",
            key->ecdh_pubkey);
      debug(dbg, 0, "%*sECDH Point: 0x%p", level + 1, "",
            key->ecdh_pubkey->point);
      dump_octstr(dbg, level + 1, key->ecdh_pubkey->point);
        break;
    case ecdsa_key:
      debug(dbg, 0, "%*sECDSA Point: 0x%p", level + 1, "",
            key->ecdsa_pubkey->point);
      dump_octstr(dbg, level + 1, key->ecdsa_pubkey->point);
        break;
    case rsa_key:
      dump_rsa_pubkey(dbg, level + 1, key->rsa_pubkey);
        break;
    }
}

void dump_rsa_pubkey(char *dbg, int level, RSAPublicKey * key)
{
   debug(dbg, 0, "%*sRSA Public Key: 0x%p", level, "", key);
   debug(dbg, 0, "%*sRSA Exponent: 0x%p", level + 1, "",
         key->rsa_exponent);
   dump_octstr(dbg, level + 2, key->rsa_exponent);
   debug(dbg, 0, "%*sRSA Modulus: 0x%p", level + 1, "", key->rsa_modulus);
   dump_octstr(dbg, level + 2, key->rsa_modulus);
}

void dump_ec_pubkey(char *dbg, int level, ECPublicKey * key)
{
   debug(dbg, 0, "%*sEC Public Key: 0x%p", level, "", key);
   debug(dbg, 0, "%*sPoint: 0x%p", level + 1, "", key->point);
   dump_octstr(dbg, level + 2, key->point);
}

void dump_dh_pubkey(char *dbg, int level, DHPublicKey * key)
{
   debug(dbg, 0, "%*sDH Public Key: 0x%p", level, "", key->dh_Y);
   dump_octstr(dbg, level + 2, key->dh_Y);
}

void dump_rsa_secret(char *dbg, int level, RSASecret * secret)
{
   debug(dbg, 0, "%*sRSA Secret: 0x%p", level, "", secret);
   debug(dbg, 0, "%*sClient Version: %d", level + 1, "",
         secret->client_version);
   debug(dbg, 0, "%*sRandom: 0x%p", level, "", secret->random);
   dump_array(dbg, level + 2, secret->random);
}

void dump_rsa_encrypted_secret(char *dbg, int level, RSAEncryptedSecret
                * secret)
{
   debug(dbg, 0, "%*sRSA Encrypted Secret: %p", level, "",
         secret->encrypted_secret);
   dump_octstr(dbg, level + 1, secret->encrypted_secret);
}

void dump_key_exchange_id(char *dbg, int level, KeyExchangeId * keyexid)
{
   debug(dbg, 0, "%*sKey Exchange Id: 0x%p", level, "", keyexid);
   debug(dbg, 0, "%*sKey Exch Suite: %d", level + 1, "",
         keyexid->key_exchange_suite);
   dump_param_spec(dbg, level + 1, keyexid->param_specif);
   dump_identifier(dbg, level + 1, keyexid->identifier);
}

void dump_array(char *dbg, int level, List * array)
{
    int i;

   /*debug(dbg, 0, "%*sOctstr Array: %p", level, ""); */
    
    /* dump each entry in the array */
   for (i = 0; i < gwlist_len(array); i++) {
        debug(dbg, 0, "%*sElement %d", level, "", i);
      dump_octstr(dbg, level + 1, (Octstr *) gwlist_get(array, i));
    }
}

void dump_key_list(char *dbg, int level, List * key_list)
{
    int i;
    KeyExchangeId *keyexid;

   debug(dbg, 0, "%*sKey List: 0x%p", level, "", key_list);
    
    /* pack the KeyExchangeIds */
   for (i = 0; i < gwlist_len(key_list); i++) {
        keyexid = (KeyExchangeId *) gwlist_get(key_list, i);
      dump_key_exchange_id(dbg, level + 1, keyexid);
    }
}

void dump_ciphersuite_list(char *dbg, int level, List * ciphersuites)
{
    int i;
    CipherSuite *cs;

   debug(dbg, 0, "%*sCipherSuite List: 0x%p", level, "", ciphersuites);
    
    /* dump the CipherSuites */
   for (i = 0; i < gwlist_len(ciphersuites); i++) {
        cs = (CipherSuite *) gwlist_get(ciphersuites, i);
      debug(dbg, 0, "%*sBulk Cipher Algo: %d", level, "",
            cs->bulk_cipher_algo);
      debug(dbg, 0, "%*sMAC Algo: %d", level, "", cs->mac_algo);
    }
}

void dump_compression_method_list(char *dbg, int level, List * compmethod_list)
{
    int i;
    
   debug(dbg, 0, "%*sCompression Method List: 0x%p", level, "",
         compmethod_list);
    /* pack the CompressionMethods */
   for (i = 0; i < gwlist_len(compmethod_list); i++) {
      debug(dbg, 0, "%*sMethod %d: %d", level, "", i,
                (CompressionMethod) gwlist_get(compmethod_list, i));
    }
}

void dump_identifier(char *dbg, int level, Identifier * ident)
{
   debug(dbg, 0, "%*sIdentifier: 0x%p", level, "", ident);
   debug(dbg, 0, "%*sIdent type: %d", level + 1, "", ident->id_type);
    switch (ident->id_type) {
    case text:
      debug(dbg, 0, "%*sCharset: %d", level + 1, "", ident->charset);
      debug(dbg, 0, "%*sNamet: %s", level + 1, "",
            octstr_get_cstr(ident->name));
        break;
    case binary:
      debug(dbg, 0, "%*sIdentifier: 0x%p", level + 1, "",
            ident->identifier);
      dump_octstr(dbg, level + 2, ident->identifier);
        break;
    case key_hash_sha:
      debug(dbg, 0, "%*sKey Hash: 0x%p", level + 1, "",
            ident->key_hash);
      dump_octstr(dbg, level + 2, ident->key_hash);
        break;
    case x509_name:
      debug(dbg, 0, "%*sDistinguished Name: 0x%p", level + 1, "",
            ident->distinguished_name);
      dump_octstr(dbg, level + 2, ident->distinguished_name);
      break;
   default:
        break;
    }
}

void dump_signature(char *dbg, int level, Signature * sig)
{
   debug(dbg, 0, "%*sSignature: 0x%p", level, "", sig);
    switch (signature_algo) {
    case ecdsa_sha:
    case rsa_sha:
      dump_array(dbg, level + 1, sig->sha_hash);
      break;

   default:
        break;
    }
}

void dump_wtls_certificate(char *dbg, int level, WTLSCertificate * cert)
{
   debug(dbg, 0, "%*sWTLS Certificate: 0x%p", level, "", cert);
    /* === pack ToBeSignedCertificate === */
    /* version */
   debug(dbg, 0, "%*sCertificate Version: %d", level + 1, "",
         cert->tobesigned_cert->certificate_version);
    /* sig algo */
   debug(dbg, 0, "%*sSignature Algo: %d", level + 1, "",
         cert->tobesigned_cert->signature_algo);
    /* identifier */
   debug(dbg, 0, "%*sID Type: %d", level + 1, "",
         cert->tobesigned_cert->issuer->id_type);
    /* issuer Identifier */
   dump_identifier(dbg, level + 1, cert->tobesigned_cert->issuer);
    /* validity periods */
   debug(dbg, 0, "%*sValid not Before: %ld", level + 1, "",
         cert->tobesigned_cert->valid_not_before);
   debug(dbg, 0, "%*sValid not After: %ld", level + 1, "",
         cert->tobesigned_cert->valid_not_after);
    /* subject Identifier */
   dump_identifier(dbg, level + 1, cert->tobesigned_cert->subject);
    /* public_key_type */
   debug(dbg, 0, "%*sPublic Key Type: %d", level + 1, "",
         cert->tobesigned_cert->pubkey_type);
    /* parameter specifier */
   dump_param_spec(dbg, level + 1, cert->tobesigned_cert->param_spec);
    /* public key */
   dump_public_key(dbg, level + 1, cert->tobesigned_cert->pubkey,
                    cert->tobesigned_cert->pubkey_type);

    /* === pack Signature === */
   dump_signature(dbg, level + 1, cert->signature);
}
#endif /* HAVE_WTLS_OPENSSL */