void setup_test_rsa_keyptrs()
{
/*
* set up key pointers
*/
assert(pub_keyring.nkeys);
alpha_pub_keydata=ops_keyring_find_key_by_userid(&pub_keyring,
alpha_user_id);
bravo_pub_keydata=ops_keyring_find_key_by_userid(&pub_keyring,
bravo_user_id);
assert(alpha_pub_keydata);
assert(bravo_pub_keydata);
alpha_sec_keydata=ops_keyring_find_key_by_userid(&sec_keyring,
alpha_user_id);
bravo_sec_keydata=ops_keyring_find_key_by_userid(&sec_keyring,
bravo_user_id);
assert(alpha_sec_keydata);
assert(bravo_sec_keydata);
alpha_pkey=ops_get_public_key_from_data(alpha_pub_keydata);
alpha_skey=ops_get_secret_key_from_data(alpha_sec_keydata);
bravo_pkey=ops_get_public_key_from_data(bravo_pub_keydata);
bravo_skey=ops_decrypt_secret_key_from_data(bravo_sec_keydata,
bravo_passphrase);
assert(alpha_pkey);
assert(alpha_skey);
assert(bravo_pkey);
assert(bravo_skey); //not yet set because of passphrase
}
void setup_test_dsa_keyptrs()
{
/*
* set up key pointers
*/
assert(pub_keyring.nkeys);
alphadsa_pub_keydata=ops_keyring_find_key_by_userid(&pub_keyring,
alphadsa_user_id);
bravodsa_pub_keydata=ops_keyring_find_key_by_userid(&pub_keyring,
bravodsa_user_id);
printf("%s\n", alphadsa_user_id);
assert(alphadsa_pub_keydata);
assert(bravodsa_pub_keydata);
alphadsa_sec_keydata=ops_keyring_find_key_by_userid(&sec_keyring,
alphadsa_user_id);
bravodsa_sec_keydata=ops_keyring_find_key_by_userid(&sec_keyring,
bravodsa_user_id);
assert(alphadsa_sec_keydata);
assert(bravodsa_sec_keydata);
alphadsa_pkey=ops_get_public_key_from_data(alphadsa_pub_keydata);
alphadsa_skey=ops_get_secret_key_from_data(alphadsa_sec_keydata);
bravodsa_pkey=ops_get_public_key_from_data(bravodsa_pub_keydata);
bravodsa_skey=ops_decrypt_secret_key_from_data(bravodsa_sec_keydata,
bravodsa_passphrase);
assert(alphadsa_pkey);
assert(alphadsa_skey);
assert(bravodsa_pkey);
assert(bravodsa_skey);
}
/**
\ingroup Core_Create
\brief Creates an ops_pk_session_key_t struct from keydata
\param key Keydata to use
\return ops_pk_session_key_t struct
\note It is the caller's responsiblity to free the returned pointer. Before freeing,
the key must be cleared by calling ops_pk_session_key_free()
\note Currently hard-coded to use CAST5
\note Currently hard-coded to use RSA
*/
ops_pk_session_key_t *ops_create_pk_session_key(const ops_keydata_t *key)
{
/*
* Creates a random session key and encrypts it for the given key
*
* Session Key is for use with a SK algo,
* can be any, we're hardcoding CAST5 for now
*
* Encryption used is PK,
* can be any, we're hardcoding RSA for now
*/
const ops_public_key_t* pub_key=ops_get_public_key_from_data(key);
#define SZ_UNENCODED_M_BUF CAST_KEY_LENGTH+1+2
unsigned char unencoded_m_buf[SZ_UNENCODED_M_BUF];
const size_t sz_encoded_m_buf=BN_num_bytes(pub_key->key.rsa.n);
unsigned char* encoded_m_buf = ops_mallocz(sz_encoded_m_buf);
ops_pk_session_key_t *session_key=ops_mallocz(sizeof *session_key);
assert(key->type == OPS_PTAG_CT_PUBLIC_KEY);
session_key->version=OPS_PKSK_V3;
memcpy(session_key->key_id, key->key_id, sizeof session_key->key_id);
if (debug)
{
unsigned int i=0;
fprintf(stderr,"Encrypting for RSA key id : ");
for (i=0; i<sizeof session_key->key_id; i++)
fprintf(stderr,"%2x ", key->key_id[i]);
fprintf(stderr,"\n");
}
assert(key->key.pkey.algorithm == OPS_PKA_RSA);
session_key->algorithm=key->key.pkey.algorithm;
// \todo allow user to specify other algorithm
session_key->symmetric_algorithm=OPS_SA_CAST5;
ops_random(session_key->key, CAST_KEY_LENGTH);
if (debug)
{
unsigned int i=0;
fprintf(stderr,"CAST5 session key created (len=%d):\n ",
CAST_KEY_LENGTH);
for (i=0; i<CAST_KEY_LENGTH; i++)
fprintf(stderr,"%2x ", session_key->key[i]);
fprintf(stderr,"\n");
}
if (create_unencoded_m_buf(session_key, &unencoded_m_buf[0])==ops_false)
{
free(encoded_m_buf);
return NULL;
}
if (debug)
{
unsigned int i=0;
printf("unencoded m buf:\n");
for (i=0; i<SZ_UNENCODED_M_BUF; i++)
printf("%2x ", unencoded_m_buf[i]);
printf("\n");
}
encode_m_buf(&unencoded_m_buf[0], SZ_UNENCODED_M_BUF, pub_key,
&encoded_m_buf[0]);
// and encrypt it
if(!ops_rsa_encrypt_mpi(encoded_m_buf, sz_encoded_m_buf, pub_key,
&session_key->parameters))
{
free (encoded_m_buf);
return NULL;
}
free(encoded_m_buf);
return session_key;
}
