int cp_ecss_sig(bn_t e, bn_t s, uint8_t *msg, int len, bn_t d) {
bn_t n, k, x, r;
ec_t p;
uint8_t hash[MD_LEN];
uint8_t m[len + FC_BYTES];
int result = STS_OK;
bn_null(n);
bn_null(k);
bn_null(x);
bn_null(r);
ec_null(p);
TRY {
bn_new(n);
bn_new(k);
bn_new(x);
bn_new(r);
ec_new(p);
ec_curve_get_ord(n);
do {
bn_rand_mod(k, n);
ec_mul_gen(p, k);
ec_get_x(x, p);
bn_mod(r, x, n);
} while (bn_is_zero(r));
memcpy(m, msg, len);
bn_write_bin(m + len, FC_BYTES, r);
md_map(hash, m, len + FC_BYTES);
if (8 * MD_LEN > bn_bits(n)) {
len = CEIL(bn_bits(n), 8);
bn_read_bin(e, hash, len);
bn_rsh(e, e, 8 * MD_LEN - bn_bits(n));
} else {
bn_read_bin(e, hash, MD_LEN);
}
bn_mod(e, e, n);
bn_mul(s, d, e);
bn_mod(s, s, n);
bn_sub(s, n, s);
bn_add(s, s, k);
bn_mod(s, s, n);
}
CATCH_ANY {
result = STS_ERR;
}
FINALLY {
bn_free(n);
bn_free(k);
bn_free(x);
bn_free(r);
ec_free(p);
}
return result;
}
void DynamicConfigurationServer::generateCredentialsAndSendResponse(const std::array<uint8_t, 16>& nonce) {
LOG(INFO) << "generate ID";
// statically use node ID 5
std::array<uint8_t, 16> nodeID = networkInterface_->getUsedAddress().to_bytes();
nodeID[14] = 0x0;
nodeID[15] = 0x5;
boost::asio::ip::address_v6 nodeAddress = boost::asio::ip::address_v6(nodeID);
LOG(INFO) << "extract identity key for ID: " << nodeAddress.to_string();
LOG(INFO) << "Begin identity key extraction.";
auto idKey = ta_->extractIdentityKey(std::vector<uint8_t>(nodeID.begin(), nodeID.end()));
LOG(INFO) << "End identity key extraction.";
LOG(INFO) << "Begin CBOR encoding";
// build cbor message of TA public key, identity and identity key
std::vector<uint8_t> clearBuffer;
ec_t mpk;
ec_null(mpk); ec_new(mpk);
cbor_item_t* root = cbor_new_definite_map(3);
cbor_map_add(root, (struct cbor_pair) {
.key = cbor_move(cbor_build_string("mpk")),
.value = cbor_move(relic_ec2cbor_compressed(ta_->kgc_->mpk))
});
int main(int argc, char *argv[])
{
FILE *in, *out;
char *file, s[100], cat[100], *macro, *desc;
int len;
if (argc < 2)
file = "/aup/common/macrostr.txt";
else
file = argv[1];
ec_null( in = fopen(file, "r") )
ec_null( out = fopen("/aup/common/macrostr.incl", "w") )
while (fgets(s, sizeof(s), in) != NULL) {
for (len = strlen(s); len > 0 && isspace((int)s[len - 1]); len--)
;
s[len] = '\0';
if (s[0] == '#') {
fprintf(out, "%s\n", s);
continue;
}
if (s[len - 1] == ':') {
strcpy(cat, s);
cat[len - 1] = '\0';
}
else {
macro = strtok(s, " \t");
if (macro == NULL)
continue;
desc = strtok(NULL, "\t");
if (desc == NULL)
desc = "";
else
while (isspace((int)*desc))
desc++;
fprintf(out, "{\"%s\", (intptr_t)%s, \"%s\", \"%s\"},\n",
cat, macro, macro, desc);
}
}
exit(EXIT_SUCCESS);
EC_CLEANUP_BGN
exit(EXIT_FAILURE);
EC_CLEANUP_END
}
cbor_item_t* relic_ec2cbor(const ec_t n) {
ec_t tmp;
cbor_item_t* ret = NULL;
ec_null(tmp);
ec_new(tmp);
ec_norm(tmp, n);
ret = cbor_new_definite_map(2);
// add X coordinate
cbor_map_add(ret, (struct cbor_pair) {
.key = cbor_move(cbor_build_string("x")),
.value = cbor_move(relic_fp2cbor(tmp->x))
});
int cp_ecdh_key(uint8_t *key, int key_len, bn_t d, ec_t q) {
ec_t p;
bn_t x, h;
int l, result = STS_OK;
uint8_t _x[FC_BYTES];
ec_null(p);
bn_null(x);
bn_null(h);
TRY {
ec_new(p);
bn_new(x);
bn_new(h);
ec_curve_get_cof(h);
if (bn_bits(h) < BN_DIGIT) {
ec_mul_dig(p, q, h->dp[0]);
} else {
ec_mul(p, q, h);
}
ec_mul(p, p, d);
if (ec_is_infty(p)) {
result = STS_ERR;
}
ec_get_x(x, p);
l = bn_size_bin(x);
bn_write_bin(_x, l, x);
md_kdf2(key, key_len, _x, l);
}
CATCH_ANY {
THROW(ERR_CAUGHT);
}
FINALLY {
ec_free(p);
bn_free(x);
bn_free(h);
}
return result;
}
int cp_ecss_ver(bn_t e, bn_t s, uint8_t *msg, int len, ec_t q) {
bn_t n, ev, rv;
ec_t p;
uint8_t hash[MD_LEN];
uint8_t m[len + FC_BYTES];
int result = 0;
bn_null(n);
bn_null(ev);
bn_null(rv);
ec_null(p);
TRY {
bn_new(n);
bn_new(ev);
bn_new(rv);
ec_new(p);
ec_curve_get_ord(n);
if (bn_sign(e) == BN_POS && bn_sign(s) == BN_POS && !bn_is_zero(s)) {
if (bn_cmp(e, n) == CMP_LT && bn_cmp(s, n) == CMP_LT) {
ec_mul_sim_gen(p, s, q, e);
ec_get_x(rv, p);
bn_mod(rv, rv, n);
memcpy(m, msg, len);
bn_write_bin(m + len, FC_BYTES, rv);
md_map(hash, m, len + FC_BYTES);
if (8 * MD_LEN > bn_bits(n)) {
len = CEIL(bn_bits(n), 8);
bn_read_bin(ev, hash, len);
bn_rsh(ev, ev, 8 * MD_LEN - bn_bits(n));
} else {
bn_read_bin(ev, hash, MD_LEN);
}
bn_mod(ev, ev, n);
result = dv_cmp_const(ev->dp, e->dp, MIN(ev->used, e->used));
result = (result == CMP_NE ? 0 : 1);
if (ev->used != e->used) {
result = 0;
}
}
}
}
CATCH_ANY {
THROW(ERR_CAUGHT);
}
FINALLY {
bn_free(n);
bn_free(ev);
bn_free(rv);
ec_free(p);
}
return result;
}
static void tests_relic_ecdh(void)
{
/* The following is an example for doing an elliptic-curve Diffie-Hellman
key exchange.
*/
/* Select an elliptic curve configuration */
if (ec_param_set_any() == STS_OK) {
#if (TEST_RELIC_SHOW_OUTPUT == 1)
ec_param_print();
#endif
bn_t privateA;
ec_t publicA;
uint8_t sharedKeyA[MD_LEN];
bn_t privateB;
ec_t publicB;
uint8_t sharedKeyB[MD_LEN];
bn_null(privateA);
ec_null(publicA);
bn_new(privateA);
ec_new(publicA);
bn_null(privateB);
ec_null(publicB);
bn_new(privateB);
ec_new(publicB);
/* User A generates private/public key pair */
TEST_ASSERT_EQUAL_INT(STS_OK, cp_ecdh_gen(privateA, publicA));
#if (TEST_RELIC_SHOW_OUTPUT == 1)
printf("User A\n");
printf("======\n");
printf("private key: ");
bn_print(privateA);
printf("\npublic key: ");
ec_print(publicA);
printf("\n");
#endif
/* User B generates private/public key pair */
TEST_ASSERT_EQUAL_INT(STS_OK, cp_ecdh_gen(privateB, publicB));
#if (TEST_RELIC_SHOW_OUTPUT == 1)
printf("User B\n");
printf("======\n");
printf("private key: ");
bn_print(privateB);
printf("\npublic key: ");
ec_print(publicB);
printf("\n");
#endif
/* In a protocol you would exchange the public keys now */
/* User A calculates shared secret */
TEST_ASSERT_EQUAL_INT(STS_OK, cp_ecdh_key(sharedKeyA, MD_LEN, privateA, publicB));
#if (TEST_RELIC_SHOW_OUTPUT == 1)
printf("\nshared key computed by user A: ");
print_mem(sharedKeyA, MD_LEN);
#endif
/* User B calculates shared secret */
TEST_ASSERT_EQUAL_INT(STS_OK, cp_ecdh_key(sharedKeyB, MD_LEN, privateB, publicA));
#if (TEST_RELIC_SHOW_OUTPUT == 1)
printf("\nshared key computed by user B: ");
print_mem(sharedKeyB, MD_LEN);
#endif
/* The secrets should be the same now */
TEST_ASSERT_EQUAL_INT(CMP_EQ, util_cmp_const(sharedKeyA, sharedKeyB, MD_LEN));
bn_free(privateA);
ec_free(publicA);
bn_free(privateB);
ec_free(publicB);
#if (TEST_RELIC_SHOW_OUTPUT == 1)
printf("\nRELIC EC-DH test successful\n");
#endif
}
}
void cp_ecss_sig(bn_t e, bn_t s, unsigned char *msg, int len, bn_t d) {
bn_t n, k, x, r;
ec_t p;
unsigned char hash[MD_LEN];
unsigned char m[len + EC_BYTES];
bn_null(n);
bn_null(k);
bn_null(x);
bn_null(r);
ec_null(p);
TRY {
bn_new(n);
bn_new(k);
bn_new(x);
bn_new(r);
ec_new(p);
ec_curve_get_ord(n);
do {
do {
bn_rand(k, BN_POS, bn_bits(n));
bn_mod(k, k, n);
} while (bn_is_zero(k));
ec_mul_gen(p, k);
ec_get_x(x, p);
bn_mod(r, x, n);
} while (bn_is_zero(r));
memcpy(m, msg, len);
bn_write_bin(m + len, EC_BYTES, r);
md_map(hash, m, len + EC_BYTES);
if (8 * MD_LEN > bn_bits(n)) {
len = CEIL(bn_bits(n), 8);
bn_read_bin(e, hash, len);
bn_rsh(e, e, 8 * MD_LEN - bn_bits(n));
} else {
bn_read_bin(e, hash, MD_LEN);
}
bn_mod(e, e, n);
bn_mul(s, d, e);
bn_mod(s, s, n);
bn_sub(s, n, s);
bn_add(s, s, k);
bn_mod(s, s, n);
}
CATCH_ANY {
THROW(ERR_CAUGHT);
}
FINALLY {
bn_free(n);
bn_free(k);
bn_free(x);
bn_free(r);
ec_free(p);
}
}
void scatter(DATATYPE* local){
/* puntatore file dei dati */
FILE* input;
/* puntatore alla matrice che verra scatterizzata */
FILE* out;
/* array di partizioni */
DATATYPE* partitions[p];
/* variabile temporanea per la la lettura del file */
DATATYPE temp;
/* indici per i cicli for */
int i,j;
/* indice di partizione e offset interno */
int part_index,part_offset;
/* array per le coordinate */
part_id result;
/* matrice su cui scrivo i dati letti da data */
DATATYPE matrix[M];
/* apertura del file dei dati */
input = fopen(INPUT_MATRIX,"r");
ec_meno1( input, "Problema nell'apertura del file dei dati\n" );
ec_null( input, "Problema nell'apertura del file dei dati\n" );
#ifdef DEBUG
printf("SCATTER: \n");
#endif
/* inizializzazione partizioni */
for(i = 0; i < p; i++ ){
partitions[i] = malloc(sizeof(DATATYPE)* localsize);
}
#ifdef DEBUG
printf("PARTIZIONI INIZIALIZZATE\n");
#endif
for(i=0; i< M; i++){
/* leggo il prossimo elemento */
fscanf(input,FORMAT,&temp);
matrix[i]=temp;
/* creazione delle coordinate*/
result = offset2partition(dim,lato,s,i);
/* assegnamento*/
*(partitions[result.part_index]+result.part_offset) = temp;
}/* LOOP i*/
#ifdef DEBUG
printf("RIEMPITE LE PARTIZIONI\n");
writeMatrix(SCATTER_MATRIX,matrix);
printf("SCRITTA LA MATRICE SU FILE\n");
#endif
/* copio gli elementi nella mia partizione locale */
for (i=0; i < localsize; i++){
local[i] = *(partitions[0]+i);
}
/*invio le partizioni agli altri*/
for (i=1; i < p; i++){
if( MPI_Send(partitions[i],localsize, MPI_DATATYPE, i, TAG, MPI_COMM_WORLD) != MPI_SUCCESS ){
fprintf(stderr,"Fallita la MPI_Send verso %d\n",i);
}
}
#if DEBUG
printf("SCATTER TERMINATA\n");
#endif
}
