wtls_pdusupport.c

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

}

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;
	}
	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<list_len(array); i++)
	{
		octstr_destroy((Octstr *) list_get(array, i));
	}
	
	list_destroy(array, NULL);
}

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

void destroy_ciphersuite_list(List *ciphersuites) {
	int i;
	CipherSuite *cs;
	
	/* destroy the CipherSuites */
	for (i=0; i<list_len(ciphersuites); i++) {
		gw_free( (CipherSuite *) list_get(ciphersuites, i) );
	}
		
	list_destroy(ciphersuites, NULL);
}

void destroy_compression_method_list(List *compmethod_list) {
	int i;
	CompressionMethod *cm;
	
	/* destroy the CompressionMethods */
	for (i=0; i<list_len(compmethod_list); i++) {
		cm = (CompressionMethod*) list_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;
	}
	gw_free(ident);
}

void destroy_signature(Signature *sig) {
	switch (signature_algo) {
	case ecdsa_sha:
	case rsa_sha:
		destroy_array(sig->sha_hash);
		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(unsigned char *dbg, int level, int i) {
	debug(dbg, 0, "%*s16 bit Int: %p", level, "", i);
}

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

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

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

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

void dump_random(unsigned char *dbg, int level, Random *random) {
	debug(dbg, 0, "%*sRandom :", level, "");
	debug(dbg, 0, "%*sGMT Unix Time: %p", 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(unsigned char *dbg, int level, DHParameters *dhparams) {
	debug(dbg, 0, "%*sDH Parameters :", level, "");
	debug(dbg, 0, "%*sdh_e: %p", 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(unsigned char *dbg, int level, ECParameters *ecparams) {
	debug(dbg, 0, "%*sEC Parameters :", level, "");
	/* field */
	debug(dbg, 0, "%*sField: %p", 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: %p", level+1, "", ecparams->m);
		/* basis */
		debug(dbg, 0, "%*sBasis: %p", level+1, "", ecparams->basis);
		switch (ecparams->basis) {
		case ec_basis_onb:
			break;
		case ec_basis_trinomial:
			debug(dbg, 0, "%*sK: %p", level+1, "", ecparams->k);
			break;
		case ec_basis_pentanomial:
			debug(dbg, 0, "%*sk1: %p", level+1, "", ecparams->k1);
			debug(dbg, 0, "%*sk2: %p", level+1, "", ecparams->k2);
			debug(dbg, 0, "%*sk3: %p", level+1, "", ecparams->k3);
			break;
		case ec_basis_polynomial:
			debug(dbg, 0, "%*sirreducible: %p", level+1, "");
			dump_octstr(dbg, level+1, ecparams->irreducible);
			break;
		}
		break;
	}
	/* pack the ECCurve */
	debug(dbg, 0, "%*sEC Curve: %p", level+1, "");
	debug(dbg, 0, "%*sa: %p", level+2, "");
	dump_octstr(dbg, level+2, ecparams->curve->a);
	debug(dbg, 0, "%*sb: %p", level+2, "");
	dump_octstr(dbg, level+2, ecparams->curve->b);
	debug(dbg, 0, "%*sseed: %p", level+2, "");
	dump_octstr(dbg, level+2, ecparams->curve->seed);
	/* pack the ECPoint */
	debug(dbg, 0, "%*spoint: %p", level+2, "");
	dump_octstr(dbg, level+2, ecparams->base->point);
	/* order and cofactor */
	debug(dbg, 0, "%*sorder: %p", level+2, "");
	dump_octstr(dbg, level+2, ecparams->order);
	debug(dbg, 0, "%*scofactor: %p", level+2, "");
	dump_octstr(dbg, level+2, ecparams->cofactor);
}

void dump_param_spec(unsigned 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: %p", 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;
		}
	}
}

void dump_public_key(unsigned char *dbg, int level, PublicKey *key, PublicKeyType key_type) {
	switch (key_type) {
	case ecdh_key:
		debug(dbg, 0, "%*sPublicKey: %p", level, "");
		debug(dbg, 0, "%*sECDH Point: %p", level+1, "");
		dump_octstr(dbg, level+1, key->ecdh_pubkey->point);
		break;
	case ecdsa_key:
		debug(dbg, 0, "%*sECDSA Point: %p", level+1, "");
		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(unsigned char *dbg, int level, RSAPublicKey *key) {
	debug(dbg, 0, "%*sRSA Public Key: %p", level, "");
	debug(dbg, 0, "%*sRSA Exponent: %p", level+1, "");
	dump_octstr(dbg, level+2, key->rsa_exponent);
	debug(dbg, 0, "%*sRSA Modulus: %p", level+1, "");
	dump_octstr(dbg, level+2, key->rsa_modulus);
}

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

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

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

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

void dump_key_exchange_id(unsigned char *dbg, int level, KeyExchangeId *keyexid) {
	debug(dbg, 0, "%*sKey Exchange Id:", level, "");
	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(unsigned 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<list_len(array); i++)
	{
		debug(dbg, 0, "%*sElement %d", level, "", i);
		dump_octstr(dbg, level+1, (Octstr *) list_get(array, i));
	}
}

void dump_key_list(unsigned char *dbg, int level, List *key_list) {
	int i;
	long pos = 0;
	Octstr *buffer;
	KeyExchangeId *keyexid;

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

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

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

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

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

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

void dump_wtls_certificate(unsigned char *dbg, int level, WTLSCertificate *cert) {
	debug(dbg, 0, "%*sWTLS Certificate: %p", level, "");
	/* === pack ToBeSignedCertificate === */
	/* version */
	debug(dbg, 0, "%*sCertificate Version: %p", level+1, "", cert->tobesigned_cert->certificate_version);
	/* sig algo */
	debug(dbg, 0, "%*sSignature Algo: %p", level+1, "", cert->tobesigned_cert->signature_algo);
	/* identifier */
	debug(dbg, 0, "%*sID Type: %p", 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: %p", level+1, "", cert->tobesigned_cert->valid_not_before);
	debug(dbg, 0, "%*sValid not After: %p", 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: %p", 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