wtls_pdusupport.c

The Kannel Open Source WAP and SMS gateway works as both an SMS gateway, for implementing keyword b

/* ==================================================================== 
 * The Kannel Software License, Version 1.0 
 * 
 * Copyright (c) 2001-2004 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 [e-mail]. 
 * 
 * 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
 * 
 */

#include "gwlib/gwlib.h"

#if (HAVE_WTLS_OPENSSL)

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

// Change this later !!!!
extern PublicKeyAlgorithm public_key_algo;
extern SignatureAlgorithm signature_algo;

/*****************************************************************
 * 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;
	}
	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<list_len(array); i++)
	{
		pos = pack_octstr(buffer, pos, (Octstr *) list_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<list_len(key_list); i++) {
		keyexid = (KeyExchangeId *) list_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, list_len(ciphersuites)*2);
	charpos += 1;
	
	/* pack the CipherSuites */
	for (i=0; i<list_len(ciphersuites); i++) {
		cs = (CipherSuite *) list_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, list_len(compmethod_list));
	charpos += 1;
	
	/* pack the CompressionMethods */
	for (i=0; i<list_len(compmethod_list); i++) {
		octstr_set_char(data, charpos, 
				(CompressionMethod) list_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;
	}
	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;
	}
	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);