/// Create a new private key - or return the existing private key with this id
WINEXPORT CryptFramePrivateKey*
cryptframe_privatekey_new(const char *key_id, ///<[in] Key id of given private key
gpointer private_key) ///<[in] MALLOCed private key
{
AssimObj* aself;
CryptFramePrivateKey* self;
INITMAPS;
g_return_val_if_fail(key_id != NULL && private_key != NULL, NULL);
self = cryptframe_private_key_by_id(key_id);
if (self) {
g_warning("%s.%d: Private key %s Already IN private key map", __FUNCTION__, __LINE__, key_id);
return self;
}
aself = assimobj_new(sizeof(CryptFramePrivateKey));
aself->_finalize = _cryptframe_privatekey_finalize;
self = NEWSUBCLASS(CryptFramePrivateKey, aself);
self->key_id = g_strdup(key_id);
self->key_size = crypto_box_SECRETKEYBYTES;
self->private_key = private_key;
g_hash_table_insert(private_key_map, self->key_id, self);
DEBUGCKSUM3(self->key_id, private_key);
return self;
}
/// Create a new public key - or return the existing public key with this id
WINEXPORT CryptFramePublicKey*
cryptframe_publickey_new (const char *key_id, ///< Key id of the given public key
gpointer public_key) ///< MALLOCed public key
{
AssimObj* aself;
CryptFramePublicKey* self;
INITMAPS;
g_return_val_if_fail(key_id != NULL && public_key != NULL, NULL);
self = cryptframe_public_key_by_id(key_id);
if (self) {
return self;
}
aself = assimobj_new(sizeof(CryptFramePublicKey));
aself->_finalize = _cryptframe_publickey_finalize;
self = NEWSUBCLASS(CryptFramePublicKey, aself);
self->key_id = g_strdup(key_id);
self->key_size = crypto_box_PUBLICKEYBYTES;
self->frame_type = FRAMETYPE_PUBKEYCURVE25519;
self->public_key = public_key;
g_hash_table_insert(public_key_map, self->key_id, self);
DEBUGCKSUM3(self->key_id, public_key);
return self;
}
/// Construct a new CryptCurve25519 object (frame).
CryptCurve25519*
cryptcurve25519_new(guint16 frame_type, ///<[in] TLV type of CryptCurve25519
const char * sender_key_id, ///<[in] name of sender's key
const char * receiver_key_id, ///<[in] name of receiver's key
gboolean forsending, ///<[in] TRUE if this is for sending
gsize objsize) ///<[in] sizeof(this object) - or zero for default
{
CryptFrame* baseframe;
CryptCurve25519* ret;
BINDDEBUG(CryptCurve25519);
if (objsize < sizeof(CryptCurve25519)) {
objsize = sizeof(CryptCurve25519);
}
if (NULL == sender_key_id) {
sender_key_id = cryptframe_get_signing_key_id();
}
DEBUGMSG2("%s.%d:(%s, %s, %d)", __FUNCTION__, __LINE__, sender_key_id, receiver_key_id
, (int)objsize);
g_return_val_if_fail(sender_key_id != NULL && receiver_key_id != NULL, NULL);
if (!_is_valid_curve25519_key_id(receiver_key_id, PUBLICKEY)) {
g_critical("%s.%d: public key name [%s] is invalid", __FUNCTION__, __LINE__, receiver_key_id);
return NULL;
}
if (!_is_valid_curve25519_key_id(sender_key_id, PUBLICKEY)) {
g_critical("%s.%d: public key name [%s] is invalid", __FUNCTION__, __LINE__, sender_key_id);
return NULL;
}
baseframe = cryptframe_new(frame_type, sender_key_id, receiver_key_id, objsize);
if (!_parentclass_finalize) {
_parentclass_finalize = baseframe->baseclass.baseclass._finalize;
}
baseframe->baseclass.isvalid = _cryptcurve25519_default_isvalid;
baseframe->baseclass.updatedata = _cryptcurve25519_updatedata;
baseframe->baseclass.length = TLVLEN(receiver_key_id, sender_key_id);
baseframe->baseclass.baseclass._finalize = _cryptcurve25519_finalize;
ret = NEWSUBCLASS(CryptCurve25519, baseframe);
ret->forsending = forsending;
ret->private_key = cryptframe_private_key_by_id(forsending ? sender_key_id : receiver_key_id);
ret->public_key = cryptframe_public_key_by_id(forsending ? receiver_key_id : sender_key_id);
if (ret->private_key && ret->public_key) {
DEBUGCKSUM3("private_key:", ret->private_key->private_key, crypto_box_SECRETKEYBYTES);
DEBUGCKSUM3("public_key:", ret->public_key->public_key, crypto_box_PUBLICKEYBYTES);
DUMP3(__FUNCTION__, &ret->baseclass.baseclass.baseclass, " is return value");
REF(ret->private_key);
REF(ret->public_key);
}else{
if (!ret->private_key) {
g_warning("%s.%d: Sender private key is NULL for key id %s", __FUNCTION__, __LINE__
, sender_key_id);
abort();
}
if (!ret->public_key) {
g_warning("%s.%d: Receiver public key is NULL for key id %s", __FUNCTION__, __LINE__
, receiver_key_id);
}
UNREF3(ret);
return NULL;
}
return ret;
}
