/// 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;
}
/// Routine to pretend to be the initial CMA
void
fakecma_startup(AuthListener* auth, FrameSet* ifs, NetAddr* nanoaddr)
{
FrameSet* pkt;
NetGSource* netpkt = auth->baseclass.transport;
char * nanostr = nanoaddr->baseclass.toString(nanoaddr);
GSList* thisgsf;
const char * keyid = NULL;
(void)ifs;
g_message("CMA received startup message from nanoprobe at address %s/%d."
, nanostr, nanoaddr->port(nanoaddr));
g_free(nanostr); nanostr = NULL;
check_JSON(ifs);
netpkt->_netio->addalias(netpkt->_netio, nanoaddr, destaddr);
// Set up our crypto...
cryptframe_set_dest_key_id(nanoaddr, cryptframe_get_signing_key_id());
cryptframe_set_dest_key_id(destaddr, cryptframe_get_signing_key_id());
cryptframe_associate_identity(CMA_IDENTITY_NAME, cryptframe_get_signing_key_id());
cryptframe_set_encryption_method(cryptcurve25519_new_generic);
for (thisgsf = ifs->framelist; thisgsf; thisgsf=thisgsf->next) {
Frame* thisframe = CASTTOCLASS(Frame, thisgsf->data);
if (thisframe->type == FRAMETYPE_KEYID) {
CstringFrame* csf = CASTTOCLASS(CstringFrame, thisframe);
keyid = (const char *)csf->baseclass.value;
}else if (keyid && thisframe->type == FRAMETYPE_PUBKEYCURVE25519) {
cryptcurve25519_save_public_key(keyid, thisframe->value
, thisframe->length);
}
}
// Send the configuration data to our new "client"
pkt = create_setconfig(nanoconfig);
netpkt->_netio->sendareliablefs(netpkt->_netio, nanoaddr, DEFAULT_FSP_QID, pkt);
UNREF(pkt);
// Now tell them to send/expect heartbeats to various places
pkt = create_sendexpecthb(auth->baseclass.config, FRAMESETTYPE_SENDEXPECTHB, destaddr, 1);
netpkt->_netio->sendareliablefs(netpkt->_netio, nanoaddr, DEFAULT_FSP_QID, pkt);
UNREF(pkt);
{
const char * monopjson[] = { START, MONITOR, STOP};
unsigned j;
// Create a frameset for a few resource operations
pkt = frameset_new(FRAMESETTYPE_DORSCOP);
for (j=0; j < DIMOF(monopjson); j++) {
CstringFrame* csf = cstringframe_new(FRAMETYPE_RSCJSON,0);
csf->baseclass.setvalue(&csf->baseclass, g_strdup(monopjson[j])
, strlen(monopjson[j])+1, g_free);
frameset_append_frame(pkt, &csf->baseclass);
UNREF2(csf);
}
netpkt->_netio->sendareliablefs(netpkt->_netio, nanoaddr, DEFAULT_FSP_QID, pkt);
UNREF(pkt);
}
{
const char * discoverjson[] = {SWITCHDISCOVER, ARPDISCOVER};
const char * discoverinstnm[] = {SWINSTNM, ARPINSTNM};
unsigned j;
// Create a frameset for a few discovery operations
pkt = frameset_new(FRAMESETTYPE_DODISCOVER);
for (j=0; j < DIMOF(discoverjson); j++) {
CstringFrame* csf = cstringframe_new(FRAMETYPE_DISCJSON,0);
CstringFrame* inst = cstringframe_new(FRAMETYPE_DISCNAME,0);
fprintf(stderr, "Creating discovery frameset: %s: %s\n"
, discoverinstnm[j]
, discoverjson[j]);
inst->baseclass.setvalue(&inst->baseclass, g_strdup(discoverjson[j])
, strlen(discoverjson[j])+1, g_free);
frameset_append_frame(pkt, &inst->baseclass);
UNREF2(inst);
csf->baseclass.setvalue(&csf->baseclass, g_strdup(discoverjson[j])
, strlen(discoverjson[j])+1, g_free);
frameset_append_frame(pkt, &csf->baseclass);
UNREF2(csf);
}
netpkt->_netio->sendareliablefs(netpkt->_netio, nanoaddr, DEFAULT_FSP_QID, pkt);
UNREF(pkt);
}
pkt = frameset_new(FRAMESETTYPE_ACKSTARTUP);
netpkt->_netio->sendareliablefs(netpkt->_netio, nanoaddr, DEFAULT_FSP_QID, pkt);
UNREF(pkt);
g_info("ACKSTARTUP packet queued to send");
}
