Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • car/libdap-crypto
1 result
Show changes
Hide whitespace changes
Inline Side-by-side
Showing
with 5219 additions and 3015 deletions
src/dap_enc_GOST.c 0 → 100644
View file @ fb1c4cbf
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <stddef.h>
#include <string.h>
#include "dap_enc_GOST.h"
#include "dap_common.h"
#include "rand/dap_rand.h"
#include "sha3/KeccakHash.h"
#define LOG_TAG "dap_enc_gost"
#define DAP_DEL_Z DAP_DELETE
void dap_enc_gost_key_generate(struct dap_enc_key * a_key, const void *kex_buf,
size_t kex_size, const void * seed, size_t seed_size, size_t key_size)
{
if(key_size < 32)
{
log_it(L_ERROR, "GOST key cannot be less than 32 bytes.");
}
a_key->last_used_timestamp = time(NULL);
a_key->priv_key_data_size = 32;
a_key->priv_key_data = DAP_NEW_SIZE(uint8_t, key_size);
Keccak_HashInstance Keccak_ctx;
Keccak_HashInitialize(&Keccak_ctx, 1088, 512, 32*8, 0x06);
Keccak_HashUpdate(&Keccak_ctx, kex_buf, kex_size*8);
if(seed_size)
Keccak_HashUpdate(&Keccak_ctx, seed, seed_size*8);
Keccak_HashFinal(&Keccak_ctx, a_key->priv_key_data);
}
void dap_enc_gost_key_delete(struct dap_enc_key *a_key)
{
if(a_key->priv_key_data != NULL)
{
randombytes(a_key->priv_key_data,a_key->priv_key_data_size);
DAP_DELETE(a_key->priv_key_data);
}
a_key->priv_key_data_size = 0;
}
//------GOST_OFB-----------
void dap_enc_gost_ofb_key_new(struct dap_enc_key * a_key)
{
a_key->_inheritor = NULL;
a_key->_inheritor_size = 0;
a_key->type = DAP_ENC_KEY_TYPE_GOST_OFB;
a_key->enc = dap_enc_gost_ofb_encrypt;
a_key->dec = dap_enc_gost_ofb_decrypt;
a_key->enc_na = dap_enc_gost_ofb_encrypt_fast;
a_key->dec_na = dap_enc_gost_ofb_decrypt_fast;
}
size_t dap_enc_gost_ofb_decrypt(struct dap_enc_key *a_key, const void * a_in, size_t a_in_size, void ** a_out)
{
size_t a_out_size = a_in_size - kBlockLen89;
if(a_out_size <= 0) {
log_it(L_ERROR, "gost_ofb decryption ct with iv must be more than kBlockLen89 bytes");
return 0;
}
*a_out = DAP_NEW_SIZE(uint8_t, a_in_size - kBlockLen89);
a_out_size = dap_enc_gost_ofb_decrypt_fast(a_key, a_in, a_in_size, *a_out, a_out_size);
if(a_out_size == 0)
DAP_DEL_Z(*a_out);
return a_out_size;
}
size_t dap_enc_gost_ofb_encrypt(struct dap_enc_key * a_key, const void * a_in, size_t a_in_size, void ** a_out)
{
if(a_in_size <= 0) {
log_it(L_ERROR, "gost ofb encryption pt cannot be 0 bytes");
return 0;
}
size_t a_out_size = a_in_size + kBlockLen89;
*a_out = DAP_NEW_SIZE(uint8_t, a_out_size);
a_out_size = dap_enc_gost_ofb_encrypt_fast(a_key, a_in, a_in_size, *a_out, a_out_size);
if(a_out_size == 0)
DAP_DEL_Z(*a_out);
return a_out_size;
}
size_t dap_enc_gost_ofb_calc_encode_size(const size_t size_in)
{
return size_in + kBlockLen89;
}
size_t dap_enc_gost_ofb_calc_decode_size(const size_t size_in)
{
if(size_in <= kBlockLen89) {
log_it(L_ERROR, "gost_ofb decryption size_in ct with iv must be more than kBlockLen89 bytes");
return 0;
}
return size_in - kBlockLen89;
}
size_t dap_enc_gost_ofb_decrypt_fast(struct dap_enc_key *a_key, const void * a_in,
size_t a_in_size, void * a_out, size_t buf_out_size) {
size_t a_out_size = a_in_size - kBlockLen89;
if(a_out_size > buf_out_size) {
log_it(L_ERROR, "gost_ofb fast_decryption too small buf_out_size");
return 0;
}
uint8_t iv[kBlockLen89];
memcpy(iv, a_in, kBlockLen89);
unsigned char ctx[kOfb89ContextLen];
if(init_ofb_89(a_key->priv_key_data, ctx, kBlockLen89, iv, kBlockLen89,NULL, NULL))//, print_array, print_uint_array))
{
return 0;
}
if(crypt_ofb(ctx, a_in + kBlockLen89, a_out, a_in_size - kBlockLen89))
{
return 0;
}
free_ofb(ctx);
return a_out_size;
}
size_t dap_enc_gost_ofb_encrypt_fast(struct dap_enc_key * a_key, const void * a_in, size_t a_in_size, void * a_out,size_t buf_out_size)
{
//generate iv and put it in *a_out first bytes
size_t a_out_size = a_in_size + kBlockLen89;
if(a_out_size > buf_out_size) {
log_it(L_ERROR, "gost_ofb fast_encryption too small buf_out_size");
return 0;
}
uint8_t iv[kBlockLen89];
if(randombytes(iv, kBlockLen89) == 1)
{
log_it(L_ERROR, "failed to get kBlockLen89 bytes iv gost ofb");
return 0;
}
memcpy(a_out, iv, kBlockLen89);
unsigned char ctx[kOfb89ContextLen];
if(init_ofb_89(a_key->priv_key_data, ctx, kBlockLen89, iv, kBlockLen89,NULL, NULL))//, print_array, print_uint_array))
{
return 0;
}
if(crypt_ofb(ctx, a_in, a_out + kBlockLen89, a_in_size))
{
return 0;
}
free_ofb(ctx);
return a_out_size;
}
//------KUZN_OFB-----------
void dap_enc_kuzn_ofb_key_new(struct dap_enc_key * a_key)
{
a_key->_inheritor = NULL;
a_key->_inheritor_size = 0;
a_key->type = DAP_ENC_KEY_TYPE_GOST_OFB;
a_key->enc = dap_enc_kuzn_ofb_encrypt;
a_key->dec = dap_enc_kuzn_ofb_decrypt;
a_key->enc_na = dap_enc_kuzn_ofb_encrypt_fast;
a_key->dec_na = dap_enc_kuzn_ofb_decrypt_fast;
}
size_t dap_enc_kuzn_ofb_calc_encode_size(const size_t size_in)
{
return size_in + kBlockLen14;
}
size_t dap_enc_kuzn_ofb_calc_decode_size(const size_t size_in)
{
if(size_in <= kBlockLen14) {
log_it(L_ERROR, "gost_ofb decryption size_in ct with iv must be more than kBlockLen14 bytes");
return 0;
}
return size_in - kBlockLen14;
}
size_t dap_enc_kuzn_ofb_encrypt_fast(struct dap_enc_key * a_key, const void * a_in, size_t a_in_size, void * a_out,size_t buf_out_size)
{
//generate iv and put it in *a_out first bytes
size_t a_out_size = a_in_size + kBlockLen14;
if(a_in_size <= 0) {
log_it(L_ERROR, "kuzn_ofb fast_encryption too small a_in_size");
return 0;
}
if(a_out_size > buf_out_size) {
log_it(L_ERROR, "kuzn_ofb fast_encryption too small buf_out_size");
return 0;
}
if(randombytes(a_out, kBlockLen14) == 1)//iv
{
log_it(L_ERROR, "failed to get kBlockLen14 bytes iv gost ofb");
return 0;
}
unsigned char ctx[kOfb14ContextLen];
if(init_ofb_14(a_key->priv_key_data, ctx, kBlockLen14, a_out, kBlockLen14, NULL,NULL))
return -1;
if(crypt_ofb(ctx, a_in, a_out + kBlockLen14, a_in_size))
return -1;
free_ofb(ctx);
return a_out_size;
}
size_t dap_enc_kuzn_ofb_decrypt_fast(struct dap_enc_key *a_key, const void * a_in,
size_t a_in_size, void * a_out, size_t buf_out_size)
{
size_t a_out_size = a_in_size - kBlockLen14;
if(a_out_size <= 0) {
log_it(L_ERROR, "kuzn_ofb fast_decryption too small a_in_size");
return 0;
}
if(a_out_size > buf_out_size) {
log_it(L_ERROR, "kuzn_ofb fast_decryption too small buf_out_size");
return 0;
}
unsigned char ctx[kOfb14ContextLen];
//iv first kBlockLen14 a_in bytes
if(init_ofb_14(a_key->priv_key_data, ctx, kBlockLen14, a_in, kBlockLen14, NULL, NULL))
return -1;
if(decrypt_ofb(ctx, a_in + kBlockLen14, a_out, a_out_size))
return -1;
free_ofb(ctx);
return a_out_size;
}
size_t dap_enc_kuzn_ofb_decrypt(struct dap_enc_key *a_key, const void * a_in,
size_t a_in_size, void ** a_out) {
size_t a_out_size = a_in_size - kBlockLen14;
if(a_out_size <= 0) {
log_it(L_ERROR, "kuzn_ofb decryption too small a_in_size");
return 0;
}
*a_out = DAP_NEW_SIZE(uint8_t, a_out_size);
a_out_size = dap_enc_kuzn_ofb_decrypt_fast(a_key, a_in, a_in_size, *a_out, a_out_size);
if(!a_out_size)
DAP_DEL_Z(*a_out);
return a_out_size;
}
size_t dap_enc_kuzn_ofb_encrypt(struct dap_enc_key * a_key, const void * a_in, size_t a_in_size, void ** a_out)
{
//generate iv and put it in *a_out first bytes
if(a_in_size <= 0) {
log_it(L_ERROR, "kuzn fast_encryption too small a_in_size");
return 0;
}
size_t a_out_size = a_in_size + kBlockLen14;
*a_out = DAP_NEW_SIZE(uint8_t, a_out_size);
a_out_size = dap_enc_kuzn_ofb_encrypt_fast(a_key, a_in, a_in_size, *a_out, a_out_size);
if(!a_out_size)
DAP_DEL_Z(*a_out);
return a_out_size;
}
src/dap_enc_base58.c
View file @ fb1c4cbf
/*
* Authors:
* Dmitriy A. Gearasimov <kahovski@gmail.com>
* DeM Labs Inc. https://demlabs.net
* Kelvin Blockchain community https://github.com/kelvinblockchain
* Copyright (c) 2017-2019
* All rights reserved.
This file is part of DAP (Deus Applications Prototypes) the open source project
DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
DAP is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with any DAP based project. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include "dap_common.h"
#include "dap_enc_base58.h"
#define LOG_TAG "dap_enc_base58"
const char c_b58digits_ordered[] = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
const int8_t c_b58digits_map[] = {
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1, 0, 1, 2, 3, 4, 5, 6, 7, 8,-1,-1,-1,-1,-1,-1,
-1, 9,10,11,12,13,14,15,16,-1,17,18,19,20,21,-1,
22,23,24,25,26,27,28,29,30,31,32,-1,-1,-1,-1,-1,
-1,33,34,35,36,37,38,39,40,41,42,43,-1,44,45,46,
47,48,49,50,51,52,53,54,55,56,57,-1,-1,-1,-1,-1,
};
/**
* @brief dap_enc_base58_decode
* @param a_in
* @param a_out
* @return
*/
size_t dap_enc_base58_decode(const char * a_in, void * a_out)
{
size_t l_out_size_max = DAP_ENC_BASE58_DECODE_SIZE(strlen(a_in ));
size_t l_out_size = l_out_size_max;
const unsigned char *l_in_u8 = (const unsigned char*)a_in;
size_t l_outi_size = (l_out_size_max + 3) / 4;
uint32_t l_outi[l_outi_size];
memset(l_outi, 0, l_outi_size*sizeof(uint32_t));
uint64_t t;
uint32_t c;
size_t i, j;
uint8_t bytesleft = l_out_size_max % 4;
uint32_t zeromask = bytesleft ? (0xffffffff << (bytesleft * 8)) : 0;
unsigned zerocount = 0;
size_t l_in_len = strlen(a_in);
// Leading zeros, just count
for (i = 0; i < l_in_len && l_in_u8[i] == '1'; ++i)
++zerocount;
for ( ; i < l_in_len; ++i)
{
if (l_in_u8[i] & 0x80)
// High-bit set on invalid digit
return 0;
if (c_b58digits_map[l_in_u8[i]] == -1)
// Invalid base58 digit
return 0;
c = (unsigned)c_b58digits_map[l_in_u8[i]];
for (j = l_outi_size; j--; )
{
t = ((uint64_t)l_outi[j]) * 58 + c;
c = (t & 0x3f00000000) >> 32;
l_outi[j] = t & 0xffffffff;
}
if (c)
// Output number too big (carry to the next int32)
return 0;
if (l_outi[0] & zeromask)
// Output number too big (last int32 filled too far)
return 0;
}
unsigned char l_out_u80[l_out_size_max];
unsigned char *l_out_u8 = l_out_u80;
j = 0;
switch (bytesleft) {
case 3:
*(l_out_u8++) = (l_outi[0] & 0xff0000) >> 16;
//-fallthrough
case 2:
*(l_out_u8++) = (l_outi[0] & 0xff00) >> 8;
//-fallthrough
case 1:
*(l_out_u8++) = (l_outi[0] & 0xff);
++j;
//-fallthrough
default:
break;
}
for (; j < l_outi_size; ++j)
{
*(l_out_u8++) = (l_outi[j] >> 0x18) & 0xff;
*(l_out_u8++) = (l_outi[j] >> 0x10) & 0xff;
*(l_out_u8++) = (l_outi[j] >> 8) & 0xff;
*(l_out_u8++) = (l_outi[j] >> 0) & 0xff;
}
// Count canonical base58 byte count
l_out_u8 = l_out_u80;
for (i = 0; i < l_out_size_max; ++i)
{
if (l_out_u8[i]) {
if (zerocount > i) {
/* result too large */
return 0;
}
break;
}
--l_out_size;
}
unsigned char *l_out = a_out;
memset(l_out, 0, zerocount);
// shift result to beginning of the string
for (j = 0; j < l_out_size; j++){
l_out[j+zerocount] = l_out_u8[j+i];
}
l_out[j+zerocount] = 0;
l_out_size += zerocount;
return l_out_size;
}
//bool b58enc(char *a_out, size_t *l_out_size, const void *a_in, size_t a_in_size)
size_t dap_enc_base58_encode(const void * a_in, size_t a_in_size, char * a_out)
{
const uint8_t *l_in_u8 = a_in;
int carry;
ssize_t i, j, high, zcount = 0;
size_t size;
size_t l_out_size = DAP_ENC_BASE58_ENCODE_SIZE (a_in_size);
while (zcount < (ssize_t)a_in_size && !l_in_u8[zcount])
++zcount;
size = (a_in_size - zcount) * 138 / 100 + 1;
uint8_t buf[size];
memset(buf, 0, size);
for (i = zcount, high = size - 1; i < (ssize_t)a_in_size; ++i, high = j)
{
for (carry = l_in_u8[i], j = size - 1; (j > high) || carry; --j)
{
carry += 256 * buf[j];
buf[j] = carry % 58;
carry /= 58;
}
}
for (j = 0; j < (ssize_t)size && !buf[j]; ++j);
if (l_out_size <= ( zcount + size - j) ){
l_out_size = ( zcount + size - j + 1 );
return l_out_size;
}
if (zcount)
memset(a_out, '1', zcount);
for (i = zcount; j < (ssize_t)size; ++i, ++j)
a_out[i] = c_b58digits_ordered[buf[j]];
a_out[i] = '\0';
l_out_size = i;
return l_out_size;
}
/*
* Authors:
* Dmitriy A. Gearasimov <kahovski@gmail.com>
* DeM Labs Inc. https://demlabs.net
* Kelvin Blockchain community https://github.com/kelvinblockchain
* Copyright (c) 2017-2019
* All rights reserved.
This file is part of DAP (Deus Applications Prototypes) the open source project
DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
DAP is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with any DAP based project. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include "dap_common.h"
#include "dap_enc_base58.h"
#define LOG_TAG "dap_enc_base58"
const char c_b58digits_ordered[] = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
const int8_t c_b58digits_map[] = {
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1, 0, 1, 2, 3, 4, 5, 6, 7, 8,-1,-1,-1,-1,-1,-1,
-1, 9,10,11,12,13,14,15,16,-1,17,18,19,20,21,-1,
22,23,24,25,26,27,28,29,30,31,32,-1,-1,-1,-1,-1,
-1,33,34,35,36,37,38,39,40,41,42,43,-1,44,45,46,
47,48,49,50,51,52,53,54,55,56,57,-1,-1,-1,-1,-1,
};
/**
* @brief dap_enc_base58_decode
* @param a_in
* @param a_out
* @return
*/
size_t dap_enc_base58_decode(const char * a_in, void * a_out)
{
size_t l_out_size_max = DAP_ENC_BASE58_DECODE_SIZE(strlen(a_in ));
size_t l_out_size = l_out_size_max;
const unsigned char *l_in_u8 = (const unsigned char*)a_in;
size_t l_outi_size = (l_out_size_max + 3) / 4;
uint32_t l_outi[l_outi_size];
memset(l_outi, 0, l_outi_size*sizeof(uint32_t));
uint64_t t;
uint32_t c;
size_t i, j;
uint8_t bytesleft = l_out_size_max % 4;
uint32_t zeromask = bytesleft ? (0xffffffff << (bytesleft * 8)) : 0;
unsigned zerocount = 0;
size_t l_in_len = strlen(a_in);
// Leading zeros, just count
for (i = 0; i < l_in_len && l_in_u8[i] == '1'; ++i)
++zerocount;
for ( ; i < l_in_len; ++i)
{
if (l_in_u8[i] & 0x80)
// High-bit set on invalid digit
return 0;
if (c_b58digits_map[l_in_u8[i]] == -1)
// Invalid base58 digit
return 0;
c = (unsigned)c_b58digits_map[l_in_u8[i]];
for (j = l_outi_size; j--; )
{
t = ((uint64_t)l_outi[j]) * 58 + c;
c = (t & 0x3f00000000) >> 32;
l_outi[j] = t & 0xffffffff;
}
if (c)
// Output number too big (carry to the next int32)
return 0;
if (l_outi[0] & zeromask)
// Output number too big (last int32 filled too far)
return 0;
}
unsigned char l_out_u80[l_out_size_max];
unsigned char *l_out_u8 = l_out_u80;
j = 0;
switch (bytesleft) {
case 3:
*(l_out_u8++) = (l_outi[0] & 0xff0000) >> 16;
//-fallthrough
case 2:
*(l_out_u8++) = (l_outi[0] & 0xff00) >> 8;
//-fallthrough
case 1:
*(l_out_u8++) = (l_outi[0] & 0xff);
++j;
//-fallthrough
default:
break;
}
for (; j < l_outi_size; ++j)
{
*(l_out_u8++) = (l_outi[j] >> 0x18) & 0xff;
*(l_out_u8++) = (l_outi[j] >> 0x10) & 0xff;
*(l_out_u8++) = (l_outi[j] >> 8) & 0xff;
*(l_out_u8++) = (l_outi[j] >> 0) & 0xff;
}
// Count canonical base58 byte count
l_out_u8 = l_out_u80;
for (i = 0; i < l_out_size_max; ++i)
{
if (l_out_u8[i]) {
if (zerocount > i) {
/* result too large */
return 0;
}
break;
}
--l_out_size;
}
unsigned char *l_out = a_out;
memset(l_out, 0, zerocount);
// shift result to beginning of the string
for (j = 0; j < l_out_size; j++){
l_out[j+zerocount] = l_out_u8[j+i];
}
l_out[j+zerocount] = 0;
l_out_size += zerocount;
return l_out_size;
}
//bool b58enc(char *a_out, size_t *l_out_size, const void *a_in, size_t a_in_size)
size_t dap_enc_base58_encode(const void * a_in, size_t a_in_size, char * a_out)
{
const uint8_t *l_in_u8 = a_in;
int carry;
ssize_t i, j, high, zcount = 0;
size_t size;
size_t l_out_size = DAP_ENC_BASE58_ENCODE_SIZE (a_in_size);
while (zcount < (ssize_t)a_in_size && !l_in_u8[zcount])
++zcount;
size = (a_in_size - zcount) * 138 / 100 + 1;
uint8_t buf[size];
memset(buf, 0, size);
for (i = zcount, high = size - 1; i < (ssize_t)a_in_size; ++i, high = j)
{
for (carry = l_in_u8[i], j = size - 1; (j > high) || carry; --j)
{
carry += 256 * buf[j];
buf[j] = carry % 58;
carry /= 58;
}
}
for (j = 0; j < (ssize_t)size && !buf[j]; ++j);
if (l_out_size <= ( zcount + size - j) ){
l_out_size = ( zcount + size - j + 1 );
return l_out_size;
}
if (zcount)
memset(a_out, '1', zcount);
for (i = zcount; j < (ssize_t)size; ++i, ++j)
a_out[i] = c_b58digits_ordered[buf[j]];
a_out[i] = '\0';
l_out_size = i;
return l_out_size;
}
src/dap_enc_base64.c
View file @ fb1c4cbf
#include <math.h>
#include <stdio.h>
#include <stdint.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include "dap_enc_base64.h"
typedef unsigned char byte;
// get the size of the result buffer required for Base-64
// encoding/decoding.
// sz - size of original buffer to be encoded/decoded
// isEncoded - true (1) when encoding the original buffer;
// false (0) when decoding the original buffer.
int B64_GetSize( int sz, int isEncode );
// Base-64 encode the given byte array
// outChars - buffer of length returned by GetSize(), filled upon return
void B64_Encode( const byte* srcBytes, int srcLen, char* outChars );
// Base-64 decode the given string
// srcChars - characters to be decoded
// outBytes - buffer of length returned by GetSize(), filled upon return
void B64_Decode( const char* srcChars, int srcLen, byte* outBytes );
// return the Base-64 encoded char for the given source byte
char B64_EncodeByte( byte b );
// return the Base-64 decoded byte for the given source char
// <returns></returns>
byte B64_DecodeByte( byte b );
#ifndef b64_malloc
# define b64_malloc(ptr) malloc(ptr)
#endif
#ifndef b64_realloc
# define b64_realloc(ptr, size) realloc(ptr, size)
#endif
/**
* @breif Base64 index table.
*/
static const char b64_standart_table[] = {
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
'w', 'x', 'y', 'z', '0', '1', '2', '3',
'4', '5', '6', '7', '8', '9', '+', '/'
};
/**
* @breif Base64 url safe index table.
*/
static const char b64_table_url_safe[] = {
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
'w', 'x', 'y', 'z', '0', '1', '2', '3',
'4', '5', '6', '7', '8', '9', '-', '_'
};
/**
* Encode `unsigned char *' source with `size_t' size.
* Returns a `char *' base64 encoded string.
*/
char *
b64_encode (const unsigned char *, size_t);
/**
* Dencode `char *' source with `size_t' size.
* Returns a `unsigned char *' base64 decoded string.
*/
unsigned char *
b64_decode (const char *, size_t);
/**
* Dencode `char *' source with `size_t' size.
* Returns a `unsigned char *' base64 decoded string + size of decoded string.
*/
unsigned char *
b64_decode_ex (const char *, size_t, size_t *);
/**
* @brief b64_table_by_standard The function returns the corresponding table of indices
* @param[in] standard Base64 or Base64 URLSAFE encoding
* @return index table
*/
static const char* b64_table_by_standard(dap_enc_data_type_t standard)
{
switch (standard) {
case DAP_ENC_DATA_TYPE_B64:
return b64_standart_table;
case DAP_ENC_DATA_TYPE_B64_URLSAFE:
return b64_table_url_safe;
default:
perror("Unknown base64 standard");
abort();
}
return NULL;
}
/**
* @brief dap_enc_base64_decode Function of reverse transformation of base64 algorithm
* @param[in] in Pointer to an array with incoming data
* @param[in] in_size Size of the array with outgoing data
* @param[out] out Pointer to an array with outgoing data
* @return Size of the array with outgoing data
*/
size_t dap_enc_base64_decode(const char * in, size_t in_size,void * out, dap_enc_data_type_t standard)
{
uint8_t * out_bytes = (uint8_t*) out;
int j = 0;
int8_t l = 0, i = 0;
size_t l_size = 0;
unsigned char buf[3] = {0};
unsigned char tmp[4] = {0};
const char* b64_table = b64_table_by_standard(standard);
if (NULL == out) { return 0; }
// parse until end of source
while (in_size--) {
// break if char is `=' or not base64 char
if ('=' == in[j]) { break; }
if (!(isalnum(in[j]) || in[j] == b64_table[62] || in[j] == b64_table[63]))
break;
// read up to 4 bytes at a time into `tmp'
tmp[i++] = in[j++];
// if 4 bytes read then decode into `buf'
if (4 == i) {
// translate values in `tmp' from table
for (i = 0; i < 4; ++i) {
// find translation char in `b64_table'
for (l = 0; l < 64; ++l) {
if (tmp[i] == b64_table[l]) {
tmp[i] = l;
break;
}
}
}
// decode
buf[0] = (tmp[0] << 2) + ((tmp[1] & 0x30) >> 4);
buf[1] = ((tmp[1] & 0xf) << 4) + ((tmp[2] & 0x3c) >> 2);
buf[2] = ((tmp[2] & 0x3) << 6) + tmp[3];
// write decoded buffer to `dec'
for (i = 0; i < 3; ++i) {
out_bytes[l_size++] = buf[i];
}
// reset
i = 0;
}
}
// remainder
if (i > 0) {
// fill `tmp' with `\0' at most 4 times
for (j = i; j < 4; ++j) {
tmp[j] = '\0';
}
// translate remainder
for (j = 0; j < 4; ++j) {
// find translation char in `b64_table'
for (l = 0; l < 64; ++l) {
if (tmp[j] == b64_table[l]) {
tmp[j] = l;
break;
}
}
}
// decode remainder
buf[0] = (tmp[0] << 2) + ((tmp[1] & 0x30) >> 4);
buf[1] = ((tmp[1] & 0xf) << 4) + ((tmp[2] & 0x3c) >> 2);
buf[2] = ((tmp[2] & 0x3) << 6) + tmp[3];
// write remainer decoded buffer to `dec'
for (j = 0; (j < i - 1); ++j) {
out_bytes[l_size++] = buf[j];
}
}
return l_size;
}
/**
* @brief dap_enc_base64_encode The function encodes the array according to the base64 algorithm
* @param[in] a_in Array with incoming data
* @param[in] a_in_size The size of the deviance array in the a_in parameter
* @param[out] a_out A pointer to an array in which the data will be after encoding
* @return Size of the array with outgoing data
*/
size_t dap_enc_base64_encode(const void * a_in, size_t a_in_size, char * a_out, dap_enc_data_type_t standard)
{
uint8_t i = 0;
int j = 0;
size_t size = 0;
unsigned char buf[4];
unsigned char tmp[3];
const unsigned char * l_in_bytes = (const unsigned char*) a_in;
const char* b64_table = b64_table_by_standard(standard);
if (NULL == a_out) { return 0; }
// parse until end of source
while (a_in_size--) {
// read up to 3 bytes at a time into `tmp'
tmp[i++] = *( l_in_bytes++);
// if 3 bytes read then encode into `buf'
if (3 == i) {
buf[0] = (tmp[0] & 0xfc) >> 2;
buf[1] = ((tmp[0] & 0x03) << 4) + ((tmp[1] & 0xf0) >> 4);
buf[2] = ((tmp[1] & 0x0f) << 2) + ((tmp[2] & 0xc0) >> 6);
buf[3] = tmp[2] & 0x3f;
for (i = 0; i < 4; ++i) {
a_out[size++] = b64_table[buf[i]];
}
// reset index
i = 0;
}
}
// remainder
if (i > 0) {
// fill `tmp' with `\0' at most 3 times
for (j = i; j < 3; ++j) {
tmp[j] = '\0';
}
// perform same codec as above
buf[0] = (tmp[0] & 0xfc) >> 2;
buf[1] = ((tmp[0] & 0x03) << 4) + ((tmp[1] & 0xf0) >> 4);
buf[2] = ((tmp[1] & 0x0f) << 2) + ((tmp[2] & 0xc0) >> 6);
buf[3] = tmp[2] & 0x3f;
// perform same write to `enc` with new allocation
for (j = 0; (j < i + 1); ++j) {
a_out[size++] = b64_table[buf[j]];
}
// while there is still a remainder
// append `=' to `enc'
while ((i++ < 3)) {
a_out[size++] = '=';
}
}
return size;
}
// get the size of the result buffer required for Base-64
// encoding/decoding.
// sz - size of original buffer to be encoded/decoded
// isEncoded - true (1) when encoding the original buffer;
// false (0) when decoding the original buffer.
int B64_GetSize( int sz, int isEncode )
{
int n = 0;
if( isEncode ) {
n = ceil ( ((double) sz) / 3.0 ) * 4.0;
switch( sz % 3 ) {
case 0: break;
case 1: n += 2; break;
case 2: n += 3; break;
}
}
else {
n = ceil ( ((double) sz) / 4.0 ) * 3.0;
switch( sz % 4 ) {
case 0: break;
case 1: break;
case 2: n += 1; break;
case 3: n += 2; break;
}
}
return n;
}
// Base-64 encode the given byte array
// outChars - buffer of length returned by GetSize(), filled upon return
void B64_Encode( const byte* srcBytes, int srcLen, char* outChars )
{
byte b1, b2, b3;
byte* destBytes = (byte*)outChars;
// walk through the source, taking 3 bytes at a time
int srcNdx = 0;
int destNdx = 0;
int remaining = srcLen;
for( ; remaining > 2; remaining -= 3 ) {
b1 = srcBytes[ srcNdx++ ];
b2 = srcBytes[ srcNdx++ ];
b3 = srcBytes[ srcNdx++ ];
destBytes[destNdx++] = B64_EncodeByte( (byte)( b1 >> 2 ) );
destBytes[destNdx++] = B64_EncodeByte( (byte)( ( b1 << 4 ) | ( b2 >> 4 ) ) );
destBytes[destNdx++] = B64_EncodeByte( (byte)( ( b2 << 2 ) | ( b3 >> 6 ) ) );
destBytes[destNdx++] = B64_EncodeByte( (byte)b3 );
}
// process the remaining bytes
b2 = 0;
if( remaining > 0 ) {
b1 = srcBytes[srcNdx++];
if( remaining == 2 )
b2 = srcBytes[srcNdx++];
destBytes[destNdx++] = B64_EncodeByte( (byte)( b1 >> 2 ) );
destBytes[destNdx++] = B64_EncodeByte( (byte)( ( b1 << 4 ) | ( b2 >> 4 ) ) );
if( remaining == 2 )
destBytes[destNdx++] = B64_EncodeByte( (byte)( b2 << 2 ) );
}
}
// Base-64 decode the given string
// srcChars - characters to be decoded
// outBytes - buffer of length returned by GetSize(), filled upon return
void B64_Decode( const char* srcChars, int srcLen, byte* outBytes )
{
byte b1, b2, b3, b4;
const byte* srcBytes = (byte*)srcChars;
byte* destBytes = outBytes;
// walk through the source, taking 4 bytes at a time
int srcNdx = 0;
int destNdx = 0;
int remaining = srcLen;
for( ; remaining > 3; remaining -= 4 ) {
b1 = B64_DecodeByte( srcBytes[srcNdx++] );
b2 = B64_DecodeByte( srcBytes[srcNdx++] );
b3 = B64_DecodeByte( srcBytes[srcNdx++] );
b4 = B64_DecodeByte( srcBytes[srcNdx++] );
destBytes[destNdx++] = (byte)( ( b1 << 2 ) | ( b2 >> 4 ) );
destBytes[destNdx++] = (byte)( ( b2 << 4 ) | ( b3 >> 2 ) );
destBytes[destNdx++] = (byte)( ( b3 << 6 ) | b4 );
}
// process the remaining bytes
b2 = b3 = 0;
if( remaining > 0 ) {
b1 = B64_DecodeByte( srcBytes[srcNdx++] );
if( remaining > 1 )
b2 = B64_DecodeByte( srcBytes[srcNdx++] );
if( remaining == 3 )
b3 = B64_DecodeByte( srcBytes[srcNdx++] );
destBytes[destNdx++] = (byte)( ( b1 << 2 ) | ( b2 >> 4 ) );
if( remaining == 3 )
destBytes[destNdx++] = (byte)( ( b2 << 4 ) | ( b3 >> 2 ) );
}
}
// return the Base-64 encoded char for the given source byte
char B64_EncodeByte( byte b )
{
b &= 0x3f;
if( b <= 25 )
return (byte)( b +'A' );
if( b <= 51 )
return (byte)( b - 26 + 'a' );
if( b <= 61 )
return (byte)( b - 52 + '0' );
if( b == 62 )
return (byte)'-';
return (byte)'_';
}
// return the Base-64 decoded byte for the given source char
// <returns></returns>
byte B64_DecodeByte( byte b )
{
if (( b == '+' ) || (b =='-') )
return 62;
if( (b == '/' ) || (b == '_') )
return 63;
if( b <= '9' )
return (byte)( b - '0' + 52 );
if( b <= 'Z' )
return (byte)( b - 'A' );
return (byte)( b - 'a' + 26 );
}
#include <math.h>
#include <stdio.h>
#include <stdint.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include "dap_enc_base64.h"
typedef unsigned char byte;
// get the size of the result buffer required for Base-64
// encoding/decoding.
// sz - size of original buffer to be encoded/decoded
// isEncoded - true (1) when encoding the original buffer;
// false (0) when decoding the original buffer.
int B64_GetSize( int sz, int isEncode );
// Base-64 encode the given byte array
// outChars - buffer of length returned by GetSize(), filled upon return
void B64_Encode( const byte* srcBytes, int srcLen, char* outChars );
// Base-64 decode the given string
// srcChars - characters to be decoded
// outBytes - buffer of length returned by GetSize(), filled upon return
void B64_Decode( const char* srcChars, int srcLen, byte* outBytes );
// return the Base-64 encoded char for the given source byte
char B64_EncodeByte( byte b );
// return the Base-64 decoded byte for the given source char
// <returns></returns>
byte B64_DecodeByte( byte b );
#ifndef b64_malloc
# define b64_malloc(ptr) malloc(ptr)
#endif
#ifndef b64_realloc
# define b64_realloc(ptr, size) realloc(ptr, size)
#endif
/**
* @breif Base64 index table.
*/
static const char b64_standart_table[] = {
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
'w', 'x', 'y', 'z', '0', '1', '2', '3',
'4', '5', '6', '7', '8', '9', '+', '/'
};
/**
* @breif Base64 url safe index table.
*/
static const char b64_table_url_safe[] = {
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
'w', 'x', 'y', 'z', '0', '1', '2', '3',
'4', '5', '6', '7', '8', '9', '-', '_'
};
/**
* Encode `unsigned char *' source with `size_t' size.
* Returns a `char *' base64 encoded string.
*/
char *
b64_encode (const unsigned char *, size_t);
/**
* Dencode `char *' source with `size_t' size.
* Returns a `unsigned char *' base64 decoded string.
*/
unsigned char *
b64_decode (const char *, size_t);
/**
* Dencode `char *' source with `size_t' size.
* Returns a `unsigned char *' base64 decoded string + size of decoded string.
*/
unsigned char *
b64_decode_ex (const char *, size_t, size_t *);
/**
* @brief b64_table_by_standard The function returns the corresponding table of indices
* @param[in] standard Base64 or Base64 URLSAFE encoding
* @return index table
*/
static const char* b64_table_by_standard(dap_enc_data_type_t standard)
{
switch (standard) {
case DAP_ENC_DATA_TYPE_B64:
return b64_standart_table;
case DAP_ENC_DATA_TYPE_B64_URLSAFE:
return b64_table_url_safe;
default:
perror("Unknown base64 standard");
abort();
}
return NULL;
}
/**
* @brief dap_enc_base64_decode Function of reverse transformation of base64 algorithm
* @param[in] in Pointer to an array with incoming data
* @param[in] in_size Size of the array with outgoing data
* @param[out] out Pointer to an array with outgoing data
* @return Size of the array with outgoing data
*/
size_t dap_enc_base64_decode(const char * in, size_t in_size,void * out, dap_enc_data_type_t standard)
{
uint8_t * out_bytes = (uint8_t*) out;
int j = 0;
int8_t l = 0, i = 0;
size_t l_size = 0;
unsigned char buf[3] = {0};
unsigned char tmp[4] = {0};
const char* b64_table = b64_table_by_standard(standard);
if (NULL == out) { return 0; }
// parse until end of source
while (in_size--) {
// break if char is `=' or not base64 char
if ('=' == in[j]) { break; }
if (!(isalnum(in[j]) || in[j] == b64_table[62] || in[j] == b64_table[63]))
break;
// read up to 4 bytes at a time into `tmp'
tmp[i++] = in[j++];
// if 4 bytes read then decode into `buf'
if (4 == i) {
// translate values in `tmp' from table
for (i = 0; i < 4; ++i) {
// find translation char in `b64_table'
for (l = 0; l < 64; ++l) {
if (tmp[i] == b64_table[l]) {
tmp[i] = l;
break;
}
}
}
// decode
buf[0] = (tmp[0] << 2) + ((tmp[1] & 0x30) >> 4);
buf[1] = ((tmp[1] & 0xf) << 4) + ((tmp[2] & 0x3c) >> 2);
buf[2] = ((tmp[2] & 0x3) << 6) + tmp[3];
// write decoded buffer to `dec'
for (i = 0; i < 3; ++i) {
out_bytes[l_size++] = buf[i];
}
// reset
i = 0;
}
}
// remainder
if (i > 0) {
// fill `tmp' with `\0' at most 4 times
for (j = i; j < 4; ++j) {
tmp[j] = '\0';
}
// translate remainder
for (j = 0; j < 4; ++j) {
// find translation char in `b64_table'
for (l = 0; l < 64; ++l) {
if (tmp[j] == b64_table[l]) {
tmp[j] = l;
break;
}
}
}
// decode remainder
buf[0] = (tmp[0] << 2) + ((tmp[1] & 0x30) >> 4);
buf[1] = ((tmp[1] & 0xf) << 4) + ((tmp[2] & 0x3c) >> 2);
buf[2] = ((tmp[2] & 0x3) << 6) + tmp[3];
// write remainer decoded buffer to `dec'
for (j = 0; (j < i - 1); ++j) {
out_bytes[l_size++] = buf[j];
}
}
return l_size;
}
/**
* @brief dap_enc_base64_encode The function encodes the array according to the base64 algorithm
* @param[in] a_in Array with incoming data
* @param[in] a_in_size The size of the deviance array in the a_in parameter
* @param[out] a_out A pointer to an array in which the data will be after encoding
* @return Size of the array with outgoing data
*/
size_t dap_enc_base64_encode(const void * a_in, size_t a_in_size, char * a_out, dap_enc_data_type_t standard)
{
uint8_t i = 0;
int j = 0;
size_t size = 0;
unsigned char buf[4];
unsigned char tmp[3];
const unsigned char * l_in_bytes = (const unsigned char*) a_in;
const char* b64_table = b64_table_by_standard(standard);
if (NULL == a_out) { return 0; }
// parse until end of source
while (a_in_size--) {
// read up to 3 bytes at a time into `tmp'
tmp[i++] = *( l_in_bytes++);
// if 3 bytes read then encode into `buf'
if (3 == i) {
buf[0] = (tmp[0] & 0xfc) >> 2;
buf[1] = ((tmp[0] & 0x03) << 4) + ((tmp[1] & 0xf0) >> 4);
buf[2] = ((tmp[1] & 0x0f) << 2) + ((tmp[2] & 0xc0) >> 6);
buf[3] = tmp[2] & 0x3f;
for (i = 0; i < 4; ++i) {
a_out[size++] = b64_table[buf[i]];
}
// reset index
i = 0;
}
}
// remainder
if (i > 0) {
// fill `tmp' with `\0' at most 3 times
for (j = i; j < 3; ++j) {
tmp[j] = '\0';
}
// perform same codec as above
buf[0] = (tmp[0] & 0xfc) >> 2;
buf[1] = ((tmp[0] & 0x03) << 4) + ((tmp[1] & 0xf0) >> 4);
buf[2] = ((tmp[1] & 0x0f) << 2) + ((tmp[2] & 0xc0) >> 6);
buf[3] = tmp[2] & 0x3f;
// perform same write to `enc` with new allocation
for (j = 0; (j < i + 1); ++j) {
a_out[size++] = b64_table[buf[j]];
}
// while there is still a remainder
// append `=' to `enc'
while ((i++ < 3)) {
a_out[size++] = '=';
}
}
return size;
}
// get the size of the result buffer required for Base-64
// encoding/decoding.
// sz - size of original buffer to be encoded/decoded
// isEncoded - true (1) when encoding the original buffer;
// false (0) when decoding the original buffer.
int B64_GetSize( int sz, int isEncode )
{
int n = 0;
if( isEncode ) {
n = ceil ( ((double) sz) / 3.0 ) * 4.0;
switch( sz % 3 ) {
case 0: break;
case 1: n += 2; break;
case 2: n += 3; break;
}
}
else {
n = ceil ( ((double) sz) / 4.0 ) * 3.0;
switch( sz % 4 ) {
case 0: break;
case 1: break;
case 2: n += 1; break;
case 3: n += 2; break;
}
}
return n;
}
// Base-64 encode the given byte array
// outChars - buffer of length returned by GetSize(), filled upon return
void B64_Encode( const byte* srcBytes, int srcLen, char* outChars )
{
byte b1, b2, b3;
byte* destBytes = (byte*)outChars;
// walk through the source, taking 3 bytes at a time
int srcNdx = 0;
int destNdx = 0;
int remaining = srcLen;
for( ; remaining > 2; remaining -= 3 ) {
b1 = srcBytes[ srcNdx++ ];
b2 = srcBytes[ srcNdx++ ];
b3 = srcBytes[ srcNdx++ ];
destBytes[destNdx++] = B64_EncodeByte( (byte)( b1 >> 2 ) );
destBytes[destNdx++] = B64_EncodeByte( (byte)( ( b1 << 4 ) | ( b2 >> 4 ) ) );
destBytes[destNdx++] = B64_EncodeByte( (byte)( ( b2 << 2 ) | ( b3 >> 6 ) ) );
destBytes[destNdx++] = B64_EncodeByte( (byte)b3 );
}
// process the remaining bytes
b2 = 0;
if( remaining > 0 ) {
b1 = srcBytes[srcNdx++];
if( remaining == 2 )
b2 = srcBytes[srcNdx++];
destBytes[destNdx++] = B64_EncodeByte( (byte)( b1 >> 2 ) );
destBytes[destNdx++] = B64_EncodeByte( (byte)( ( b1 << 4 ) | ( b2 >> 4 ) ) );
if( remaining == 2 )
destBytes[destNdx++] = B64_EncodeByte( (byte)( b2 << 2 ) );
}
}
// Base-64 decode the given string
// srcChars - characters to be decoded
// outBytes - buffer of length returned by GetSize(), filled upon return
void B64_Decode( const char* srcChars, int srcLen, byte* outBytes )
{
byte b1, b2, b3, b4;
const byte* srcBytes = (byte*)srcChars;
byte* destBytes = outBytes;
// walk through the source, taking 4 bytes at a time
int srcNdx = 0;
int destNdx = 0;
int remaining = srcLen;
for( ; remaining > 3; remaining -= 4 ) {
b1 = B64_DecodeByte( srcBytes[srcNdx++] );
b2 = B64_DecodeByte( srcBytes[srcNdx++] );
b3 = B64_DecodeByte( srcBytes[srcNdx++] );
b4 = B64_DecodeByte( srcBytes[srcNdx++] );
destBytes[destNdx++] = (byte)( ( b1 << 2 ) | ( b2 >> 4 ) );
destBytes[destNdx++] = (byte)( ( b2 << 4 ) | ( b3 >> 2 ) );
destBytes[destNdx++] = (byte)( ( b3 << 6 ) | b4 );
}
// process the remaining bytes
b2 = b3 = 0;
if( remaining > 0 ) {
b1 = B64_DecodeByte( srcBytes[srcNdx++] );
if( remaining > 1 )
b2 = B64_DecodeByte( srcBytes[srcNdx++] );
if( remaining == 3 )
b3 = B64_DecodeByte( srcBytes[srcNdx++] );
destBytes[destNdx++] = (byte)( ( b1 << 2 ) | ( b2 >> 4 ) );
if( remaining == 3 )
destBytes[destNdx++] = (byte)( ( b2 << 4 ) | ( b3 >> 2 ) );
}
}
// return the Base-64 encoded char for the given source byte
char B64_EncodeByte( byte b )
{
b &= 0x3f;
if( b <= 25 )
return (byte)( b +'A' );
if( b <= 51 )
return (byte)( b - 26 + 'a' );
if( b <= 61 )
return (byte)( b - 52 + '0' );
if( b == 62 )
return (byte)'-';
return (byte)'_';
}
// return the Base-64 decoded byte for the given source char
// <returns></returns>
byte B64_DecodeByte( byte b )
{
if (( b == '+' ) || (b =='-') )
return 62;
if( (b == '/' ) || (b == '_') )
return 63;
if( b <= '9' )
return (byte)( b - '0' + 52 );
if( b <= 'Z' )
return (byte)( b - 'A' );
return (byte)( b - 'a' + 26 );
}
src/dap_enc_bf.c 0 → 100644
View file @ fb1c4cbf
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <stddef.h>
#include <string.h>
#include "dap_enc_bf.h"
#include "dap_common.h"
#include "rand/dap_rand.h"
#include "sha3/KeccakHash.h"
#define LOG_TAG "dap_enc_blowfish"
void dap_enc_bf_key_generate(struct dap_enc_key * a_key, const void *kex_buf,
size_t kex_size, const void * seed, size_t seed_size, size_t key_size)
{
a_key->last_used_timestamp = time(NULL);
a_key->priv_key_data_size = sizeof(BF_KEY);
a_key->priv_key_data = DAP_NEW_SIZE(uint8_t, sizeof(BF_KEY));
uint8_t *tmp_buf = DAP_NEW_SIZE(uint8_t, (BF_ROUNDS + 2)*4);
Keccak_HashInstance Keccak_ctx;
Keccak_HashInitialize(&Keccak_ctx, 1088, 512, (BF_ROUNDS + 2)*4*8, 0x06);
Keccak_HashUpdate(&Keccak_ctx, kex_buf, kex_size*8);
if(seed_size)
Keccak_HashUpdate(&Keccak_ctx, seed, seed_size*8);
Keccak_HashFinal(&Keccak_ctx, tmp_buf);
BF_set_key(a_key->priv_key_data, (BF_ROUNDS + 2)*4, tmp_buf);
DAP_DELETE(tmp_buf);
}
void dap_enc_bf_key_delete(struct dap_enc_key *a_key)
{
if(a_key->priv_key_data != NULL)
{
randombytes(a_key->priv_key_data,a_key->priv_key_data_size);
DAP_DELETE(a_key->priv_key_data);
}
a_key->priv_key_data_size = 0;
}
//------CBC-----------
size_t dap_enc_bf_cbc_decrypt(struct dap_enc_key *a_key, const void * a_in,
size_t a_in_size, void ** a_out) {
uint8_t iv[8];
//BF_KEY *key=a_key->priv_key_data;
if(a_in_size <= 8 || a_in_size%8) {
log_it(L_ERROR, "blowfish_cbc decryption ct with iv must be more than 8 bytes and equal to 8*k");
return 0;
}
*a_out = DAP_NEW_SIZE(uint8_t, a_in_size - 8);
memcpy(iv, a_in, 8);
BF_cbc_encrypt((unsigned char *)(a_in + 8), *a_out, a_in_size - 8,
a_key->priv_key_data, iv, BF_DECRYPT);
int bf_cbc_padding_length = *(uint8_t*)(*a_out + a_in_size - 8 - 1);
// for(int i=0;i < bf_cbc_padding_length + 4 + 1; ++i)
// printf("%.2x ", *(uint8_t*)(*a_out + a_in_size - 8 - 1 - bf_cbc_padding_length - 4 + i));
// for(int i=0;i < a_in_size - 8; ++i)
// printf("%.2x ", *(uint8_t*)(*a_out + i));
// printf("\n");
// fflush(stdout);
size_t a_out_size = *(uint32_t*)(*a_out + a_in_size - 8 - 1 - bf_cbc_padding_length - 4);
return a_out_size;
}
size_t dap_enc_bf_cbc_encrypt(struct dap_enc_key * a_key, const void * a_in, size_t a_in_size, void ** a_out)
{
//generate iv and put it in *a_out first bytes
uint8_t iv[8];
randombytes(iv, 8);
if(a_in_size <= 0) {
log_it(L_ERROR, "blowfish_cbc encryption pt cannot be 0 bytes");
return 0;
}
// BF_KEY *key = a_key->priv_key_data;
size_t a_out_size = (a_in_size + 4 + 1 + 7)/8*8 + 8;
*a_out = DAP_NEW_SIZE(uint8_t, a_out_size);
memcpy(*a_out, iv, 8);
BF_cbc_encrypt((unsigned char *)(a_in), *a_out + 8, a_in_size,
a_key->priv_key_data, iv, BF_ENCRYPT);
return a_out_size;
}
size_t dap_enc_bf_cbc_calc_encode_size(const size_t size_in)
{
return (size_in + 4 + 1 + 7)/8*8 + 8;
}
size_t dap_enc_bf_cbc_calc_decode_size(const size_t size_in)
{
if(size_in <= 8) {
log_it(L_ERROR, "blowfish_cbc decryption size_in ct with iv must be more than 8 bytes");
return 0;
}
return size_in - 8;
}
size_t dap_enc_bf_cbc_decrypt_fast(struct dap_enc_key *a_key, const void * a_in,
size_t a_in_size, void * a_out, size_t buf_out_size) {
if(a_in_size - 8 > buf_out_size || a_in_size %8) {
log_it(L_ERROR, "blowfish_cbc fast_decryption too small buf_out_size or not 8*k");
return 0;
}
uint8_t iv[8];
//BF_KEY *key=a_key->priv_key_data;
memcpy(iv, a_in, 8);
BF_cbc_encrypt((unsigned char *)(a_in + 8), a_out, a_in_size - 8,
a_key->priv_key_data, iv, BF_DECRYPT);
int bf_cbc_padding_length = *(uint8_t*)(a_out + a_in_size - 8 - 1);
size_t a_out_size = *(uint32_t*)(a_out + a_in_size - 8 - 1 - bf_cbc_padding_length - 4);
return a_out_size;
}
size_t dap_enc_bf_cbc_encrypt_fast(struct dap_enc_key * a_key, const void * a_in, size_t a_in_size, void * a_out,size_t buf_out_size)
{
//generate iv and put it in *a_out first bytes
size_t a_out_size = (a_in_size + 4 + 1 + 7)/8*8 + 8;
if(a_out_size > buf_out_size) {
log_it(L_ERROR, "blowfish_cbc fast_encryption too small buf_out_size");
return 0;
}
uint8_t iv[8];
randombytes(iv, 8);
// BF_KEY *key = a_key->priv_key_data;
memcpy(a_out, iv, 8);
BF_cbc_encrypt((unsigned char *)(a_in), a_out + 8, a_in_size,
a_key->priv_key_data, iv, BF_ENCRYPT);
return a_out_size;
}
void dap_enc_bf_cbc_key_new(struct dap_enc_key * a_key)
{
a_key->_inheritor = NULL;
a_key->_inheritor_size = 0;
a_key->type = DAP_ENC_KEY_TYPE_BF_CBC;
a_key->enc = dap_enc_bf_cbc_encrypt;
a_key->dec = dap_enc_bf_cbc_decrypt;
a_key->enc_na = dap_enc_bf_cbc_encrypt_fast;
a_key->dec_na = dap_enc_bf_cbc_decrypt_fast;
}
//------OFB-----------
size_t dap_enc_bf_ofb_decrypt(struct dap_enc_key *a_key, const void * a_in,
size_t a_in_size, void ** a_out) {
uint8_t iv[8];
if(a_in_size <= 8) {
log_it(L_ERROR, "blowfish_ofb decryption ct with iv must be more than 8 bytes");
return 0;
}
*a_out = DAP_NEW_SIZE(uint8_t, a_in_size - 8);
memcpy(iv, a_in, 8);
int num = 0;//need for concatenate encryptions or decryptions
BF_ofb64_encrypt((unsigned char *)(a_in + 8), *a_out, a_in_size - 8,
a_key->priv_key_data, iv, &num);
size_t a_out_size = a_in_size - 8;
return a_out_size;
}
size_t dap_enc_bf_ofb_encrypt(struct dap_enc_key * a_key, const void * a_in, size_t a_in_size, void ** a_out)
{
//generate iv and put it in *a_out first bytes
uint8_t iv[8];
randombytes(iv, 8);
if(a_in_size <= 0) {
log_it(L_ERROR, "blowfish_ofb encryption pt cannot be 0 bytes");
return 0;
}
size_t a_out_size = a_in_size + 8;
*a_out = DAP_NEW_SIZE(uint8_t, a_out_size);
memcpy(*a_out, iv, 8);
int num = 0;//need for concatenate encryptions or decryptions
BF_ofb64_encrypt((unsigned char *)(a_in), *a_out + 8, a_in_size,
a_key->priv_key_data, iv, &num);
return a_out_size;
}
size_t dap_enc_bf_ofb_calc_encode_size(const size_t size_in)
{
return size_in + 8;
}
size_t dap_enc_bf_ofb_calc_decode_size(const size_t size_in)
{
if(size_in <= 8) {
log_it(L_ERROR, "blowfish_ofb decryption size_in ct with iv must be more than 8 bytes");
return 0;
}
return size_in - 8;
}
size_t dap_enc_bf_ofb_decrypt_fast(struct dap_enc_key *a_key, const void * a_in,
size_t a_in_size, void * a_out, size_t buf_out_size) {
if(a_in_size - 8 > buf_out_size) {
log_it(L_ERROR, "blowfish_ofb fast_decryption too small buf_out_size");
return 0;
}
uint8_t iv[8];
//BF_KEY *key=a_key->priv_key_data;
memcpy(iv, a_in, 8);
int num = 0;//need for concatenate encryptions or decryptions
BF_ofb64_encrypt((unsigned char *)(a_in + 8), a_out, a_in_size - 8,
a_key->priv_key_data, iv, &num);
size_t a_out_size = a_in_size - 8;
return a_out_size;
}
size_t dap_enc_bf_ofb_encrypt_fast(struct dap_enc_key * a_key, const void * a_in, size_t a_in_size, void * a_out,size_t buf_out_size)
{
//generate iv and put it in *a_out first bytes
size_t a_out_size = a_in_size + 8;
if(a_out_size > buf_out_size) {
log_it(L_ERROR, "blowfish_ofb fast_encryption too small buf_out_size");
return 0;
}
uint8_t iv[8];
randombytes(iv, 8);
memcpy(a_out, iv, 8);
int num = 0;//need for concatenate encryptions or decryptions
BF_ofb64_encrypt((unsigned char *)(a_in), a_out + 8, a_in_size,
a_key->priv_key_data, iv, &num);
return a_out_size;
}
void dap_enc_bf_ofb_key_new(struct dap_enc_key * a_key)
{
a_key->_inheritor = NULL;
a_key->_inheritor_size = 0;
a_key->type = DAP_ENC_KEY_TYPE_BF_OFB;
a_key->enc = dap_enc_bf_ofb_encrypt;
a_key->dec = dap_enc_bf_ofb_decrypt;
a_key->enc_na = dap_enc_bf_ofb_encrypt_fast;
a_key->dec_na = dap_enc_bf_ofb_decrypt_fast;
}
src/dap_enc_bliss.c
View file @ fb1c4cbf
#include <stdint.h>
#include <assert.h>
#include <inttypes.h>
#include <string.h>
#include "dap_enc_bliss.h"
#include "dap_common.h"
#include "dap_rand.h"
#include "SimpleFIPS202.h"
#define LOG_TAG "dap_enc_sig_bliss"
static enum DAP_BLISS_SIGN_SECURITY _bliss_type = MAX_SECURITY; // by default
void dap_enc_sig_bliss_set_type(enum DAP_BLISS_SIGN_SECURITY type)
{
_bliss_type = type;
}
void dap_enc_sig_bliss_key_new(struct dap_enc_key *key) {
key->type = DAP_ENC_KEY_TYPE_SIG_BLISS;
key->enc = NULL;
key->gen_bob_shared_key = (dap_enc_gen_bob_shared_key) dap_enc_sig_bliss_get_sign;
key->gen_alice_shared_key = (dap_enc_gen_alice_shared_key) dap_enc_sig_bliss_verify_sign;
}
/**
* @brief dap_enc_sig_bliss_key_pub_output_size
* @param l_key
* @return
*/
size_t dap_enc_sig_bliss_key_pub_output_size(struct dap_enc_key *l_key)
{
(void) l_key;
return sizeof(bliss_public_key_t); // Always same, right?
}
/**
* @brief dap_enc_sig_bliss_key_pub_output
* @param l_key
* @param l_output
* @return
*/
int dap_enc_sig_bliss_key_pub_output(struct dap_enc_key *l_key, void * l_output)
{
int32_t retcode;
retcode = bliss_b_public_key_extract((bliss_public_key_t *) l_output,
(const bliss_private_key_t *) l_key->priv_key_data);
if(retcode != BLISS_B_NO_ERROR) {
log_it(L_CRITICAL, "Can't extract public key from the private one");
return -1;
}
return 0;
}
// generation key pair for sign Alice
// OUTPUT:
// a_key->data --- Alice's public key
// alice_priv --- Alice's private key
// alice_msg_len --- Alice's private key length
void dap_enc_sig_bliss_key_new_generate(struct dap_enc_key * a_key, const void *kex_buf,
size_t kex_size, const void * seed, size_t seed_size,
size_t key_size)
{
(void) kex_buf;
(void) kex_size;
(void) seed;
(void) seed_size;
(void) key_size;
int32_t l_retcode;
dap_enc_sig_bliss_key_new(a_key);
uint8_t seed_tmp[SHA3_512_DIGEST_LENGTH];
entropy_t entropy;
if(seed && seed_size>0){
assert(SHA3_512_DIGEST_LENGTH==64);
SHA3_512((unsigned char *)seed_tmp, (const unsigned char *)seed, seed_size);
}
else
randombytes(&seed_tmp, 64);
entropy_init(&entropy, seed_tmp);
/* type is a param of sign-security
* type = 0 - "toy" version (< 60 bits)
* type = 1 - max speed (128 bits)
* type = 2 - min size (128 bits)
* type = 3 - good speed and good security (160 bits)
* type = 4 - max securiry (192 bits)
*/
//int32_t type = 4;
a_key->priv_key_data_size = sizeof(bliss_private_key_t);
a_key->priv_key_data = DAP_NEW_SIZE(void, a_key->priv_key_data_size);
l_retcode = bliss_b_private_key_gen((bliss_private_key_t *) a_key->priv_key_data, _bliss_type, &entropy);
if(l_retcode != BLISS_B_NO_ERROR) {
bliss_b_private_key_delete(a_key->priv_key_data);
a_key->priv_key_data = NULL;
a_key->priv_key_data_size = 0;
log_it(L_CRITICAL, "Error");
return;
}
a_key->pub_key_data_size = sizeof(bliss_public_key_t);
a_key->pub_key_data = DAP_NEW_SIZE(void, a_key->pub_key_data_size);
l_retcode = bliss_b_public_key_extract((bliss_public_key_t *) a_key->pub_key_data,
(const bliss_private_key_t *) a_key->priv_key_data);
if(l_retcode != BLISS_B_NO_ERROR) {
bliss_b_private_key_delete(a_key->priv_key_data);
bliss_b_public_key_delete(a_key->pub_key_data);
log_it(L_CRITICAL, "Error");
return;
}
}
int dap_enc_sig_bliss_get_sign(struct dap_enc_key * key, const void * msg,
const size_t msg_size, void * signature, const size_t signature_size)
{
if(signature_size < sizeof(bliss_signature_t)) {
log_it(L_ERROR, "bad signature size");
return 0;
}
uint8_t seed_tmp[SHA3_512_DIGEST_LENGTH];
entropy_t entropy;
randombytes(&seed_tmp, 64);
entropy_init(&entropy, seed_tmp);
return bliss_b_sign((bliss_signature_t *) signature,
(const bliss_private_key_t *) key->priv_key_data,
(const uint8_t *) msg,
msg_size,
&entropy);
}
int dap_enc_sig_bliss_verify_sign(struct dap_enc_key * key, const void * msg,
const size_t msg_size, void * signature, const size_t signature_size)
{
if(signature_size < sizeof(bliss_signature_t)) {
log_it(L_ERROR, "bad signature size");
return -1;
}
return bliss_b_verify(signature, key->pub_key_data, msg, msg_size);
}
void dap_enc_sig_bliss_key_delete(struct dap_enc_key *key)
{
if(key->priv_key_data)
bliss_b_private_key_delete(key->priv_key_data);
if(key->pub_key_data)
bliss_b_public_key_delete(key->pub_key_data);
}
/* Serialize a signature */
uint8_t* dap_enc_sig_bliss_write_signature(bliss_signature_t* a_sign, size_t *a_sign_out)
{
bliss_param_t p;
if(!bliss_params_init(&p, a_sign->kind)) {
return NULL ;
}
size_t l_shift_mem = 0;
size_t l_buflen = sizeof(size_t) + sizeof(bliss_kind_t) + p.n * 2 * sizeof(int32_t) + p.kappa * sizeof(int32_t);
uint8_t *l_buf = DAP_NEW_SIZE(uint8_t, l_buflen);
memcpy(l_buf, &l_buflen, sizeof(size_t));
l_shift_mem += sizeof(size_t);
memcpy(l_buf + l_shift_mem, &a_sign->kind, sizeof(bliss_kind_t));
l_shift_mem += sizeof(bliss_kind_t);
memcpy(l_buf + l_shift_mem, a_sign->z1, p.n * sizeof(int32_t));
l_shift_mem += p.n * sizeof(int32_t);
memcpy(l_buf + l_shift_mem, a_sign->z2, p.n * sizeof(int32_t));
l_shift_mem += p.n * sizeof(int32_t);
memcpy(l_buf + l_shift_mem, a_sign->c, p.kappa * sizeof(int32_t));
l_shift_mem += p.kappa * sizeof(int32_t);
if(a_sign_out)
*a_sign_out = l_buflen;
return l_buf;
}
/* Deserialize a signature */
bliss_signature_t* dap_enc_sig_bliss_read_signature(uint8_t *a_buf, size_t a_buflen)
{
if(!a_buf || a_buflen < (sizeof(size_t) + sizeof(bliss_kind_t)))
return NULL ;
bliss_kind_t kind;
size_t l_buflen = 0;
memcpy(&l_buflen, a_buf, sizeof(size_t));
memcpy(&kind, a_buf + sizeof(size_t), sizeof(bliss_kind_t));
if(l_buflen != a_buflen)
return NULL ;
bliss_param_t p;
if(!bliss_params_init(&p, kind))
return NULL ;
bliss_signature_t* l_sign = DAP_NEW(bliss_signature_t);
l_sign->kind = kind;
l_sign->z1 = DAP_NEW_SIZE(int32_t, p.n * sizeof(int32_t));
l_sign->z2 = DAP_NEW_SIZE(int32_t, p.n * sizeof(int32_t));
l_sign->c = DAP_NEW_SIZE(uint32_t, p.kappa * sizeof(int32_t));
size_t l_shift_mem = sizeof(size_t) + sizeof(bliss_kind_t);
memcpy(l_sign->z1, a_buf + l_shift_mem, p.n * sizeof(int32_t));
l_shift_mem += p.n * sizeof(int32_t);
memcpy(l_sign->z2, a_buf + l_shift_mem, p.n * sizeof(int32_t));
l_shift_mem += p.n * sizeof(int32_t);
memcpy(l_sign->c, a_buf + l_shift_mem, p.kappa * sizeof(int32_t));
l_shift_mem += p.kappa * sizeof(int32_t);
return l_sign;
}
/* Serialize a private key. */
uint8_t* dap_enc_sig_bliss_write_private_key(const bliss_private_key_t* a_private_key, size_t *a_buflen_out)
{
bliss_param_t p;
if(!bliss_params_init(&p, a_private_key->kind)) {
return NULL;
}
size_t l_shift_mem = 0;
size_t l_buflen = sizeof(size_t) + sizeof(bliss_kind_t) + 3 * p.n * sizeof(int32_t);
uint8_t *l_buf = DAP_NEW_SIZE(uint8_t, l_buflen);
memcpy(l_buf, &l_buflen, sizeof(size_t));
l_shift_mem += sizeof(size_t);
memcpy(l_buf + l_shift_mem, &a_private_key->kind, sizeof(bliss_kind_t));
l_shift_mem += sizeof(bliss_kind_t);
memcpy(l_buf + l_shift_mem, a_private_key->s1, p.n * sizeof(int32_t));
l_shift_mem += p.n * sizeof(int32_t);
memcpy(l_buf + l_shift_mem, a_private_key->s2, p.n * sizeof(int32_t));
l_shift_mem += p.n * sizeof(int32_t);
memcpy(l_buf + l_shift_mem, a_private_key->a, p.n * sizeof(int32_t));
l_shift_mem += p.n * sizeof(int32_t);
if(a_buflen_out)
*a_buflen_out = l_buflen;
return l_buf;
}
/* Serialize a public key. */
uint8_t* dap_enc_sig_bliss_write_public_key(const bliss_public_key_t* a_public_key, size_t *a_buflen_out)
{
bliss_param_t p;
if(!bliss_params_init(&p, a_public_key->kind)) {
return NULL;
}
size_t l_shift_mem = 0;
size_t l_buflen = sizeof(size_t) + sizeof(bliss_kind_t) + p.n * sizeof(int32_t);
uint8_t *l_buf = DAP_NEW_SIZE(uint8_t, l_buflen);
memcpy(l_buf, &l_buflen, sizeof(size_t));
l_shift_mem += sizeof(size_t);
memcpy(l_buf + l_shift_mem, &a_public_key->kind, sizeof(bliss_kind_t));
l_shift_mem += sizeof(bliss_kind_t);
memcpy(l_buf + l_shift_mem, a_public_key->a, p.n * sizeof(int32_t));
l_shift_mem += p.n * sizeof(int32_t);
if(a_buflen_out)
*a_buflen_out = l_buflen;
return l_buf;
}
/* Deserialize a private key. */
bliss_private_key_t* dap_enc_sig_bliss_read_private_key(uint8_t *a_buf, size_t a_buflen)
{
if(!a_buf || a_buflen < (sizeof(size_t) + sizeof(bliss_kind_t)))
return NULL;
bliss_kind_t kind;
size_t l_buflen = 0;
memcpy(&l_buflen, a_buf, sizeof(size_t));
memcpy(&kind, a_buf + sizeof(size_t), sizeof(bliss_kind_t));
if(l_buflen != a_buflen)
return NULL;
bliss_param_t p;
if(!bliss_params_init(&p, kind))
return NULL;
bliss_private_key_t* l_private_key = DAP_NEW(bliss_private_key_t);
l_private_key->kind = kind;
l_private_key->s1 = DAP_NEW_SIZE(int32_t, p.n * sizeof(int32_t));
l_private_key->s2 = DAP_NEW_SIZE(int32_t, p.n * sizeof(int32_t));
l_private_key->a = DAP_NEW_SIZE(int32_t, p.n * sizeof(int32_t));
size_t l_shift_mem = sizeof(size_t) + sizeof(bliss_kind_t);
memcpy(l_private_key->s1, a_buf + l_shift_mem, p.n * sizeof(int32_t));
l_shift_mem += p.n * sizeof(int32_t);
memcpy(l_private_key->s2, a_buf + l_shift_mem, p.n * sizeof(int32_t));
l_shift_mem += p.n * sizeof(int32_t);
memcpy(l_private_key->a, a_buf + l_shift_mem, p.n * sizeof(int32_t));
l_shift_mem += p.n * sizeof(int32_t);
return l_private_key;
}
/* Deserialize a public key. */
bliss_public_key_t* dap_enc_sig_bliss_read_public_key(const uint8_t *a_buf, size_t a_buflen)
{
if(!a_buf || a_buflen < (sizeof(size_t) + sizeof(bliss_kind_t)))
return NULL;
bliss_kind_t kind;
size_t l_buflen = 0;
memcpy(&l_buflen, a_buf, sizeof(size_t));
memcpy(&kind, a_buf + sizeof(size_t), sizeof(bliss_kind_t));
if(l_buflen != a_buflen)
return NULL;
bliss_param_t p;
if(!bliss_params_init(&p, kind))
return NULL;
bliss_public_key_t* l_public_key = DAP_NEW(bliss_public_key_t);
l_public_key->kind = kind;
l_public_key->a = DAP_NEW_SIZE(int32_t, p.n * sizeof(int32_t));
memcpy(l_public_key->a, a_buf + sizeof(size_t) + sizeof(bliss_kind_t), p.n * sizeof(int32_t));
return l_public_key;
}
#include <stdint.h>
#include <assert.h>
#include <inttypes.h>
#include <string.h>
#include "dap_enc_bliss.h"
#include "dap_common.h"
#include "dap_rand.h"
#include "SimpleFIPS202.h"
#define LOG_TAG "dap_enc_sig_bliss"
static enum DAP_BLISS_SIGN_SECURITY _bliss_type = MAX_SECURITY; // by default
bliss_kind_t _bliss_kind = BLISS_B_4; // same as previous as I expect
void dap_enc_sig_bliss_set_type(enum DAP_BLISS_SIGN_SECURITY type)
{
_bliss_type = type;
}
void dap_enc_sig_bliss_key_new(struct dap_enc_key *key) {
key->type = DAP_ENC_KEY_TYPE_SIG_BLISS;
key->enc = NULL;
key->gen_bob_shared_key = (dap_enc_gen_bob_shared_key) dap_enc_sig_bliss_get_sign;
key->gen_alice_shared_key = (dap_enc_gen_alice_shared_key) dap_enc_sig_bliss_verify_sign;
}
/**
* @brief dap_enc_sig_bliss_key_pub_output_size
* @param l_key
* @return
*/
size_t dap_enc_sig_bliss_key_pub_output_size(struct dap_enc_key *l_key)
{
(void) l_key;
return sizeof(bliss_public_key_t); // Always same, right?
}
/**
* @brief dap_enc_sig_bliss_key_pub_output
* @param l_key
* @param l_output
* @return
*/
int dap_enc_sig_bliss_key_pub_output(struct dap_enc_key *l_key, void * l_output)
{
int32_t retcode;
retcode = bliss_b_public_key_extract((bliss_public_key_t *) l_output,
(const bliss_private_key_t *) l_key->priv_key_data);
if(retcode != BLISS_B_NO_ERROR) {
log_it(L_CRITICAL, "Can't extract public key from the private one");
return -1;
}
return 0;
}
// generation key pair for sign Alice
// OUTPUT:
// a_key->data --- Alice's public key
// alice_priv --- Alice's private key
// alice_msg_len --- Alice's private key length
void dap_enc_sig_bliss_key_new_generate(struct dap_enc_key * a_key, const void *kex_buf,
size_t kex_size, const void * seed, size_t seed_size,
size_t key_size)
{
(void) kex_buf;
(void) kex_size;
(void) seed;
(void) seed_size;
(void) key_size;
int32_t l_retcode;
dap_enc_sig_bliss_key_new(a_key);
uint8_t seed_tmp[SHA3_512_DIGEST_LENGTH];
entropy_t entropy;
if(seed && seed_size>0){
assert(SHA3_512_DIGEST_LENGTH==64);
SHA3_512((unsigned char *)seed_tmp, (const unsigned char *)seed, seed_size);
}
else
randombytes(&seed_tmp, 64);
entropy_init(&entropy, seed_tmp);
/* type is a param of sign-security
* type = 0 - "toy" version (< 60 bits)
* type = 1 - max speed (128 bits)
* type = 2 - min size (128 bits)
* type = 3 - good speed and good security (160 bits)
* type = 4 - max securiry (192 bits)
*/
//int32_t type = 4;
a_key->priv_key_data_size = sizeof(bliss_private_key_t);
a_key->priv_key_data = DAP_NEW_SIZE(void, a_key->priv_key_data_size);
l_retcode = bliss_b_private_key_gen((bliss_private_key_t *) a_key->priv_key_data, _bliss_kind, &entropy);
if(l_retcode != BLISS_B_NO_ERROR) {
bliss_b_private_key_delete(a_key->priv_key_data);
a_key->priv_key_data = NULL;
a_key->priv_key_data_size = 0;
log_it(L_CRITICAL, "Error");
return;
}
a_key->pub_key_data_size = sizeof(bliss_public_key_t);
a_key->pub_key_data = DAP_NEW_SIZE(void, a_key->pub_key_data_size);
l_retcode = bliss_b_public_key_extract((bliss_public_key_t *) a_key->pub_key_data,
(const bliss_private_key_t *) a_key->priv_key_data);
if(l_retcode != BLISS_B_NO_ERROR) {
bliss_b_private_key_delete(a_key->priv_key_data);
bliss_b_public_key_delete(a_key->pub_key_data);
log_it(L_CRITICAL, "Error");
return;
}
}
int dap_enc_sig_bliss_get_sign(struct dap_enc_key * key, const void * msg,
const size_t msg_size, void * signature, const size_t signature_size)
{
if(signature_size < sizeof(bliss_signature_t)) {
log_it(L_ERROR, "bad signature size");
return 0;
}
uint8_t seed_tmp[SHA3_512_DIGEST_LENGTH];
entropy_t entropy;
randombytes(&seed_tmp, 64);
entropy_init(&entropy, seed_tmp);
return bliss_b_sign((bliss_signature_t *) signature,
(const bliss_private_key_t *) key->priv_key_data,
(const uint8_t *) msg,
msg_size,
&entropy);
}
int dap_enc_sig_bliss_verify_sign(struct dap_enc_key * key, const void * msg,
const size_t msg_size, void * signature, const size_t signature_size)
{
if(signature_size < sizeof(bliss_signature_t)) {
log_it(L_ERROR, "bad signature size");
return -1;
}
return bliss_b_verify(signature, key->pub_key_data, msg, msg_size);
}
void dap_enc_sig_bliss_key_delete(struct dap_enc_key *key)
{
if(key->priv_key_data)
bliss_b_private_key_delete(key->priv_key_data);
if(key->pub_key_data)
bliss_b_public_key_delete(key->pub_key_data);
}
/* Serialize a signature */
uint8_t* dap_enc_sig_bliss_write_signature(bliss_signature_t* a_sign, size_t *a_sign_out)
{
bliss_param_t p;
if(!bliss_params_init(&p, a_sign->kind)) {
return NULL ;
}
size_t l_shift_mem = 0;
size_t l_buflen = sizeof(size_t) + sizeof(bliss_kind_t) + p.n * 2 * sizeof(int32_t) + p.kappa * sizeof(int32_t);
uint8_t *l_buf = DAP_NEW_SIZE(uint8_t, l_buflen);
memcpy(l_buf, &l_buflen, sizeof(size_t));
l_shift_mem += sizeof(size_t);
memcpy(l_buf + l_shift_mem, &a_sign->kind, sizeof(bliss_kind_t));
l_shift_mem += sizeof(bliss_kind_t);
memcpy(l_buf + l_shift_mem, a_sign->z1, p.n * sizeof(int32_t));
l_shift_mem += p.n * sizeof(int32_t);
memcpy(l_buf + l_shift_mem, a_sign->z2, p.n * sizeof(int32_t));
l_shift_mem += p.n * sizeof(int32_t);
memcpy(l_buf + l_shift_mem, a_sign->c, p.kappa * sizeof(int32_t));
l_shift_mem += p.kappa * sizeof(int32_t);
if(a_sign_out)
*a_sign_out = l_buflen;
return l_buf;
}
/* Deserialize a signature */
bliss_signature_t* dap_enc_sig_bliss_read_signature(const uint8_t *a_buf, size_t a_buflen)
{
if(!a_buf || a_buflen < (sizeof(size_t) + sizeof(bliss_kind_t)))
return NULL ;
bliss_kind_t kind;
size_t l_buflen = 0;
memcpy(&l_buflen, a_buf, sizeof(size_t));
memcpy(&kind, a_buf + sizeof(size_t), sizeof(bliss_kind_t));
if(l_buflen != a_buflen)
return NULL ;
bliss_param_t p;
if(!bliss_params_init(&p, kind))
return NULL ;
bliss_signature_t* l_sign = DAP_NEW(bliss_signature_t);
l_sign->kind = kind;
l_sign->z1 = DAP_NEW_SIZE(int32_t, p.n * sizeof(int32_t));
l_sign->z2 = DAP_NEW_SIZE(int32_t, p.n * sizeof(int32_t));
l_sign->c = DAP_NEW_SIZE(uint32_t, p.kappa * sizeof(int32_t));
size_t l_shift_mem = sizeof(size_t) + sizeof(bliss_kind_t);
memcpy(l_sign->z1, a_buf + l_shift_mem, p.n * sizeof(int32_t));
l_shift_mem += p.n * sizeof(int32_t);
memcpy(l_sign->z2, a_buf + l_shift_mem, p.n * sizeof(int32_t));
l_shift_mem += p.n * sizeof(int32_t);
memcpy(l_sign->c, a_buf + l_shift_mem, p.kappa * sizeof(int32_t));
l_shift_mem += p.kappa * sizeof(int32_t);
return l_sign;
}
/* Serialize a private key. */
uint8_t* dap_enc_sig_bliss_write_private_key(const bliss_private_key_t* a_private_key, size_t *a_buflen_out)
{
bliss_param_t p;
if(!bliss_params_init(&p, a_private_key->kind)) {
return NULL;
}
size_t l_shift_mem = 0;
size_t l_buflen = sizeof(size_t) + sizeof(bliss_kind_t) + 3 * p.n * sizeof(int32_t);
uint8_t *l_buf = DAP_NEW_SIZE(uint8_t, l_buflen);
memcpy(l_buf, &l_buflen, sizeof(size_t));
l_shift_mem += sizeof(size_t);
memcpy(l_buf + l_shift_mem, &a_private_key->kind, sizeof(bliss_kind_t));
l_shift_mem += sizeof(bliss_kind_t);
memcpy(l_buf + l_shift_mem, a_private_key->s1, p.n * sizeof(int32_t));
l_shift_mem += p.n * sizeof(int32_t);
memcpy(l_buf + l_shift_mem, a_private_key->s2, p.n * sizeof(int32_t));
l_shift_mem += p.n * sizeof(int32_t);
memcpy(l_buf + l_shift_mem, a_private_key->a, p.n * sizeof(int32_t));
l_shift_mem += p.n * sizeof(int32_t);
if(a_buflen_out)
*a_buflen_out = l_buflen;
return l_buf;
}
/* Serialize a public key. */
uint8_t* dap_enc_sig_bliss_write_public_key(const bliss_public_key_t* a_public_key, size_t *a_buflen_out)
{
bliss_param_t p;
if(!bliss_params_init(&p, a_public_key->kind)) {
return NULL;
}
size_t l_shift_mem = 0;
size_t l_buflen = sizeof(size_t) + sizeof(bliss_kind_t) + p.n * sizeof(int32_t);
uint8_t *l_buf = DAP_NEW_SIZE(uint8_t, l_buflen);
memcpy(l_buf, &l_buflen, sizeof(size_t));
l_shift_mem += sizeof(size_t);
memcpy(l_buf + l_shift_mem, &a_public_key->kind, sizeof(bliss_kind_t));
l_shift_mem += sizeof(bliss_kind_t);
memcpy(l_buf + l_shift_mem, a_public_key->a, p.n * sizeof(int32_t));
l_shift_mem += p.n * sizeof(int32_t);
if(a_buflen_out)
*a_buflen_out = l_buflen;
return l_buf;
}
/* Deserialize a private key. */
bliss_private_key_t* dap_enc_sig_bliss_read_private_key(const uint8_t *a_buf, size_t a_buflen)
{
if(!a_buf || a_buflen < (sizeof(size_t) + sizeof(bliss_kind_t)))
return NULL;
bliss_kind_t kind;
size_t l_buflen = 0;
memcpy(&l_buflen, a_buf, sizeof(size_t));
memcpy(&kind, a_buf + sizeof(size_t), sizeof(bliss_kind_t));
if(l_buflen != a_buflen)
return NULL;
bliss_param_t p;
if(!bliss_params_init(&p, kind))
return NULL;
bliss_private_key_t* l_private_key = DAP_NEW(bliss_private_key_t);
l_private_key->kind = kind;
l_private_key->s1 = DAP_NEW_SIZE(int32_t, p.n * sizeof(int32_t));
l_private_key->s2 = DAP_NEW_SIZE(int32_t, p.n * sizeof(int32_t));
l_private_key->a = DAP_NEW_SIZE(int32_t, p.n * sizeof(int32_t));
size_t l_shift_mem = sizeof(size_t) + sizeof(bliss_kind_t);
memcpy(l_private_key->s1, a_buf + l_shift_mem, p.n * sizeof(int32_t));
l_shift_mem += p.n * sizeof(int32_t);
memcpy(l_private_key->s2, a_buf + l_shift_mem, p.n * sizeof(int32_t));
l_shift_mem += p.n * sizeof(int32_t);
memcpy(l_private_key->a, a_buf + l_shift_mem, p.n * sizeof(int32_t));
l_shift_mem += p.n * sizeof(int32_t);
return l_private_key;
}
/* Deserialize a public key. */
bliss_public_key_t* dap_enc_sig_bliss_read_public_key(const uint8_t *a_buf, size_t a_buflen)
{
if(!a_buf || a_buflen < (sizeof(size_t) + sizeof(bliss_kind_t)))
return NULL;
bliss_kind_t kind;
size_t l_buflen = 0;
memcpy(&l_buflen, a_buf, sizeof(size_t));
memcpy(&kind, a_buf + sizeof(size_t), sizeof(bliss_kind_t));
if(l_buflen != a_buflen)
return NULL;
bliss_param_t p;
if(!bliss_params_init(&p, kind))
return NULL;
bliss_public_key_t* l_public_key = DAP_NEW(bliss_public_key_t);
l_public_key->kind = kind;
l_public_key->a = DAP_NEW_SIZE(int32_t, p.n * sizeof(int32_t));
memcpy(l_public_key->a, a_buf + sizeof(size_t) + sizeof(bliss_kind_t), p.n * sizeof(int32_t));
return l_public_key;
}
src/dap_enc_defeo.c
View file @ fb1c4cbf
#include <stdlib.h>
#include <stdio.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <stdbool.h>
#include "dap_enc_defeo.h"
#include "dap_enc_key.h"
#include "dap_common.h"
#include "defeo_config.h"
#include "defeo_scheme/defeo_P768_internal.h"
void dap_enc_defeo_key_new(struct dap_enc_key *a_key) {
a_key->type = DAP_ENC_KEY_TYPE_DEFEO;
a_key->enc = NULL;
a_key->gen_bob_shared_key = (dap_enc_gen_bob_shared_key) dap_enc_defeo_gen_bob_shared_key;
a_key->gen_alice_shared_key = (dap_enc_gen_alice_shared_key) dap_enc_defeo_gen_alice_shared_key;
}
// key pair generation of Alice
// OUTPUT:
// a_key->data --- Alice's public key
// alice_priv --- Alice's private key
// alice_msg_len --- Alice's private key length
void dap_enc_defeo_key_new_generate(struct dap_enc_key * a_key, const void *kex_buf,
size_t kex_size, const void * seed, size_t seed_size,
size_t key_size)
{
(void) kex_buf; (void) kex_size;
(void) seed; (void) seed_size;
(void)key_size;
dap_enc_defeo_key_new(a_key);
a_key->pub_key_data = malloc(DEFEO_PUBLICK_KEY_LEN);
a_key->pub_key_data_size = DEFEO_PUBLICK_KEY_LEN;
if(a_key->pub_key_data == NULL) {
log_it(L_CRITICAL, "Error malloc");
return;
}
a_key->priv_key_data = malloc(DEFEO_SECRET_KEY_LEN);
a_key->priv_key_data_size = DEFEO_SECRET_KEY_LEN;
// generate A key pair
random_mod_order_A((unsigned char *) a_key->priv_key_data);
if(EphemeralKeyGeneration_A((unsigned char *) a_key->priv_key_data, (unsigned char *) a_key->pub_key_data) != 0) {
log_it(L_CRITICAL, "Error malloc");
}
}
void dap_enc_defeo_key_delete(struct dap_enc_key *a_key)
{
(void)a_key;
}
// key pair generation and generation of shared key at Bob's side
// INPUT:
// a_pub --- Alice's public key
// a_pub_size --- Alice's public key length
// OUTPUT:
// b_pub --- Bob's public key
// b_key->data --- shared key
// a_pub_size --- shared key length
size_t dap_enc_defeo_gen_bob_shared_key(struct dap_enc_key *b_key, const void *a_pub,
size_t a_pub_size, void ** b_pub)
{
*b_pub = NULL;
if(a_pub_size != DEFEO_PUBLICK_KEY_LEN) {
return 1;
}
*b_pub = malloc(DEFEO_PUBLICK_KEY_LEN);
if(b_pub == NULL) {
log_it(L_CRITICAL, "Error malloc");
return 2;
}
b_key->priv_key_data = malloc(DEFEO_SHARED_KEY_LEN);
if(b_key->priv_key_data == NULL) {
log_it(L_CRITICAL, "Error malloc");
return 3;
}
uint8_t *bob_priv = malloc(DEFEO_SECRET_KEY_LEN);
// generate Bob's key pair
random_mod_order_B((unsigned char *)bob_priv);
if(EphemeralKeyGeneration_B((unsigned char *) bob_priv, (unsigned char *) b_key->pub_key_data) != 0) {
log_it(L_CRITICAL, "Error malloc");
return 1;
}
// compute Bob's shared secret
if(EphemeralSecretAgreement_B((unsigned char *) bob_priv, (unsigned char *) a_pub,
(unsigned char *) b_key->priv_key_data) != 0) {
log_it(L_CRITICAL, "Error malloc");
return 2;
}
free(bob_priv);
b_key->priv_key_data_size = DEFEO_SHARED_KEY_LEN;
b_key->pub_key_data_size = DEFEO_PUBLICK_KEY_LEN;
return 0;
}
// generation of shared key at Alice's side
// INPUT:
// a_priv --- Alice's private key
// b_pub --- Bob's public key
// OUTPUT:
// a_key->priv_key_data --- shared key
// a_key_len --- shared key length
size_t dap_enc_defeo_gen_alice_shared_key(struct dap_enc_key *a_key, const void *a_priv, size_t b_pub_size, unsigned char *b_pub)
{
size_t ret_val = 0;
if(b_pub_size != DEFEO_PUBLICK_KEY_LEN) {
log_it(L_ERROR, "public key size not equal DEFEO_PUBLICKEYBYTES");
return 1;
}
void *oldkey = NULL;
if(a_key->priv_key_data && a_key->priv_key_data_size > 0)
oldkey = a_key->priv_key_data;
a_key->priv_key_data = malloc(DEFEO_SHARED_KEY_LEN);
if(a_key->priv_key_data == NULL) {
log_it(L_CRITICAL, "Error malloc");
ret_val = 2;
}
if(EphemeralSecretAgreement_A((unsigned char *) a_priv, (unsigned char *) b_pub,
(unsigned char *) a_key->priv_key_data) != 0) {
log_it(L_ERROR, "Error EphemeralSecretAgreement_A");
ret_val = 3;
}
if(oldkey)
free(oldkey);
if(!ret_val)
a_key->priv_key_data_size = DEFEO_SHARED_KEY_LEN;
return ret_val;
}
#include <stdlib.h>
#include <stdio.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <stdbool.h>
#include "dap_enc_defeo.h"
#include "dap_enc_key.h"
#include "dap_common.h"
#include "defeo_config.h"
#include "defeo_scheme/defeo_P768_internal.h"
void dap_enc_defeo_key_new(struct dap_enc_key *a_key) {
a_key->type = DAP_ENC_KEY_TYPE_DEFEO;
a_key->enc = NULL;
a_key->gen_bob_shared_key = (dap_enc_gen_bob_shared_key) dap_enc_defeo_gen_bob_shared_key;
a_key->gen_alice_shared_key = (dap_enc_gen_alice_shared_key) dap_enc_defeo_gen_alice_shared_key;
}
// key pair generation of Alice
// OUTPUT:
// a_key->data --- Alice's public key
// alice_priv --- Alice's private key
// alice_msg_len --- Alice's private key length
void dap_enc_defeo_key_new_generate(struct dap_enc_key * a_key, const void *kex_buf,
size_t kex_size, const void * seed, size_t seed_size,
size_t key_size)
{
(void) kex_buf; (void) kex_size;
(void) seed; (void) seed_size;
(void)key_size;
dap_enc_defeo_key_new(a_key);
a_key->pub_key_data = malloc(DEFEO_PUBLICK_KEY_LEN);
a_key->pub_key_data_size = DEFEO_PUBLICK_KEY_LEN;
if(a_key->pub_key_data == NULL) {
log_it(L_CRITICAL, "Error malloc");
return;
}
a_key->priv_key_data = malloc(DEFEO_SECRET_KEY_LEN);
a_key->priv_key_data_size = DEFEO_SECRET_KEY_LEN;
// generate A key pair
random_mod_order_A((unsigned char *) a_key->priv_key_data);
if(EphemeralKeyGeneration_A((unsigned char *) a_key->priv_key_data, (unsigned char *) a_key->pub_key_data) != 0) {
log_it(L_CRITICAL, "Error malloc");
}
}
void dap_enc_defeo_key_delete(struct dap_enc_key *a_key)
{
(void)a_key;
}
// key pair generation and generation of shared key at Bob's side
// INPUT:
// a_pub --- Alice's public key
// a_pub_size --- Alice's public key length
// OUTPUT:
// b_pub --- Bob's public key
// b_key->data --- shared key
// a_pub_size --- shared key length
size_t dap_enc_defeo_gen_bob_shared_key(struct dap_enc_key *b_key, const void *a_pub,
size_t a_pub_size, void ** b_pub)
{
*b_pub = NULL;
if(a_pub_size != DEFEO_PUBLICK_KEY_LEN) {
return 1;
}
*b_pub = malloc(DEFEO_PUBLICK_KEY_LEN);
if(b_pub == NULL) {
log_it(L_CRITICAL, "Error malloc");
return 2;
}
b_key->priv_key_data = malloc(DEFEO_SHARED_KEY_LEN);
if(b_key->priv_key_data == NULL) {
log_it(L_CRITICAL, "Error malloc");
return 3;
}
uint8_t *bob_priv = malloc(DEFEO_SECRET_KEY_LEN);
// generate Bob's key pair
random_mod_order_B((unsigned char *)bob_priv);
if(EphemeralKeyGeneration_B((unsigned char *) bob_priv, (unsigned char *) b_key->pub_key_data) != 0) {
log_it(L_CRITICAL, "Error malloc");
return 1;
}
// compute Bob's shared secret
if(EphemeralSecretAgreement_B((unsigned char *) bob_priv, (unsigned char *) a_pub,
(unsigned char *) b_key->priv_key_data) != 0) {
log_it(L_CRITICAL, "Error malloc");
return 2;
}
free(bob_priv);
b_key->priv_key_data_size = DEFEO_SHARED_KEY_LEN;
b_key->pub_key_data_size = DEFEO_PUBLICK_KEY_LEN;
return 0;
}
// generation of shared key at Alice's side
// INPUT:
// a_priv --- Alice's private key
// b_pub --- Bob's public key
// OUTPUT:
// a_key->priv_key_data --- shared key
// a_key_len --- shared key length
size_t dap_enc_defeo_gen_alice_shared_key(struct dap_enc_key *a_key, const void *a_priv, size_t b_pub_size, unsigned char *b_pub)
{
size_t ret_val = 0;
if(b_pub_size != DEFEO_PUBLICK_KEY_LEN) {
log_it(L_ERROR, "public key size not equal DEFEO_PUBLICKEYBYTES");
return 1;
}
void *oldkey = NULL;
if(a_key->priv_key_data && a_key->priv_key_data_size > 0)
oldkey = a_key->priv_key_data;
a_key->priv_key_data = malloc(DEFEO_SHARED_KEY_LEN);
if(a_key->priv_key_data == NULL) {
log_it(L_CRITICAL, "Error malloc");
ret_val = 2;
}
if(EphemeralSecretAgreement_A((unsigned char *) a_priv, (unsigned char *) b_pub,
(unsigned char *) a_key->priv_key_data) != 0) {
log_it(L_ERROR, "Error EphemeralSecretAgreement_A");
ret_val = 3;
}
if(oldkey)
free(oldkey);
if(!ret_val)
a_key->priv_key_data_size = DEFEO_SHARED_KEY_LEN;
return ret_val;
}
src/dap_enc_dilithium.c
View file @ fb1c4cbf
#include <assert.h>
#include <inttypes.h>
#include <string.h>
#include "dap_enc_dilithium.h"
#include "dap_common.h"
#include "dap_rand.h"
#define LOG_TAG "dap_enc_sig_dilithium"
static enum DAP_DILITHIUM_SIGN_SECURITY _dilithium_type = DILITHIUM_MIN_SIZE; // by default
void dap_enc_sig_dilithium_set_type(enum DAP_DILITHIUM_SIGN_SECURITY type)
{
_dilithium_type = type;
}
void dap_enc_sig_dilithium_key_new(struct dap_enc_key *key) {
key->type = DAP_ENC_KEY_TYPE_SIG_DILITHIUM;
key->enc = NULL;
key->enc_na = (dap_enc_callback_dataop_na_t) dap_enc_sig_dilithium_get_sign;
key->dec_na = (dap_enc_callback_dataop_na_t) dap_enc_sig_dilithium_verify_sign;
// key->gen_bob_shared_key = (dap_enc_gen_bob_shared_key) dap_enc_sig_dilithium_get_sign;
// key->gen_alice_shared_key = (dap_enc_gen_alice_shared_key) dap_enc_sig_dilithium_verify_sign;
}
// generation key pair for sign Alice
// OUTPUT:
// a_key->data --- Alice's public key
// alice_priv --- Alice's private key
// alice_msg_len --- Alice's private key length
void dap_enc_sig_dilithium_key_new_generate(struct dap_enc_key * key, const void *kex_buf,
size_t kex_size, const void * seed, size_t seed_size,
size_t key_size)
{
(void) kex_buf;
(void) kex_size;
(void) key_size;
int32_t retcode;
int dilithium_type = (seed && seed_size >= sizeof(uint8_t)) ? ((uint8_t*)seed)[0] % (DILITHIUM_MAX_SECURITY + 1) :
DILITHIUM_MIN_SIZE;
dap_enc_sig_dilithium_set_type(dilithium_type);
//int32_t type = 2;
key->priv_key_data_size = sizeof(dilithium_private_key_t);
key->pub_key_data_size = sizeof(dilithium_public_key_t);
key->priv_key_data = malloc(key->priv_key_data_size);
key->pub_key_data = malloc(key->pub_key_data_size);
retcode = dilithium_crypto_sign_keypair((dilithium_public_key_t *) key->pub_key_data,
(dilithium_private_key_t *) key->priv_key_data, _dilithium_type, seed, seed_size);
if(retcode != 0) {
dilithium_private_and_public_keys_delete((dilithium_private_key_t *) key->pub_key_data,
(dilithium_public_key_t *) key->pub_key_data);
log_it(L_CRITICAL, "Error");
return;
}
}
size_t dap_enc_sig_dilithium_get_sign(struct dap_enc_key * key, const void * msg,
const size_t msg_size, void * signature, const size_t signature_size)
{
if(signature_size < sizeof(dilithium_signature_t)) {
log_it(L_ERROR, "bad signature size");
return 0;
}
if(!dilithium_crypto_sign((dilithium_signature_t *) signature, (const unsigned char *) msg, msg_size, key->priv_key_data))
return signature_size;
else
return 0;
}
size_t dap_enc_sig_dilithium_verify_sign(struct dap_enc_key * key, const void * msg,
const size_t msg_size, void * signature, const size_t signature_size)
{
if(signature_size < sizeof(dilithium_signature_t)) {
log_it(L_ERROR, "bad signature size");
return 0;
}
return (dilithium_crypto_sign_open( (unsigned char *) msg, msg_size, (dilithium_signature_t *) signature, key->pub_key_data));
}
void dap_enc_sig_dilithium_key_delete(struct dap_enc_key * key)
{
if( key->priv_key_data && key->pub_key_data)
dilithium_private_and_public_keys_delete((dilithium_private_key_t *) key->priv_key_data,
(dilithium_public_key_t *) key->pub_key_data);
else if ( key->pub_key_data )
dilithium_public_key_delete((dilithium_public_key_t *) key->pub_key_data);
else if ( key->priv_key_data )
dilithium_public_key_delete((dilithium_public_key_t *) key->priv_key_data);
}
size_t dap_enc_dilithium_calc_signature_unserialized_size(void)
{
return sizeof(dilithium_signature_t);
}
/* Serialize a signature */
uint8_t* dap_enc_dilithium_write_signature(dilithium_signature_t* a_sign, size_t *a_sign_out)
{
if(!a_sign ) {
return NULL ;
}
size_t l_shift_mem = 0;
size_t l_buflen = dap_enc_dilithium_calc_signagture_size(a_sign);
uint8_t *l_buf = DAP_NEW_SIZE(uint8_t, l_buflen);
memcpy(l_buf, &l_buflen, sizeof(size_t));
l_shift_mem += sizeof(size_t);
memcpy(l_buf + l_shift_mem, &a_sign->kind, sizeof(dilithium_kind_t));
l_shift_mem += sizeof(dilithium_kind_t);
memcpy(l_buf + l_shift_mem, &a_sign->sig_len, sizeof(unsigned long long));
l_shift_mem += sizeof(unsigned long long);
memcpy(l_buf + l_shift_mem, a_sign->sig_data, a_sign->sig_len );
l_shift_mem += a_sign->sig_len ;
if(a_sign_out)
*a_sign_out = l_buflen;
return l_buf;
}
/* Deserialize a signature */
dilithium_signature_t* dap_enc_dilithium_read_signature(uint8_t *a_buf, size_t a_buflen)
{
if(!a_buf || a_buflen < (sizeof(size_t) + sizeof(dilithium_kind_t)))
return NULL ;
dilithium_kind_t kind;
size_t l_buflen = 0;
memcpy(&l_buflen, a_buf, sizeof(size_t));
memcpy(&kind, a_buf + sizeof(size_t), sizeof(dilithium_kind_t));
if(l_buflen != a_buflen)
return NULL ;
dilithium_param_t p;
if(!dilithium_params_init(&p, kind))
return NULL ;
dilithium_signature_t* l_sign = DAP_NEW(dilithium_signature_t);
l_sign->kind = kind;
size_t l_shift_mem = sizeof(size_t) + sizeof(dilithium_kind_t);
memcpy(&l_sign->sig_len, a_buf + l_shift_mem, sizeof(unsigned long long));
l_shift_mem += sizeof(unsigned long long);
l_sign->sig_data = DAP_NEW_SIZE(unsigned char, l_sign->sig_len);
memcpy(l_sign->sig_data, a_buf + l_shift_mem, l_sign->sig_len);
l_shift_mem += l_sign->sig_len;
return l_sign;
}
/* Serialize a private key. */
uint8_t* dap_enc_dilithium_write_private_key(const dilithium_private_key_t* a_private_key, size_t *a_buflen_out)
{
dilithium_param_t p;// = malloc(sizeof(dilithium_param_t));
if(!dilithium_params_init(&p, a_private_key->kind))
return NULL;
size_t l_buflen = sizeof(size_t) + sizeof(dilithium_kind_t) + p.CRYPTO_SECRETKEYBYTES; //CRYPTO_PUBLICKEYBYTES;
uint8_t *l_buf = DAP_NEW_SIZE(uint8_t, l_buflen);
memcpy(l_buf, &l_buflen, sizeof(size_t));
memcpy(l_buf + sizeof(size_t), &a_private_key->kind, sizeof(dilithium_kind_t));
memcpy(l_buf + sizeof(size_t) + sizeof(dilithium_kind_t), a_private_key->data, p.CRYPTO_SECRETKEYBYTES);
if(a_buflen_out)
*a_buflen_out = l_buflen;
return l_buf;
}
/* Serialize a public key. */
uint8_t* dap_enc_dilithium_write_public_key(const dilithium_public_key_t* a_public_key, size_t *a_buflen_out)
{
dilithium_param_t p;
if(!dilithium_params_init(&p, a_public_key->kind))
return NULL;
size_t l_buflen = sizeof(size_t) + sizeof(dilithium_kind_t) + p.CRYPTO_PUBLICKEYBYTES;
uint8_t *l_buf = DAP_NEW_SIZE(uint8_t, l_buflen);
memcpy(l_buf, &l_buflen, sizeof(size_t));
memcpy(l_buf + sizeof(size_t), &a_public_key->kind, sizeof(dilithium_kind_t));
memcpy(l_buf + sizeof(size_t) + sizeof(dilithium_kind_t), a_public_key->data, p.CRYPTO_PUBLICKEYBYTES);
if(a_buflen_out)
*a_buflen_out = l_buflen;
return l_buf;
}
/* Deserialize a private key. */
dilithium_private_key_t* dap_enc_dilithium_read_private_key(const uint8_t *a_buf, size_t a_buflen)
{
if(!a_buf || a_buflen < (sizeof(size_t) + sizeof(dilithium_kind_t)))
return NULL;
dilithium_kind_t kind;
size_t l_buflen = 0;
memcpy(&l_buflen, a_buf, sizeof(size_t));
memcpy(&kind, a_buf + sizeof(size_t), sizeof(dilithium_kind_t));
if(l_buflen != a_buflen)
return NULL;
dilithium_param_t p;
if(!dilithium_params_init(&p, kind))
return NULL;
dilithium_private_key_t* l_private_key = DAP_NEW(dilithium_private_key_t);
l_private_key->kind = kind;
l_private_key->data = DAP_NEW_SIZE(unsigned char, p.CRYPTO_SECRETKEYBYTES);
memcpy(l_private_key->data, a_buf + sizeof(size_t) + sizeof(dilithium_kind_t), p.CRYPTO_SECRETKEYBYTES);
return l_private_key;
}
/* Deserialize a public key. */
dilithium_public_key_t* dap_enc_dilithium_read_public_key(const uint8_t *a_buf, size_t a_buflen)
{
if(!a_buf || a_buflen < (sizeof(size_t) + sizeof(dilithium_kind_t)))
return NULL;
dilithium_kind_t kind;
size_t l_buflen = 0;
memcpy(&l_buflen, a_buf, sizeof(size_t));
memcpy(&kind, a_buf + sizeof(size_t), sizeof(dilithium_kind_t));
if(l_buflen != a_buflen)
return NULL;
dilithium_param_t p;
if(!dilithium_params_init(&p, kind))
return NULL;
dilithium_public_key_t* l_public_key = DAP_NEW_Z(dilithium_public_key_t);
l_public_key->kind = kind;
l_public_key->data = DAP_NEW_Z_SIZE(unsigned char, p.CRYPTO_PUBLICKEYBYTES);
memcpy(l_public_key->data, a_buf + sizeof(size_t) + sizeof(dilithium_kind_t), p.CRYPTO_PUBLICKEYBYTES);
return l_public_key;
}
#include <assert.h>
#include <inttypes.h>
#include <string.h>
#include "dap_enc_dilithium.h"
#include "dap_common.h"
#include "dap_rand.h"
#define LOG_TAG "dap_enc_sig_dilithium"
static enum DAP_DILITHIUM_SIGN_SECURITY _dilithium_type = DILITHIUM_MIN_SIZE; // by default
void dap_enc_sig_dilithium_set_type(enum DAP_DILITHIUM_SIGN_SECURITY type)
{
_dilithium_type = type;
}
void dap_enc_sig_dilithium_key_new(struct dap_enc_key *key) {
key->type = DAP_ENC_KEY_TYPE_SIG_DILITHIUM;
key->enc = NULL;
key->enc_na = (dap_enc_callback_dataop_na_t) dap_enc_sig_dilithium_get_sign;
key->dec_na = (dap_enc_callback_dataop_na_t) dap_enc_sig_dilithium_verify_sign;
// key->gen_bob_shared_key = (dap_enc_gen_bob_shared_key) dap_enc_sig_dilithium_get_sign;
// key->gen_alice_shared_key = (dap_enc_gen_alice_shared_key) dap_enc_sig_dilithium_verify_sign;
}
// generation key pair for sign Alice
// OUTPUT:
// a_key->data --- Alice's public key
// alice_priv --- Alice's private key
// alice_msg_len --- Alice's private key length
void dap_enc_sig_dilithium_key_new_generate(struct dap_enc_key * key, const void *kex_buf,
size_t kex_size, const void * seed, size_t seed_size,
size_t key_size)
{
(void) kex_buf;
(void) kex_size;
(void) key_size;
int32_t retcode;
int dilithium_type = (seed && seed_size >= sizeof(uint8_t)) ? ((uint8_t*)seed)[0] % (DILITHIUM_MAX_SECURITY + 1) :
DILITHIUM_MIN_SIZE;
dap_enc_sig_dilithium_set_type(dilithium_type);
//int32_t type = 2;
key->priv_key_data_size = sizeof(dilithium_private_key_t);
key->pub_key_data_size = sizeof(dilithium_public_key_t);
key->priv_key_data = malloc(key->priv_key_data_size);
key->pub_key_data = malloc(key->pub_key_data_size);
retcode = dilithium_crypto_sign_keypair((dilithium_public_key_t *) key->pub_key_data,
(dilithium_private_key_t *) key->priv_key_data, _dilithium_type, seed, seed_size);
if(retcode != 0) {
dilithium_private_and_public_keys_delete((dilithium_private_key_t *) key->pub_key_data,
(dilithium_public_key_t *) key->pub_key_data);
log_it(L_CRITICAL, "Error");
return;
}
}
size_t dap_enc_sig_dilithium_get_sign(struct dap_enc_key * key, const void * msg,
const size_t msg_size, void * signature, const size_t signature_size)
{
if(signature_size < sizeof(dilithium_signature_t)) {
log_it(L_ERROR, "bad signature size");
return 0;
}
if(!dilithium_crypto_sign((dilithium_signature_t *) signature, (const unsigned char *) msg, msg_size, key->priv_key_data))
return signature_size;
else
return 0;
}
size_t dap_enc_sig_dilithium_verify_sign(struct dap_enc_key * key, const void * msg,
const size_t msg_size, void * signature, const size_t signature_size)
{
if(signature_size < sizeof(dilithium_signature_t)) {
log_it(L_ERROR, "bad signature size");
return 0;
}
return (dilithium_crypto_sign_open( (unsigned char *) msg, msg_size, (dilithium_signature_t *) signature, key->pub_key_data));
}
void dap_enc_sig_dilithium_key_delete(struct dap_enc_key * key)
{
if( key->priv_key_data && key->pub_key_data)
dilithium_private_and_public_keys_delete((dilithium_private_key_t *) key->priv_key_data,
(dilithium_public_key_t *) key->pub_key_data);
else if ( key->pub_key_data )
dilithium_public_key_delete((dilithium_public_key_t *) key->pub_key_data);
else if ( key->priv_key_data )
dilithium_public_key_delete((dilithium_public_key_t *) key->priv_key_data);
}
size_t dap_enc_dilithium_calc_signature_unserialized_size(void)
{
return sizeof(dilithium_signature_t);
}
/* Serialize a signature */
uint8_t* dap_enc_dilithium_write_signature(dilithium_signature_t* a_sign, size_t *a_sign_out)
{
if(!a_sign ) {
return NULL ;
}
size_t l_shift_mem = 0;
size_t l_buflen = dap_enc_dilithium_calc_signagture_size(a_sign);
uint8_t *l_buf = DAP_NEW_SIZE(uint8_t, l_buflen);
memcpy(l_buf, &l_buflen, sizeof(size_t));
l_shift_mem += sizeof(size_t);
memcpy(l_buf + l_shift_mem, &a_sign->kind, sizeof(dilithium_kind_t));
l_shift_mem += sizeof(dilithium_kind_t);
memcpy(l_buf + l_shift_mem, &a_sign->sig_len, sizeof(unsigned long long));
l_shift_mem += sizeof(unsigned long long);
memcpy(l_buf + l_shift_mem, a_sign->sig_data, a_sign->sig_len );
l_shift_mem += a_sign->sig_len ;
if(a_sign_out)
*a_sign_out = l_buflen;
return l_buf;
}
/* Deserialize a signature */
dilithium_signature_t* dap_enc_dilithium_read_signature(uint8_t *a_buf, size_t a_buflen)
{
if( !a_buf || (a_buflen < (sizeof(size_t) + sizeof(dilithium_kind_t)) ) )
return NULL ;
dilithium_kind_t kind;
size_t l_buflen_internal = 0;
memcpy(&l_buflen_internal, a_buf, sizeof(size_t));
memcpy(&kind, a_buf + sizeof(size_t), sizeof(dilithium_kind_t));
if(l_buflen_internal != a_buflen)
return NULL ;
dilithium_param_t p;
if(!dilithium_params_init(&p, kind))
return NULL ;
dilithium_signature_t* l_sign = DAP_NEW(dilithium_signature_t);
l_sign->kind = kind;
size_t l_shift_mem = sizeof(size_t) + sizeof(dilithium_kind_t);
memcpy(&l_sign->sig_len, a_buf + l_shift_mem, sizeof(unsigned long long));
l_shift_mem += sizeof(unsigned long long);
l_sign->sig_data = DAP_NEW_SIZE(unsigned char, l_sign->sig_len);
memcpy(l_sign->sig_data, a_buf + l_shift_mem, l_sign->sig_len);
l_shift_mem += l_sign->sig_len;
return l_sign;
}
/* Serialize a private key. */
uint8_t* dap_enc_dilithium_write_private_key(const dilithium_private_key_t* a_private_key, size_t *a_buflen_out)
{
dilithium_param_t p;// = malloc(sizeof(dilithium_param_t));
if(!dilithium_params_init(&p, a_private_key->kind))
return NULL;
size_t l_buflen = sizeof(size_t) + sizeof(dilithium_kind_t) + p.CRYPTO_SECRETKEYBYTES; //CRYPTO_PUBLICKEYBYTES;
uint8_t *l_buf = DAP_NEW_SIZE(uint8_t, l_buflen);
memcpy(l_buf, &l_buflen, sizeof(size_t));
memcpy(l_buf + sizeof(size_t), &a_private_key->kind, sizeof(dilithium_kind_t));
memcpy(l_buf + sizeof(size_t) + sizeof(dilithium_kind_t), a_private_key->data, p.CRYPTO_SECRETKEYBYTES);
if(a_buflen_out)
*a_buflen_out = l_buflen;
return l_buf;
}
/* Serialize a public key. */
uint8_t* dap_enc_dilithium_write_public_key(const dilithium_public_key_t* a_public_key, size_t *a_buflen_out)
{
dilithium_param_t p;
if(!dilithium_params_init(&p, a_public_key->kind))
return NULL;
size_t l_buflen = sizeof(size_t) + sizeof(dilithium_kind_t) + p.CRYPTO_PUBLICKEYBYTES;
uint8_t *l_buf = DAP_NEW_SIZE(uint8_t, l_buflen);
memcpy(l_buf, &l_buflen, sizeof(size_t));
memcpy(l_buf + sizeof(size_t), &a_public_key->kind, sizeof(dilithium_kind_t));
memcpy(l_buf + sizeof(size_t) + sizeof(dilithium_kind_t), a_public_key->data, p.CRYPTO_PUBLICKEYBYTES);
if(a_buflen_out)
*a_buflen_out = l_buflen;
return l_buf;
}
/* Deserialize a private key. */
dilithium_private_key_t* dap_enc_dilithium_read_private_key(const uint8_t *a_buf, size_t a_buflen)
{
if(!a_buf || a_buflen < (sizeof(size_t) + sizeof(dilithium_kind_t)))
return NULL;
dilithium_kind_t kind;
size_t l_buflen = 0;
memcpy(&l_buflen, a_buf, sizeof(size_t));
memcpy(&kind, a_buf + sizeof(size_t), sizeof(dilithium_kind_t));
if(l_buflen != a_buflen)
return NULL;
dilithium_param_t p;
if(!dilithium_params_init(&p, kind))
return NULL;
dilithium_private_key_t* l_private_key = DAP_NEW(dilithium_private_key_t);
l_private_key->kind = kind;
l_private_key->data = DAP_NEW_SIZE(unsigned char, p.CRYPTO_SECRETKEYBYTES);
memcpy(l_private_key->data, a_buf + sizeof(size_t) + sizeof(dilithium_kind_t), p.CRYPTO_SECRETKEYBYTES);
return l_private_key;
}
/* Deserialize a public key. */
dilithium_public_key_t* dap_enc_dilithium_read_public_key(const uint8_t *a_buf, size_t a_buflen)
{
if(!a_buf || a_buflen < (sizeof(size_t) + sizeof(dilithium_kind_t)))
return NULL;
dilithium_kind_t kind;
size_t l_buflen = 0;
memcpy(&l_buflen, a_buf, sizeof(size_t));
memcpy(&kind, a_buf + sizeof(size_t), sizeof(dilithium_kind_t));
if(l_buflen != a_buflen)
return NULL;
dilithium_param_t p;
if(!dilithium_params_init(&p, kind))
return NULL;
dilithium_public_key_t* l_public_key = DAP_NEW_Z(dilithium_public_key_t);
l_public_key->kind = kind;
l_public_key->data = DAP_NEW_Z_SIZE(unsigned char, p.CRYPTO_PUBLICKEYBYTES);
memcpy(l_public_key->data, a_buf + sizeof(size_t) + sizeof(dilithium_kind_t), p.CRYPTO_PUBLICKEYBYTES);
return l_public_key;
}
src/dap_enc_iaes.c
View file @ fb1c4cbf
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "dap_enc_key.h"
#include "dap_enc_iaes.h"
#include "sha3/fips202.h"
//#include "KeccakHash.h"
//#include "SimpleFIPS202.h"
#include "dap_common.h"
#define LOG_TAG "dap_enc_aes"
typedef struct dap_enc_aes_key {
unsigned char ivec[IAES_BLOCK_SIZE];
} dap_enc_aes_key_t;
#define DAP_ENC_AES_KEY(a) ((dap_enc_aes_key_t *)((a)->_inheritor) )
void dap_enc_aes_key_delete(struct dap_enc_key *a_key)
{
free(a_key->_inheritor);
//No need any specific actions
}
/**
* @brief dap_enc_aes_key_new_generate
* @param a_key
* @param a_size
*/
void dap_enc_aes_key_new(struct dap_enc_key * a_key)
{
a_key->_inheritor = DAP_NEW_Z(dap_enc_aes_key_t);
a_key->_inheritor_size = sizeof (dap_enc_aes_key_t);
a_key->type = DAP_ENC_KEY_TYPE_IAES;
a_key->enc = dap_enc_iaes256_cbc_encrypt;
a_key->dec = dap_enc_iaes256_cbc_decrypt;
a_key->enc_na = dap_enc_iaes256_cbc_encrypt_fast;
a_key->dec_na = dap_enc_iaes256_cbc_decrypt_fast;
//a_key->delete_callback = dap_enc_aes_key_delete;
a_key->priv_key_data = (uint8_t *)malloc(IAES_KEYSIZE);
a_key->priv_key_data_size = IAES_KEYSIZE;
}
void dap_enc_aes_key_generate(struct dap_enc_key * a_key, const void *kex_buf,
size_t kex_size, const void * seed, size_t seed_size,
size_t key_size)
{
(void)key_size;
a_key->last_used_timestamp = time(NULL);
uint8_t * id_concat_kex = (uint8_t *) malloc(kex_size + seed_size);
memcpy(id_concat_kex,seed, seed_size);
memcpy(id_concat_kex + seed_size, kex_buf, kex_size);
//SHAKE256(a_key->priv_key_data, IAES_KEYSIZE, id_concat_kex, (kex_size + seed_size));
//SHAKE128(DAP_ENC_AES_KEY(a_key)->ivec, IAES_BLOCK_SIZE, seed, seed_size);
shake256(a_key->priv_key_data, IAES_KEYSIZE, id_concat_kex, (kex_size + seed_size));
shake128(DAP_ENC_AES_KEY(a_key)->ivec, IAES_BLOCK_SIZE, seed, seed_size);
free(id_concat_kex);
}
/**
* @brief ap_enc_aes256_cbc_decrypt
* @param a_key
* @param a_in
* @param a_in_size
* @param a_out
* @return
*/
size_t dap_enc_iaes256_cbc_decrypt(struct dap_enc_key * a_key, const void * a_in, size_t a_in_size, void ** a_out)
{
if (a_in_size % 16) {
log_it(L_ERROR, "Bad in data size");
return 0;
}
*a_out = (uint8_t *) malloc(a_in_size);
return IAES_256_CBC_decrypt(a_in, *a_out, DAP_ENC_AES_KEY(a_key)->ivec, a_in_size, a_key->priv_key_data);
}
size_t dap_enc_iaes256_cbc_decrypt_fast(struct dap_enc_key * a_key, const void * a_in,
size_t a_in_size, void * buf_out, size_t buf_out_size)
{
if (a_in_size % 16) {
log_it(L_ERROR, "Bad in size");
return 0;
} else if(buf_out_size < a_in_size) {
log_it(L_ERROR, "buf_out_size < a_in_size");
return 0;
}
return IAES_256_CBC_decrypt(a_in, buf_out, DAP_ENC_AES_KEY(a_key)->ivec,
a_in_size, a_key->priv_key_data);
}
size_t dap_enc_iaes256_cbc_encrypt(struct dap_enc_key * a_key, const void * a_in, size_t a_in_size, void ** a_out)
{
size_t length_data_new;
uint8_t *data_new;
length_data_new = iaes_block128_padding(a_in, &data_new, a_in_size);
*a_out = (uint8_t *)malloc(length_data_new);
IAES_256_CBC_encrypt(data_new, *a_out, DAP_ENC_AES_KEY(a_key)->ivec, length_data_new, a_key->priv_key_data);
free(data_new);
return length_data_new;
}
size_t dap_enc_iaes256_calc_encode_size(const size_t size_in)
{
return iaes_calc_block128_size(size_in);
}
size_t dap_enc_iaes256_calc_decode_size(const size_t size_in)
{
return size_in;
}
size_t dap_enc_iaes256_cbc_encrypt_fast(struct dap_enc_key * a_key, const void * a_in,
size_t a_in_size, void * buf_out, size_t buf_out_size)
{
size_t out_size = iaes_calc_block128_size(a_in_size);
if((a_in_size % IAES_BLOCK_SIZE) == 0) {
IAES_256_CBC_encrypt(a_in, buf_out, DAP_ENC_AES_KEY(a_key)->ivec, out_size, a_key->priv_key_data);
return out_size;
}
if(buf_out_size < out_size) {
log_it(L_ERROR, "buf_out_size less than expected encrypt out size data");
return 0;
}
uint8_t* data_in_new;
iaes_block128_padding(a_in, &data_in_new, a_in_size);
IAES_256_CBC_encrypt(data_in_new, buf_out, DAP_ENC_AES_KEY(a_key)->ivec,
out_size, a_key->priv_key_data);
free(data_in_new);
return out_size;
}
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "dap_enc_key.h"
#include "dap_enc_iaes.h"
#include "sha3/fips202.h"
//#include "KeccakHash.h"
//#include "SimpleFIPS202.h"
#include "dap_common.h"
#define LOG_TAG "dap_enc_aes"
typedef struct dap_enc_aes_key {
unsigned char ivec[IAES_BLOCK_SIZE];
} dap_enc_aes_key_t;
#define DAP_ENC_AES_KEY(a) ((dap_enc_aes_key_t *)((a)->_inheritor) )
void dap_enc_aes_key_delete(struct dap_enc_key *a_key)
{
free(a_key->_inheritor);
//No need any specific actions
}
/**
* @brief dap_enc_aes_key_new_generate
* @param a_key
* @param a_size
*/
void dap_enc_aes_key_new(struct dap_enc_key * a_key)
{
a_key->_inheritor = DAP_NEW_Z(dap_enc_aes_key_t);
a_key->_inheritor_size = sizeof (dap_enc_aes_key_t);
a_key->type = DAP_ENC_KEY_TYPE_IAES;
a_key->enc = dap_enc_iaes256_cbc_encrypt;
a_key->dec = dap_enc_iaes256_cbc_decrypt;
a_key->enc_na = dap_enc_iaes256_cbc_encrypt_fast;
a_key->dec_na = dap_enc_iaes256_cbc_decrypt_fast;
//a_key->delete_callback = dap_enc_aes_key_delete;
a_key->priv_key_data = (uint8_t *)malloc(IAES_KEYSIZE);
a_key->priv_key_data_size = IAES_KEYSIZE;
}
void dap_enc_aes_key_generate(struct dap_enc_key * a_key, const void *kex_buf,
size_t kex_size, const void * seed, size_t seed_size,
size_t key_size)
{
(void)key_size;
a_key->last_used_timestamp = time(NULL);
uint8_t * id_concat_kex = (uint8_t *) malloc(kex_size + seed_size);
memcpy(id_concat_kex,seed, seed_size);
memcpy(id_concat_kex + seed_size, kex_buf, kex_size);
//SHAKE256(a_key->priv_key_data, IAES_KEYSIZE, id_concat_kex, (kex_size + seed_size));
//SHAKE128(DAP_ENC_AES_KEY(a_key)->ivec, IAES_BLOCK_SIZE, seed, seed_size);
shake256(a_key->priv_key_data, IAES_KEYSIZE, id_concat_kex, (kex_size + seed_size));
shake128(DAP_ENC_AES_KEY(a_key)->ivec, IAES_BLOCK_SIZE, seed, seed_size);
free(id_concat_kex);
}
/**
* @brief ap_enc_aes256_cbc_decrypt
* @param a_key
* @param a_in
* @param a_in_size
* @param a_out
* @return
*/
size_t dap_enc_iaes256_cbc_decrypt(struct dap_enc_key * a_key, const void * a_in, size_t a_in_size, void ** a_out)
{
if (a_in_size % 16) {
log_it(L_ERROR, "Bad in data size");
return 0;
}
*a_out = (uint8_t *) malloc(a_in_size);
return dap_enc_iaes256_cbc_decrypt_fast(a_key, a_in, a_in_size, *a_out, a_in_size);
}
size_t dap_enc_iaes256_cbc_decrypt_fast(struct dap_enc_key * a_key, const void * a_in,
size_t a_in_size, void * buf_out, size_t buf_out_size)
{
if (a_in_size % IAES_BLOCK_SIZE) {
log_it(L_ERROR, "Bad in size");
return 0;
} else if(buf_out_size < a_in_size) {
log_it(L_ERROR, "buf_out_size < a_in_size");
return 0;
}
size_t block_in32_size = IAES_BLOCK_SIZE/sizeof(uint32_t);
uint32_t round_decrypt_key[60];
uint32_t feedback[block_in32_size];
memcpy(&feedback[0], DAP_ENC_AES_KEY(a_key)->ivec, IAES_BLOCK_SIZE);
swap_endian((uint32_t *)a_key->priv_key_data, IAES_KEYSIZE/sizeof(uint32_t));
Key_Shedule_for_decrypT((uint32_t *)a_key->priv_key_data, round_decrypt_key);
void *data = buf_out;
const void *cdata = a_in;
size_t count_block, count32_word;
for(count_block = 0; count_block < (a_in_size/IAES_BLOCK_SIZE); count_block++){
AES256_dec_cernelT((uint32_t *)cdata + count_block*block_in32_size,
(uint32_t *)data + count_block*block_in32_size, round_decrypt_key);
for (count32_word = 0; count32_word < block_in32_size; count32_word++)
*((uint32_t *)data + count_block * block_in32_size + count32_word) ^= feedback[count32_word];
memcpy(&feedback[0], (uint32_t *)cdata + count_block*block_in32_size, IAES_BLOCK_SIZE);
}
// for(int i = 0; i < 16; ++i)
// {printf("%.2x ", ((uint8_t*)data)[i]);}
// printf("\n");fflush(stdout);
swap_endian((uint32_t *)a_key->priv_key_data, IAES_KEYSIZE/sizeof(uint32_t));
return a_in_size - ((uint8_t *)data)[a_in_size - 1];
}
size_t dap_enc_iaes256_cbc_encrypt(struct dap_enc_key * a_key, const void * a_in, size_t a_in_size, void ** a_out)
{
size_t length_data_new;
length_data_new = dap_enc_iaes256_calc_encode_size(a_in_size);
*a_out = DAP_NEW_SIZE(uint8_t, length_data_new);
dap_enc_iaes256_cbc_encrypt_fast(a_key, a_in, a_in_size, *a_out, length_data_new);
return length_data_new;
}
size_t dap_enc_iaes256_calc_encode_size(const size_t size_in)
{
return size_in + 1 + (IAES_BLOCK_SIZE - (size_in + 1)%IAES_BLOCK_SIZE)%IAES_BLOCK_SIZE;
}
size_t dap_enc_iaes256_calc_decode_max_size(const size_t size_in)
{
return size_in;
}
size_t dap_enc_iaes256_cbc_encrypt_fast(struct dap_enc_key * a_key, const void * a_in,
size_t a_in_size, void * buf_out, size_t buf_out_size)
{
size_t out_size = dap_enc_iaes256_calc_encode_size(a_in_size);
if(buf_out_size < out_size) {
log_it(L_ERROR, "buf_out_size less than expected encrypt out size data");
return 0;
}
int last_block_from_in = a_in_size%IAES_BLOCK_SIZE;
size_t block_in32_size = IAES_BLOCK_SIZE/sizeof(uint32_t);
uint32_t feedback[block_in32_size];
memcpy(&feedback[0], DAP_ENC_AES_KEY(a_key)->ivec, IAES_BLOCK_SIZE);
swap_endian((uint32_t *)a_key->priv_key_data, IAES_KEYSIZE/sizeof(uint32_t));
size_t count_block, count32_word;
const void *data = a_in;
void *cdata = buf_out;
for(count_block = 0; count_block < (a_in_size - last_block_from_in)/IAES_BLOCK_SIZE; count_block++)
{
for (count32_word = 0; count32_word < block_in32_size; count32_word++)
*((uint32_t *)cdata + count_block * block_in32_size + count32_word) =
*((uint32_t *)data + count_block * block_in32_size + count32_word) ^ feedback[count32_word];
AES256_enc_cernelT(((uint32_t *)cdata + count_block * block_in32_size), feedback, (uint32_t *)a_key->priv_key_data);
memcpy ((uint32_t *)cdata + count_block * block_in32_size, &feedback[0], IAES_BLOCK_SIZE);
}
uint8_t tmp_in[IAES_BLOCK_SIZE];
memcpy(tmp_in, a_in + a_in_size/IAES_BLOCK_SIZE*IAES_BLOCK_SIZE, last_block_from_in);
int padd_size = IAES_BLOCK_SIZE - last_block_from_in;
for(int padd_num = 0; padd_num < padd_size - 1; ++padd_num)
tmp_in[last_block_from_in + padd_num] = 16;
tmp_in[IAES_BLOCK_SIZE - 1] = padd_size;
for (count32_word = 0; count32_word < block_in32_size; count32_word++)
*((uint32_t *)cdata + count_block * block_in32_size + count32_word) =
*((uint32_t *)tmp_in + count32_word) ^ feedback[count32_word];
AES256_enc_cernelT(((uint32_t *)cdata + count_block * block_in32_size), feedback, (uint32_t *)a_key->priv_key_data);
memcpy ((uint32_t *)cdata + count_block * block_in32_size, &feedback[0], IAES_BLOCK_SIZE);
swap_endian((uint32_t *)a_key->priv_key_data,IAES_KEYSIZE/sizeof(uint32_t));
// IAES_256_CBC_encrypt(a_in, buf_out, DAP_ENC_AES_KEY(a_key)->ivec, a_in_size - last_block_from_in, a_key->priv_key_data);
// uint8_t tmp_in[IAES_BLOCK_SIZE];
// memcpy(tmp_in, a_in + a_in_size/IAES_BLOCK_SIZE*IAES_BLOCK_SIZE, last_block_from_in);
// int padd_size = IAES_BLOCK_SIZE - last_block_from_in;
// for(int padd_num = 0; padd_num < padd_size; ++padd_num)
// tmp_in[last_block_from_in + padd_num] = 16;
// tmp_in[last_block_from_in + IAES_BLOCK_SIZE - 1] = padd_size;
// IAES_256_CBC_encrypt(tmp_in, buf_out + a_in_size - last_block_from_in, buf_out + a_in_size - last_block_from_in - IAES_BLOCK_SIZE, IAES_BLOCK_SIZE, a_key->priv_key_data);
return out_size;
}
src/dap_enc_key.c
View file @ fb1c4cbf
/*
Copyright (c) 2017-2018 (c) Project "DeM Labs Inc" https://github.com/demlabsinc
All rights reserved.
This file is part of DAP (Deus Applications Prototypes) the open source project
DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
DAP is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with any DAP based project. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdlib.h>
#include <string.h>
#include "dap_common.h"
#include "dap_enc_iaes.h"
#include "dap_enc_oaes.h"
#include "dap_enc_msrln.h"
#include "dap_enc_defeo.h"
#include "dap_enc_picnic.h"
#include "dap_enc_bliss.h"
#include "dap_enc_tesla.h"
#include "dap_enc_dilithium.h"
#include "dap_enc_key.h"
#undef LOG_TAG
#define LOG_TAG "dap_enc_key"
struct dap_enc_key_callbacks{
const char * name;
dap_enc_callback_dataop_t enc;
dap_enc_callback_dataop_t dec;
dap_enc_callback_dataop_na_t enc_na;
dap_enc_callback_dataop_na_t dec_na;
dap_enc_callback_sign_op_t sign_get;
dap_enc_callback_sign_op_t sign_verify;
dap_enc_callback_gen_key_public_t gen_key_public;
dap_enc_callback_key_size_t gen_key_public_size;
dap_enc_callback_calc_out_size enc_out_size;
dap_enc_callback_calc_out_size dec_out_size;
dap_enc_gen_bob_shared_key gen_bob_shared_key;
dap_enc_gen_alice_shared_key gen_alice_shared_key;
dap_enc_callback_new new_callback;
dap_enc_callback_data_t new_from_data_public_callback;
dap_enc_callback_new_generate new_generate_callback;
dap_enc_callback_delete delete_callback;
} s_callbacks[]={
// AES
[DAP_ENC_KEY_TYPE_IAES]={
.name = "IAES",
.enc = dap_enc_iaes256_cbc_encrypt,
.enc_na = dap_enc_iaes256_cbc_encrypt_fast ,
.dec = dap_enc_iaes256_cbc_decrypt,
.dec_na = dap_enc_iaes256_cbc_decrypt_fast ,
.new_callback = dap_enc_aes_key_new,
.delete_callback = dap_enc_aes_key_delete,
.new_generate_callback = dap_enc_aes_key_generate,
.gen_key_public = NULL,
.gen_key_public_size = NULL,
.enc_out_size = dap_enc_iaes256_calc_encode_size,
.dec_out_size = dap_enc_iaes256_calc_decode_size,
.sign_get = NULL,
.sign_verify = NULL
},
// OAES
[DAP_ENC_KEY_TYPE_OAES]={
.name = "OAES",
.enc = dap_enc_oaes_encrypt,
.enc_na = dap_enc_oaes_encrypt_fast ,
.dec = dap_enc_oaes_decrypt,
.dec_na = dap_enc_oaes_decrypt_fast ,
.new_callback = dap_enc_oaes_key_new,
.delete_callback = dap_enc_oaes_key_delete,
.new_generate_callback = dap_enc_oaes_key_generate,
.gen_key_public = NULL,
.gen_key_public_size = NULL,
.enc_out_size = dap_enc_oaes_calc_encode_size,
.dec_out_size = dap_enc_oaes_calc_decode_size,
.sign_get = NULL,
.sign_verify = NULL
},
[DAP_ENC_KEY_TYPE_MSRLN] = {
.name = "MSRLN",
.enc = NULL,
.dec = NULL,
.new_callback = dap_enc_msrln_key_new,
.delete_callback = dap_enc_msrln_key_delete,
.new_generate_callback = dap_enc_msrln_key_generate,
.gen_bob_shared_key = dap_enc_msrln_gen_bob_shared_key,
.gen_alice_shared_key = dap_enc_msrln_gen_alice_shared_key,
.gen_key_public = NULL,
.gen_key_public_size = NULL,
.new_from_data_public_callback = dap_enc_msrln_key_new_from_data_public,
.enc_out_size = NULL,
.dec_out_size = NULL,
.sign_get = NULL,
.sign_verify = NULL
},
[DAP_ENC_KEY_TYPE_DEFEO]={
.name = "DEFEO",
.enc = NULL,
.dec = NULL,
.gen_key_public = NULL,
.gen_key_public_size = NULL,
.gen_bob_shared_key = dap_enc_defeo_gen_bob_shared_key,
.gen_alice_shared_key = dap_enc_defeo_gen_alice_shared_key,
.new_callback = dap_enc_defeo_key_new,
.delete_callback = dap_enc_defeo_key_delete,
.new_generate_callback = dap_enc_defeo_key_new_generate,
.enc_out_size = NULL,
.dec_out_size = NULL,
.sign_get = NULL,
.sign_verify = NULL
},
[DAP_ENC_KEY_TYPE_SIG_PICNIC]={
.name = "PICNIC",
.enc = NULL,
.dec = NULL,
.enc_na = dap_enc_sig_picnic_get_sign, // dap_enc_picnic_enc_na
.dec_na = dap_enc_sig_picnic_verify_sign,// dap_enc_picnic_dec_na
.gen_bob_shared_key = NULL,
.gen_alice_shared_key = NULL,
.new_callback = dap_enc_sig_picnic_key_new,
.gen_key_public = NULL,
.gen_key_public_size = dap_enc_picnic_calc_signature_size,
.delete_callback = dap_enc_sig_picnic_key_delete,
.new_generate_callback = dap_enc_sig_picnic_key_new_generate,
.enc_out_size = NULL,
.dec_out_size = NULL,
.sign_get = NULL,
.sign_verify = NULL
},
[DAP_ENC_KEY_TYPE_SIG_BLISS]={
.name = "SIG_BLISS",
.enc = NULL,
.dec = NULL,
.enc_na = NULL,
.dec_na = NULL,
.sign_get = dap_enc_sig_bliss_get_sign,
.sign_verify = dap_enc_sig_bliss_verify_sign,
.gen_bob_shared_key = NULL,
.gen_alice_shared_key = NULL,
.new_callback = dap_enc_sig_bliss_key_new,
.delete_callback = dap_enc_sig_bliss_key_delete,
.new_generate_callback = dap_enc_sig_bliss_key_new_generate,
.gen_key_public = dap_enc_sig_bliss_key_pub_output,
.gen_key_public_size = dap_enc_sig_bliss_key_pub_output_size,
.enc_out_size = NULL,
.dec_out_size = NULL
},
[DAP_ENC_KEY_TYPE_SIG_TESLA]={
.name = "SIG_TESLA",
.enc = NULL,
.dec = NULL,
.enc_na = dap_enc_sig_tesla_get_sign,
.dec_na = dap_enc_sig_tesla_verify_sign,
.gen_key_public = NULL,
.gen_key_public_size = NULL,
.gen_bob_shared_key = NULL,
.gen_alice_shared_key = NULL,
.new_callback = dap_enc_sig_tesla_key_new,
.delete_callback = dap_enc_sig_tesla_key_delete,
.new_generate_callback = dap_enc_sig_tesla_key_new_generate,
.enc_out_size = NULL,
.dec_out_size = NULL,
.sign_get = NULL,
.sign_verify = NULL
},
[DAP_ENC_KEY_TYPE_SIG_DILITHIUM]={
.name = "SIG_DILITHIUM",
.enc = NULL,
.dec = NULL,
.enc_na = dap_enc_sig_dilithium_get_sign,
.dec_na = dap_enc_sig_dilithium_verify_sign,
.gen_key_public = NULL,
.gen_key_public_size = NULL,
.gen_bob_shared_key = NULL,
.gen_alice_shared_key = NULL,
.new_callback = dap_enc_sig_dilithium_key_new,
.delete_callback = dap_enc_sig_dilithium_key_delete,
.new_generate_callback = dap_enc_sig_dilithium_key_new_generate,
.enc_out_size = NULL,
.dec_out_size = NULL,
.sign_get = NULL,
.sign_verify = NULL
}
};
const size_t c_callbacks_size = sizeof(s_callbacks) / sizeof(s_callbacks[0]);
/**
* @brief dap_enc_key_init
* @return
*/
int dap_enc_key_init()
{
return 0;
}
/**
* @brief dap_enc_key_deinit
*/
void dap_enc_key_deinit()
{
}
/**
* @brief dap_enc_key_serealize_sign
*
* @param a_key_type
* @param a_sign
* @param a_sign_len [in/out]
* @return allocates memory with private key
*/
uint8_t* dap_enc_key_serealize_sign(dap_enc_key_type_t a_key_type, uint8_t *a_sign, size_t *a_sign_len)
{
uint8_t *data = NULL;
switch (a_key_type) {
case DAP_ENC_KEY_TYPE_SIG_BLISS:
data = dap_enc_sig_bliss_write_signature((bliss_signature_t*)a_sign, a_sign_len);
break;
case DAP_ENC_KEY_TYPE_SIG_TESLA:
data = dap_enc_tesla_write_signature((tesla_signature_t*)a_sign, a_sign_len);
break;
case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
data = dap_enc_dilithium_write_signature((dilithium_signature_t*)a_sign, a_sign_len);
break;
default:
data = DAP_NEW_Z_SIZE(uint8_t, *a_sign_len);
memcpy(data, a_sign, *a_sign_len);
}
return data;
}
/**
* @brief dap_enc_key_serealize_sign
*
* @param a_key_type
* @param a_sign
* @param a_sign_len [in/out]
* @return allocates memory with private key
*/
uint8_t* dap_enc_key_deserealize_sign(dap_enc_key_type_t a_key_type, uint8_t *a_sign, size_t *a_sign_len)
{
uint8_t *data = NULL;
switch (a_key_type) {
case DAP_ENC_KEY_TYPE_SIG_BLISS:
data = (uint8_t*)dap_enc_sig_bliss_read_signature(a_sign, *a_sign_len);
*a_sign_len = sizeof(bliss_signature_t);
break;
case DAP_ENC_KEY_TYPE_SIG_TESLA:
data = (uint8_t*)dap_enc_tesla_read_signature(a_sign, *a_sign_len);
*a_sign_len = sizeof(tesla_signature_t);
break;
case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
data = (uint8_t*)dap_enc_dilithium_read_signature(a_sign, *a_sign_len);
*a_sign_len = sizeof(dilithium_signature_t);
break;
default:
data = DAP_NEW_Z_SIZE(uint8_t, *a_sign_len);
memcpy(data, a_sign, *a_sign_len);
}
return data;
}
/**
* @brief dap_enc_key_serealize_priv_key
*
* @param a_key
* @param a_buflen_out
* @return allocates memory with private key
*/
uint8_t* dap_enc_key_serealize_priv_key(dap_enc_key_t *a_key, size_t *a_buflen_out)
{
uint8_t *data = NULL;
switch (a_key->type) {
case DAP_ENC_KEY_TYPE_SIG_BLISS:
data = dap_enc_sig_bliss_write_private_key(a_key->priv_key_data, a_buflen_out);
break;
case DAP_ENC_KEY_TYPE_SIG_TESLA:
data = dap_enc_tesla_write_private_key(a_key->priv_key_data, a_buflen_out);
break;
case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
data = dap_enc_dilithium_write_private_key(a_key->priv_key_data, a_buflen_out);
break;
default:
data = DAP_NEW_Z_SIZE(uint8_t, a_key->priv_key_data_size);
memcpy(data, a_key->priv_key_data, a_key->priv_key_data_size);
if(a_buflen_out)
*a_buflen_out = a_key->priv_key_data_size;
}
return data;
}
/**
* @brief dap_enc_key_serealize_pub_key
*
* @param a_key
* @param a_buflen_out
* @return allocates memory with private key
*/
uint8_t* dap_enc_key_serealize_pub_key(dap_enc_key_t *a_key, size_t *a_buflen_out)
{
uint8_t *data = NULL;
switch (a_key->type) {
case DAP_ENC_KEY_TYPE_SIG_BLISS:
data = dap_enc_sig_bliss_write_public_key(a_key->pub_key_data, a_buflen_out);
break;
case DAP_ENC_KEY_TYPE_SIG_TESLA:
data = dap_enc_tesla_write_public_key(a_key->pub_key_data, a_buflen_out);
break;
case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
data = dap_enc_dilithium_write_public_key(a_key->pub_key_data, a_buflen_out);
break;
default:
data = DAP_NEW_Z_SIZE(uint8_t, a_key->pub_key_data_size);
memcpy(data, a_key->pub_key_data, a_key->pub_key_data_size);
if(a_buflen_out)
*a_buflen_out = a_key->pub_key_data_size;
}
return data;
}
/**
* @brief dap_enc_key_deserealize_priv_key
*
* @param a_key
* @param a_buf
* @param a_buflen_out
* @return 0 Ok, -1 error
*/
int dap_enc_key_deserealize_priv_key(dap_enc_key_t *a_key, uint8_t *a_buf, size_t a_buflen)
{
if(!a_key || !a_buf)
return -1;
switch (a_key->type) {
case DAP_ENC_KEY_TYPE_SIG_BLISS:
if((a_key->priv_key_data)) {
bliss_b_private_key_delete((bliss_private_key_t *) a_key->priv_key_data);
DAP_DELETE(a_key->pub_key_data);
}
a_key->priv_key_data = (uint8_t*) dap_enc_sig_bliss_read_private_key(a_buf, a_buflen);
if(!a_key->priv_key_data)
{
a_key->priv_key_data_size = 0;
return -1;
}
a_key->priv_key_data_size = sizeof(bliss_private_key_t);
break;
case DAP_ENC_KEY_TYPE_SIG_TESLA:
tesla_private_key_delete((tesla_private_key_t *) a_key->priv_key_data);
a_key->priv_key_data = (uint8_t*) dap_enc_tesla_read_private_key(a_buf, a_buflen);
if(!a_key->priv_key_data)
{
a_key->priv_key_data_size = 0;
return -1;
}
a_key->priv_key_data_size = sizeof(tesla_private_key_t);
break;
case DAP_ENC_KEY_TYPE_SIG_PICNIC:
DAP_DELETE(a_key->priv_key_data);
a_key->priv_key_data_size = a_buflen;
a_key->priv_key_data = DAP_NEW_Z_SIZE(uint8_t, a_key->priv_key_data_size);
memcpy(a_key->priv_key_data, a_buf, a_key->priv_key_data_size);
dap_enc_sig_picnic_update(a_key);
break;
case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
dilithium_private_key_delete((dilithium_private_key_t *) a_key->priv_key_data);
a_key->priv_key_data = (uint8_t*) dap_enc_dilithium_read_private_key(a_buf, a_buflen);
if(!a_key->priv_key_data)
{
a_key->priv_key_data_size = 0;
return -1;
}
a_key->priv_key_data_size = sizeof(dilithium_private_key_t);
break;
default:
DAP_DELETE(a_key->priv_key_data);
a_key->priv_key_data_size = a_buflen;
a_key->priv_key_data = DAP_NEW_Z_SIZE(uint8_t, a_key->priv_key_data_size);
memcpy(a_key->priv_key_data, a_buf, a_key->priv_key_data_size);
}
return 0;
}
/**
* @brief dap_enc_key_deserealize_pub_key
*
* @param a_key
* @param a_buf
* @param a_buflen_out
* @return 0 Ok, -1 error
*/
int dap_enc_key_deserealize_pub_key(dap_enc_key_t *a_key, const uint8_t *a_buf, size_t a_buflen)
{
if(!a_key || !a_buf)
return -1;
switch (a_key->type) {
case DAP_ENC_KEY_TYPE_SIG_BLISS:
if((a_key->pub_key_data)) {
bliss_b_public_key_delete((bliss_public_key_t *) a_key->pub_key_data);
DAP_DELETE(a_key->pub_key_data);
}
a_key->pub_key_data = (uint8_t*) dap_enc_sig_bliss_read_public_key(a_buf, a_buflen);
if(!a_key->pub_key_data)
{
a_key->pub_key_data_size = 0;
return -1;
}
a_key->pub_key_data_size = sizeof(bliss_public_key_t);
break;
case DAP_ENC_KEY_TYPE_SIG_TESLA:
tesla_public_key_delete((tesla_public_key_t *) a_key->pub_key_data);
a_key->pub_key_data = (uint8_t*) dap_enc_tesla_read_public_key(a_buf, a_buflen);
if(!a_key->pub_key_data)
{
a_key->pub_key_data_size = 0;
return -1;
}
a_key->pub_key_data_size = sizeof(tesla_public_key_t);
break;
case DAP_ENC_KEY_TYPE_SIG_PICNIC:
DAP_DELETE(a_key->pub_key_data);
a_key->pub_key_data_size = a_buflen;
a_key->pub_key_data = DAP_NEW_Z_SIZE(uint8_t, a_key->pub_key_data_size);
memcpy(a_key->pub_key_data, a_buf, a_key->pub_key_data_size);
dap_enc_sig_picnic_update(a_key);
break;
case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
if ( a_key->pub_key_data )
dilithium_public_key_delete((dilithium_public_key_t *) a_key->pub_key_data);
a_key->pub_key_data = (uint8_t*) dap_enc_dilithium_read_public_key(a_buf, a_buflen);
if(!a_key->pub_key_data)
{
a_key->pub_key_data_size = 0;
return -1;
}
a_key->pub_key_data_size = sizeof(dilithium_public_key_t);
break;
default:
DAP_DELETE(a_key->pub_key_data);
a_key->pub_key_data_size = a_buflen;
a_key->pub_key_data = DAP_NEW_Z_SIZE(uint8_t, a_key->pub_key_data_size);
memcpy(a_key->pub_key_data, a_buf, a_key->pub_key_data_size);
}
return 0;
}
/**
* @brief dap_enc_key_serealize
* @param key
* @return allocates dap_enc_key_serealize_t* dont remember use free()
*/
dap_enc_key_serealize_t* dap_enc_key_serealize(dap_enc_key_t * key)
{
dap_enc_key_serealize_t *result = DAP_NEW_Z(dap_enc_key_serealize_t);
result->priv_key_data_size = key->priv_key_data_size;
result->pub_key_data_size = key->pub_key_data_size;
result->last_used_timestamp = key->last_used_timestamp;
result->inheritor_size = key->_inheritor_size;
result->type = key->type;
memcpy(result->priv_key_data, key->priv_key_data, key->priv_key_data_size);
memcpy(result->pub_key_data, key->pub_key_data, key->pub_key_data_size);
memcpy(result->inheritor, key->_inheritor, key->_inheritor_size);
return result;
}
/**
* @brief dap_enc_key_deserealize
* @param buf
* @param buf_size
* @return allocates dap_enc_key_t*. Use dap_enc_key_delete for free memory
*/
dap_enc_key_t* dap_enc_key_deserealize(const void *buf, size_t buf_size)
{
if(buf_size != sizeof (dap_enc_key_serealize_t)) {
log_it(L_ERROR, "Key can't be deserealize. buf_size != sizeof (dap_enc_key_serealize_t)");
return NULL;
}
const dap_enc_key_serealize_t *in_key = (const dap_enc_key_serealize_t *)buf;
dap_enc_key_t *result = dap_enc_key_new(in_key->type);
result->last_used_timestamp = in_key->last_used_timestamp;
result->priv_key_data_size = in_key->priv_key_data_size;
result->pub_key_data_size = in_key->pub_key_data_size;
result->_inheritor_size = in_key->inheritor_size;
memcpy(result->priv_key_data, in_key->priv_key_data, result->priv_key_data_size);
memcpy(result->pub_key_data, in_key->pub_key_data, result->pub_key_data_size);
if(in_key->inheritor_size)
memcpy(result->_inheritor, in_key->inheritor, in_key->inheritor_size);
else
result->_inheritor = NULL;
return result;
}
/**
* @brief dap_enc_key_new
* @param a_key_type
* @return
*/
dap_enc_key_t *dap_enc_key_new(dap_enc_key_type_t a_key_type)
{
dap_enc_key_t * ret = NULL;
if(a_key_type < c_callbacks_size ){
ret = DAP_NEW_Z(dap_enc_key_t);
if(s_callbacks[a_key_type].new_callback){
s_callbacks[a_key_type].new_callback(ret);
}
}
ret->type = a_key_type;
return ret;
}
/**
* @brief dap_enc_key_new_generate
* @param a_key_type
* @param kex_buf
* @param kex_size
* @param seed
* @param seed_size
* @param key_size - can be NULL ( generate size by default )
* @return
*/
dap_enc_key_t *dap_enc_key_new_generate(dap_enc_key_type_t a_key_type, const void *kex_buf,
size_t kex_size, const void* seed,
size_t seed_size, size_t key_size)
{
dap_enc_key_t * ret = NULL;
if(a_key_type< c_callbacks_size ) {
ret = dap_enc_key_new(a_key_type);
if(s_callbacks[a_key_type].new_generate_callback) {
s_callbacks[a_key_type].new_generate_callback( ret, kex_buf, kex_size, seed, seed_size, key_size);
}
}
return ret;
}
/**
* @brief dap_enc_key_update
* @param a_key_type
* @return
*/
void dap_enc_key_update(dap_enc_key_t *a_key)
{
if(a_key)
switch (a_key->type) {
case DAP_ENC_KEY_TYPE_SIG_TESLA:
break;
case DAP_ENC_KEY_TYPE_SIG_PICNIC:
dap_enc_sig_picnic_update(a_key);
break;
case DAP_ENC_KEY_TYPE_SIG_BLISS:
break;
case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
break;
default:
break;
}
}
size_t dap_enc_gen_key_public_size (dap_enc_key_t *a_key)
{
if(s_callbacks[a_key->type].gen_key_public_size) {
return s_callbacks[a_key->type].gen_key_public_size(a_key);
} else {
log_it(L_ERROR, "No callback for key public size calculate");
return 0;
}
}
int dap_enc_gen_key_public (dap_enc_key_t *a_key, void * a_output)
{
if(s_callbacks[a_key->type].gen_key_public) {
return s_callbacks[a_key->type].gen_key_public(a_key,a_output);
} else {
log_it(L_ERROR, "No callback for key public generate action");
}
return -1;
}
/**
* @brief dap_enc_key_delete
* @param a_key
*/
void dap_enc_key_signature_delete(dap_enc_key_type_t a_key_type, uint8_t *a_sig_buf)
{
switch (a_key_type) {
case DAP_ENC_KEY_TYPE_SIG_BLISS:
bliss_signature_delete((bliss_signature_t*)a_sig_buf);
break;
case DAP_ENC_KEY_TYPE_SIG_TESLA:
tesla_signature_delete((tesla_signature_t*)a_sig_buf);
break;
case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
dilithium_signature_delete((dilithium_signature_t*)a_sig_buf);
break;
default:
break;
}
DAP_DELETE(a_sig_buf);
}
/**
* @brief dap_enc_key_delete
* @param a_key
*/
void dap_enc_key_delete(dap_enc_key_t * a_key)
{
if(s_callbacks[a_key->type].delete_callback) {
s_callbacks[a_key->type].delete_callback(a_key);
} else {
log_it(L_ERROR, "delete callback is null. Can be leak memory!");
}
/* a_key->_inheritor must be cleaned in delete_callback func */
if ( a_key->pub_key_data)
DAP_DELETE(a_key->pub_key_data);
if (a_key->priv_key_data )
DAP_DELETE(a_key->priv_key_data);
DAP_DELETE(a_key);
}
size_t dap_enc_key_get_enc_size(dap_enc_key_t * a_key, const size_t buf_in_size)
{
if(s_callbacks[a_key->type].enc_out_size) {
return s_callbacks[a_key->type].enc_out_size(buf_in_size);
}
log_it(L_ERROR, "enc_out_size not realize for current key type");
return 0;
}
size_t dap_enc_key_get_dec_size(dap_enc_key_t * a_key, const size_t buf_in_size)
{
if(s_callbacks[a_key->type].dec_out_size) {
return s_callbacks[a_key->type].dec_out_size(buf_in_size);
}
log_it(L_ERROR, "dec_out_size not realize for current key type");
return 0;
}
/*
Copyright (c) 2017-2018 (c) Project "DeM Labs Inc" https://github.com/demlabsinc
All rights reserved.
This file is part of DAP (Deus Applications Prototypes) the open source project
DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
DAP is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with any DAP based project. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdlib.h>
#include <string.h>
#include "dap_common.h"
#include "dap_enc_iaes.h"
#include "dap_enc_oaes.h"
#include "dap_enc_bf.h"
#include "dap_enc_GOST.h"
//#include "dap_enc_salsa2012.h"
#include "dap_enc_msrln.h"
#include "dap_enc_defeo.h"
#include "dap_enc_picnic.h"
#include "dap_enc_bliss.h"
#include "dap_enc_tesla.h"
#include "dap_enc_dilithium.h"
#include "dap_enc_ringct20.h"
#include "dap_enc_key.h"
#undef LOG_TAG
#define LOG_TAG "dap_enc_key"
struct dap_enc_key_callbacks{
const char * name;
dap_enc_callback_dataop_t enc;
dap_enc_callback_dataop_t dec;
dap_enc_callback_dataop_na_t enc_na;
dap_enc_callback_dataop_na_t dec_na;
dap_enc_callback_dataop_na_ext_t dec_na_ext;
dap_enc_callback_sign_op_t sign_get;
dap_enc_callback_sign_op_t sign_verify;
dap_enc_callback_gen_key_public_t gen_key_public;
dap_enc_callback_key_size_t gen_key_public_size;
dap_enc_callback_calc_out_size enc_out_size;
dap_enc_callback_calc_out_size dec_out_size;
dap_enc_gen_bob_shared_key gen_bob_shared_key;
dap_enc_gen_alice_shared_key gen_alice_shared_key;
dap_enc_callback_new new_callback;
dap_enc_callback_data_t new_from_data_public_callback;
dap_enc_callback_new_generate new_generate_callback;
dap_enc_callback_delete delete_callback;
} s_callbacks[]={
// AES
[DAP_ENC_KEY_TYPE_IAES]={
.name = "IAES",
.enc = dap_enc_iaes256_cbc_encrypt,
.enc_na = dap_enc_iaes256_cbc_encrypt_fast ,
.dec = dap_enc_iaes256_cbc_decrypt,
.dec_na = dap_enc_iaes256_cbc_decrypt_fast ,
.new_callback = dap_enc_aes_key_new,
.delete_callback = dap_enc_aes_key_delete,
.new_generate_callback = dap_enc_aes_key_generate,
.gen_key_public = NULL,
.gen_key_public_size = NULL,
.enc_out_size = dap_enc_iaes256_calc_encode_size,
.dec_out_size = dap_enc_iaes256_calc_decode_max_size,
.sign_get = NULL,
.sign_verify = NULL
},
// OAES
[DAP_ENC_KEY_TYPE_OAES]={
.name = "OAES",
.enc = dap_enc_oaes_encrypt,
.enc_na = dap_enc_oaes_encrypt_fast ,
.dec = dap_enc_oaes_decrypt,
.dec_na = dap_enc_oaes_decrypt_fast ,
.new_callback = dap_enc_oaes_key_new,
.delete_callback = dap_enc_oaes_key_delete,
.new_generate_callback = dap_enc_oaes_key_generate,
.gen_key_public = NULL,
.gen_key_public_size = NULL,
.enc_out_size = dap_enc_oaes_calc_encode_size,
.dec_out_size = dap_enc_oaes_calc_decode_size,
.sign_get = NULL,
.sign_verify = NULL
},
[DAP_ENC_KEY_TYPE_BF_CBC]={
.name = "BF_CBC",
.enc = dap_enc_bf_cbc_encrypt,
.enc_na = dap_enc_bf_cbc_encrypt_fast ,
.dec = dap_enc_bf_cbc_decrypt,
.dec_na = dap_enc_bf_cbc_decrypt_fast ,
.new_callback = dap_enc_bf_cbc_key_new,
.delete_callback = dap_enc_bf_key_delete,
.new_generate_callback = dap_enc_bf_key_generate,
.gen_key_public = NULL,
.gen_key_public_size = NULL,
.enc_out_size = dap_enc_bf_cbc_calc_encode_size,
.dec_out_size = dap_enc_bf_cbc_calc_decode_size,
.sign_get = NULL,
.sign_verify = NULL
},
[DAP_ENC_KEY_TYPE_BF_OFB]={
.name = "BF_OFB",
.enc = dap_enc_bf_ofb_encrypt,
.enc_na = dap_enc_bf_ofb_encrypt_fast ,
.dec = dap_enc_bf_ofb_decrypt,
.dec_na = dap_enc_bf_ofb_decrypt_fast ,
.new_callback = dap_enc_bf_ofb_key_new,
.delete_callback = dap_enc_bf_key_delete,
.new_generate_callback = dap_enc_bf_key_generate,
.gen_key_public = NULL,
.gen_key_public_size = NULL,
.enc_out_size = dap_enc_bf_ofb_calc_encode_size,
.dec_out_size = dap_enc_bf_ofb_calc_decode_size,
.sign_get = NULL,
.sign_verify = NULL
},
[DAP_ENC_KEY_TYPE_GOST_OFB]={
.name = "GOST_OFB",
.enc = dap_enc_gost_ofb_encrypt,
.enc_na = dap_enc_gost_ofb_encrypt_fast ,
.dec = dap_enc_gost_ofb_decrypt,
.dec_na = dap_enc_gost_ofb_decrypt_fast ,
.new_callback = dap_enc_gost_ofb_key_new,
.delete_callback = dap_enc_gost_key_delete,
.new_generate_callback = dap_enc_gost_key_generate,
.gen_key_public = NULL,
.gen_key_public_size = NULL,
.enc_out_size = dap_enc_gost_ofb_calc_encode_size,
.dec_out_size = dap_enc_gost_ofb_calc_decode_size,
.sign_get = NULL,
.sign_verify = NULL
},
[DAP_ENC_KEY_TYPE_KUZN_OFB]={
.name = "KUZN_OFB",
.enc = dap_enc_kuzn_ofb_encrypt,
.enc_na = dap_enc_kuzn_ofb_encrypt_fast ,
.dec = dap_enc_kuzn_ofb_decrypt,
.dec_na = dap_enc_kuzn_ofb_decrypt_fast ,
.new_callback = dap_enc_kuzn_ofb_key_new,
.delete_callback = dap_enc_gost_key_delete,
.new_generate_callback = dap_enc_gost_key_generate,
.gen_key_public = NULL,
.gen_key_public_size = NULL,
.enc_out_size = dap_enc_kuzn_ofb_calc_encode_size,
.dec_out_size = dap_enc_kuzn_ofb_calc_decode_size,
.sign_get = NULL,
.sign_verify = NULL
},
[DAP_ENC_KEY_TYPE_SALSA2012]={
.name = "SALSA2012",
.enc = dap_enc_salsa2012_encrypt,
.enc_na = dap_enc_salsa2012_encrypt_fast ,
.dec = dap_enc_salsa2012_decrypt,
.dec_na = dap_enc_salsa2012_decrypt_fast ,
.new_callback = dap_enc_salsa2012_key_new,
.delete_callback = dap_enc_salsa2012_key_delete,
.new_generate_callback = dap_enc_salsa2012_key_generate,
.gen_key_public = NULL,
.gen_key_public_size = NULL,
.enc_out_size = dap_enc_salsa2012_calc_encode_size,
.dec_out_size = dap_enc_salsa2012_calc_decode_size,
.sign_get = NULL,
.sign_verify = NULL
},
[DAP_ENC_KEY_TYPE_MSRLN] = {
.name = "MSRLN",
.enc = NULL,
.dec = NULL,
.new_callback = dap_enc_msrln_key_new,
.delete_callback = dap_enc_msrln_key_delete,
.new_generate_callback = dap_enc_msrln_key_generate,
.gen_bob_shared_key = dap_enc_msrln_gen_bob_shared_key,
.gen_alice_shared_key = dap_enc_msrln_gen_alice_shared_key,
.gen_key_public = NULL,
.gen_key_public_size = NULL,
.new_from_data_public_callback = dap_enc_msrln_key_new_from_data_public,
.enc_out_size = NULL,
.dec_out_size = NULL,
.sign_get = NULL,
.sign_verify = NULL
},
[DAP_ENC_KEY_TYPE_DEFEO]={
.name = "DEFEO",
.enc = NULL,
.dec = NULL,
.gen_key_public = NULL,
.gen_key_public_size = NULL,
.gen_bob_shared_key = dap_enc_defeo_gen_bob_shared_key,
.gen_alice_shared_key = dap_enc_defeo_gen_alice_shared_key,
.new_callback = dap_enc_defeo_key_new,
.delete_callback = dap_enc_defeo_key_delete,
.new_generate_callback = dap_enc_defeo_key_new_generate,
.enc_out_size = NULL,
.dec_out_size = NULL,
.sign_get = NULL,
.sign_verify = NULL
},
[DAP_ENC_KEY_TYPE_SIG_PICNIC]={
.name = "PICNIC",
.enc = NULL,
.dec = NULL,
.enc_na = dap_enc_sig_picnic_get_sign, // dap_enc_picnic_enc_na
.dec_na = dap_enc_sig_picnic_verify_sign,// dap_enc_picnic_dec_na
.gen_bob_shared_key = NULL,
.gen_alice_shared_key = NULL,
.new_callback = dap_enc_sig_picnic_key_new,
.gen_key_public = NULL,
.gen_key_public_size = dap_enc_picnic_calc_signature_size,
.delete_callback = dap_enc_sig_picnic_key_delete,
.new_generate_callback = dap_enc_sig_picnic_key_new_generate,
.enc_out_size = NULL,
.dec_out_size = NULL,
.sign_get = NULL,
.sign_verify = NULL
},
[DAP_ENC_KEY_TYPE_SIG_BLISS]={
.name = "SIG_BLISS",
.enc = NULL,
.dec = NULL,
.enc_na = NULL,
.dec_na = NULL,
.sign_get = dap_enc_sig_bliss_get_sign,
.sign_verify = dap_enc_sig_bliss_verify_sign,
.gen_bob_shared_key = NULL,
.gen_alice_shared_key = NULL,
.new_callback = dap_enc_sig_bliss_key_new,
.delete_callback = dap_enc_sig_bliss_key_delete,
.new_generate_callback = dap_enc_sig_bliss_key_new_generate,
.gen_key_public = dap_enc_sig_bliss_key_pub_output,
.gen_key_public_size = dap_enc_sig_bliss_key_pub_output_size,
.enc_out_size = NULL,
.dec_out_size = NULL
},
[DAP_ENC_KEY_TYPE_SIG_TESLA]={
.name = "SIG_TESLA",
.enc = NULL,
.dec = NULL,
.enc_na = dap_enc_sig_tesla_get_sign,
.dec_na = dap_enc_sig_tesla_verify_sign,
.gen_key_public = NULL,
.gen_key_public_size = NULL,
.gen_bob_shared_key = NULL,
.gen_alice_shared_key = NULL,
.new_callback = dap_enc_sig_tesla_key_new,
.delete_callback = dap_enc_sig_tesla_key_delete,
.new_generate_callback = dap_enc_sig_tesla_key_new_generate,
.enc_out_size = NULL,
.dec_out_size = NULL,
.sign_get = NULL,
.sign_verify = NULL
},
[DAP_ENC_KEY_TYPE_SIG_DILITHIUM]={
.name = "SIG_DILITHIUM",
.enc = NULL,
.dec = NULL,
.enc_na = dap_enc_sig_dilithium_get_sign,
.dec_na = dap_enc_sig_dilithium_verify_sign,
.gen_key_public = NULL,
.gen_key_public_size = NULL,
.gen_bob_shared_key = NULL,
.gen_alice_shared_key = NULL,
.new_callback = dap_enc_sig_dilithium_key_new,
.delete_callback = dap_enc_sig_dilithium_key_delete,
.new_generate_callback = dap_enc_sig_dilithium_key_new_generate,
.enc_out_size = NULL,
.dec_out_size = NULL,
.sign_get = NULL,
.sign_verify = NULL
},
[DAP_ENC_KEY_TYPE_SIG_RINGCT20]={
.name = "SIG_RINGCT20",
.enc = NULL,
.dec = NULL,
.enc_na = dap_enc_sig_ringct20_get_sign_with_pb_list,//dap_enc_sig_ringct20_get_sign,
.dec_na = dap_enc_sig_ringct20_verify_sign,
.dec_na_ext = dap_enc_sig_ringct20_verify_sign_with_pbk_list,
.gen_key_public = NULL,
.gen_key_public_size = NULL,
.gen_bob_shared_key = NULL,
.gen_alice_shared_key = NULL,
.new_callback = dap_enc_sig_ringct20_key_new,
.delete_callback = dap_enc_sig_ringct20_key_delete,
.new_generate_callback = dap_enc_sig_ringct20_key_new_generate,
.enc_out_size = NULL,
.dec_out_size = NULL,
.sign_get = NULL,
.sign_verify = NULL
}
};
const size_t c_callbacks_size = sizeof(s_callbacks) / sizeof(s_callbacks[0]);
/**
* @brief dap_enc_key_init
* @return
*/
int dap_enc_key_init()
{
return 0;
}
/**
* @brief dap_enc_key_deinit
*/
void dap_enc_key_deinit()
{
}
/**
* @brief dap_enc_key_serealize_sign
*
* @param a_key_type
* @param a_sign
* @param a_sign_len [in/out]
* @return allocates memory with private key
*/
uint8_t* dap_enc_key_serealize_sign(dap_enc_key_type_t a_key_type, uint8_t *a_sign, size_t *a_sign_len)
{
uint8_t *data = NULL;
switch (a_key_type) {
case DAP_ENC_KEY_TYPE_SIG_BLISS:
data = dap_enc_sig_bliss_write_signature((bliss_signature_t*)a_sign, a_sign_len);
break;
case DAP_ENC_KEY_TYPE_SIG_TESLA:
data = dap_enc_tesla_write_signature((tesla_signature_t*)a_sign, a_sign_len);
break;
case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
data = dap_enc_dilithium_write_signature((dilithium_signature_t*)a_sign, a_sign_len);
break;
default:
data = DAP_NEW_Z_SIZE(uint8_t, *a_sign_len);
memcpy(data, a_sign, *a_sign_len);
}
return data;
}
/**
* @brief dap_enc_key_serealize_sign
*
* @param a_key_type
* @param a_sign
* @param a_sign_len [in/out]
* @return allocates memory with private key
*/
uint8_t* dap_enc_key_deserealize_sign(dap_enc_key_type_t a_key_type, uint8_t *a_sign, size_t *a_sign_len)
{
uint8_t *data = NULL;
switch (a_key_type) {
case DAP_ENC_KEY_TYPE_SIG_BLISS:
data = (uint8_t*)dap_enc_sig_bliss_read_signature(a_sign, *a_sign_len);
*a_sign_len = sizeof(bliss_signature_t);
break;
case DAP_ENC_KEY_TYPE_SIG_TESLA:
data = (uint8_t*)dap_enc_tesla_read_signature(a_sign, *a_sign_len);
*a_sign_len = sizeof(tesla_signature_t);
break;
case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
data = (uint8_t*)dap_enc_dilithium_read_signature(a_sign, *a_sign_len);
*a_sign_len = sizeof(dilithium_signature_t);
break;
default:
data = DAP_NEW_Z_SIZE(uint8_t, *a_sign_len);
memcpy(data, a_sign, *a_sign_len);
}
return data;
}
/**
* @brief dap_enc_key_serealize_priv_key
*
* @param a_key
* @param a_buflen_out
* @return allocates memory with private key
*/
uint8_t* dap_enc_key_serealize_priv_key(dap_enc_key_t *a_key, size_t *a_buflen_out)
{
uint8_t *data = NULL;
switch (a_key->type) {
case DAP_ENC_KEY_TYPE_SIG_BLISS:
data = dap_enc_sig_bliss_write_private_key(a_key->priv_key_data, a_buflen_out);
break;
case DAP_ENC_KEY_TYPE_SIG_TESLA:
data = dap_enc_tesla_write_private_key(a_key->priv_key_data, a_buflen_out);
break;
case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
data = dap_enc_dilithium_write_private_key(a_key->priv_key_data, a_buflen_out);
break;
default:
data = DAP_NEW_Z_SIZE(uint8_t, a_key->priv_key_data_size);
memcpy(data, a_key->priv_key_data, a_key->priv_key_data_size);
if(a_buflen_out)
*a_buflen_out = a_key->priv_key_data_size;
}
return data;
}
/**
* @brief dap_enc_key_serealize_pub_key
*
* @param a_key
* @param a_buflen_out
* @return allocates memory with private key
*/
uint8_t* dap_enc_key_serealize_pub_key(dap_enc_key_t *a_key, size_t *a_buflen_out)
{
uint8_t *data = NULL;
if ( a_key->pub_key_data == NULL ){
log_it(L_ERROR, "Public key is NULL");
return NULL;
}
switch (a_key->type) {
case DAP_ENC_KEY_TYPE_SIG_BLISS:
data = dap_enc_sig_bliss_write_public_key(a_key->pub_key_data, a_buflen_out);
break;
case DAP_ENC_KEY_TYPE_SIG_TESLA:
data = dap_enc_tesla_write_public_key(a_key->pub_key_data, a_buflen_out);
break;
case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
data = dap_enc_dilithium_write_public_key(a_key->pub_key_data, a_buflen_out);
break;
default:
data = DAP_NEW_Z_SIZE(uint8_t, a_key->pub_key_data_size);
memcpy(data, a_key->pub_key_data, a_key->pub_key_data_size);
if(a_buflen_out)
*a_buflen_out = a_key->pub_key_data_size;
}
return data;
}
/**
* @brief dap_enc_key_deserealize_priv_key
*
* @param a_key
* @param a_buf
* @param a_buflen_out
* @return 0 Ok, -1 error
*/
int dap_enc_key_deserealize_priv_key(dap_enc_key_t *a_key, const uint8_t *a_buf, size_t a_buflen)
{
if(!a_key || !a_buf)
return -1;
switch (a_key->type) {
case DAP_ENC_KEY_TYPE_SIG_BLISS:
if((a_key->priv_key_data)) {
bliss_b_private_key_delete((bliss_private_key_t *) a_key->priv_key_data);
DAP_DELETE(a_key->pub_key_data);
}
a_key->priv_key_data = (uint8_t*) dap_enc_sig_bliss_read_private_key(a_buf, a_buflen);
if(!a_key->priv_key_data)
{
a_key->priv_key_data_size = 0;
return -1;
}
a_key->priv_key_data_size = sizeof(bliss_private_key_t);
break;
case DAP_ENC_KEY_TYPE_SIG_TESLA:
tesla_private_key_delete((tesla_private_key_t *) a_key->priv_key_data);
a_key->priv_key_data = (uint8_t*) dap_enc_tesla_read_private_key(a_buf, a_buflen);
if(!a_key->priv_key_data)
{
a_key->priv_key_data_size = 0;
return -1;
}
a_key->priv_key_data_size = sizeof(tesla_private_key_t);
break;
case DAP_ENC_KEY_TYPE_SIG_PICNIC:
DAP_DELETE(a_key->priv_key_data);
a_key->priv_key_data_size = a_buflen;
a_key->priv_key_data = DAP_NEW_Z_SIZE(uint8_t, a_key->priv_key_data_size);
memcpy(a_key->priv_key_data, a_buf, a_key->priv_key_data_size);
dap_enc_sig_picnic_update(a_key);
break;
case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
dilithium_private_key_delete((dilithium_private_key_t *) a_key->priv_key_data);
a_key->priv_key_data = (uint8_t*) dap_enc_dilithium_read_private_key(a_buf, a_buflen);
if(!a_key->priv_key_data)
{
a_key->priv_key_data_size = 0;
return -1;
}
a_key->priv_key_data_size = sizeof(dilithium_private_key_t);
break;
default:
DAP_DELETE(a_key->priv_key_data);
a_key->priv_key_data_size = a_buflen;
a_key->priv_key_data = DAP_NEW_Z_SIZE(uint8_t, a_key->priv_key_data_size);
memcpy(a_key->priv_key_data, a_buf, a_key->priv_key_data_size);
}
return 0;
}
/**
* @brief dap_enc_key_deserealize_pub_key
*
* @param a_key
* @param a_buf
* @param a_buflen_out
* @return 0 Ok, -1 error
*/
int dap_enc_key_deserealize_pub_key(dap_enc_key_t *a_key, const uint8_t *a_buf, size_t a_buflen)
{
if(!a_key || !a_buf)
return -1;
switch (a_key->type) {
case DAP_ENC_KEY_TYPE_SIG_BLISS:
if((a_key->pub_key_data)) {
bliss_b_public_key_delete((bliss_public_key_t *) a_key->pub_key_data);
DAP_DELETE(a_key->pub_key_data);
}
a_key->pub_key_data = (uint8_t*) dap_enc_sig_bliss_read_public_key(a_buf, a_buflen);
if(!a_key->pub_key_data)
{
a_key->pub_key_data_size = 0;
return -1;
}
a_key->pub_key_data_size = sizeof(bliss_public_key_t);
break;
case DAP_ENC_KEY_TYPE_SIG_TESLA:
tesla_public_key_delete((tesla_public_key_t *) a_key->pub_key_data);
a_key->pub_key_data = (uint8_t*) dap_enc_tesla_read_public_key(a_buf, a_buflen);
if(!a_key->pub_key_data)
{
a_key->pub_key_data_size = 0;
return -1;
}
a_key->pub_key_data_size = sizeof(tesla_public_key_t);
break;
case DAP_ENC_KEY_TYPE_SIG_PICNIC:
DAP_DELETE(a_key->pub_key_data);
a_key->pub_key_data_size = a_buflen;
a_key->pub_key_data = DAP_NEW_Z_SIZE(uint8_t, a_key->pub_key_data_size);
memcpy(a_key->pub_key_data, a_buf, a_key->pub_key_data_size);
dap_enc_sig_picnic_update(a_key);
break;
case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
if ( a_key->pub_key_data )
dilithium_public_key_delete((dilithium_public_key_t *) a_key->pub_key_data);
a_key->pub_key_data = (uint8_t*) dap_enc_dilithium_read_public_key(a_buf, a_buflen);
if(!a_key->pub_key_data)
{
a_key->pub_key_data_size = 0;
return -1;
}
a_key->pub_key_data_size = sizeof(dilithium_public_key_t);
break;
default:
DAP_DELETE(a_key->pub_key_data);
a_key->pub_key_data_size = a_buflen;
a_key->pub_key_data = DAP_NEW_Z_SIZE(uint8_t, a_key->pub_key_data_size);
memcpy(a_key->pub_key_data, a_buf, a_key->pub_key_data_size);
}
return 0;
}
/**
* @brief dap_enc_key_serealize
* @param key
* @return allocates dap_enc_key_serealize_t* dont remember use free()
*/
dap_enc_key_serealize_t* dap_enc_key_serealize(dap_enc_key_t * key)
{
dap_enc_key_serealize_t *result = DAP_NEW_Z(dap_enc_key_serealize_t);
result->priv_key_data_size = key->priv_key_data_size;
result->pub_key_data_size = key->pub_key_data_size;
result->last_used_timestamp = key->last_used_timestamp;
result->inheritor_size = key->_inheritor_size;
result->type = key->type;
memcpy(result->priv_key_data, key->priv_key_data, key->priv_key_data_size);
memcpy(result->pub_key_data, key->pub_key_data, key->pub_key_data_size);
memcpy(result->inheritor, key->_inheritor, key->_inheritor_size);
return result;
}
/**
* @brief dap_enc_key_deserealize
* @param buf
* @param buf_size
* @return allocates dap_enc_key_t*. Use dap_enc_key_delete for free memory
*/
dap_enc_key_t* dap_enc_key_deserealize(const void *buf, size_t buf_size)
{
if(buf_size != sizeof (dap_enc_key_serealize_t)) {
log_it(L_ERROR, "Key can't be deserealize. buf_size(%d) != sizeof (dap_enc_key_serealize_t)(%d)",buf_size,sizeof (dap_enc_key_serealize_t));
return NULL;
}
const dap_enc_key_serealize_t *in_key = (const dap_enc_key_serealize_t *)buf;
dap_enc_key_t *result = dap_enc_key_new(in_key->type);
result->last_used_timestamp = in_key->last_used_timestamp;
result->priv_key_data_size = in_key->priv_key_data_size;
result->pub_key_data_size = in_key->pub_key_data_size;
result->_inheritor_size = in_key->inheritor_size;
memcpy(result->priv_key_data, in_key->priv_key_data, result->priv_key_data_size);
memcpy(result->pub_key_data, in_key->pub_key_data, result->pub_key_data_size);
if(in_key->inheritor_size)
memcpy(result->_inheritor, in_key->inheritor, in_key->inheritor_size);
else
result->_inheritor = NULL;
return result;
}
/**
* @brief dap_enc_key_new
* @param a_key_type
* @return
*/
dap_enc_key_t *dap_enc_key_new(dap_enc_key_type_t a_key_type)
{
dap_enc_key_t * ret = NULL;
if(a_key_type < c_callbacks_size ){
ret = DAP_NEW_Z(dap_enc_key_t);
if(s_callbacks[a_key_type].new_callback){
s_callbacks[a_key_type].new_callback(ret);
}
}
ret->type = a_key_type;
return ret;
}
/**
* @brief dap_enc_key_new_generate
* @param a_key_type
* @param kex_buf
* @param kex_size
* @param seed
* @param seed_size
* @param key_size - can be NULL ( generate size by default )
* @return
*/
dap_enc_key_t *dap_enc_key_new_generate(dap_enc_key_type_t a_key_type, const void *kex_buf,
size_t kex_size, const void* seed,
size_t seed_size, size_t key_size)
{
dap_enc_key_t * ret = NULL;
if(a_key_type< c_callbacks_size ) {
ret = dap_enc_key_new(a_key_type);
if(s_callbacks[a_key_type].new_generate_callback) {
s_callbacks[a_key_type].new_generate_callback( ret, kex_buf, kex_size, seed, seed_size, key_size);
}
}
return ret;
}
/**
* @brief dap_enc_key_update
* @param a_key_type
* @return
*/
void dap_enc_key_update(dap_enc_key_t *a_key)
{
if(a_key)
switch (a_key->type) {
case DAP_ENC_KEY_TYPE_SIG_TESLA:
break;
case DAP_ENC_KEY_TYPE_SIG_PICNIC:
dap_enc_sig_picnic_update(a_key);
break;
case DAP_ENC_KEY_TYPE_SIG_BLISS:
break;
case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
break;
default:
break;
}
}
size_t dap_enc_gen_key_public_size (dap_enc_key_t *a_key)
{
if(s_callbacks[a_key->type].gen_key_public_size) {
return s_callbacks[a_key->type].gen_key_public_size(a_key);
} else {
log_it(L_ERROR, "No callback for key public size calculate");
return 0;
}
}
int dap_enc_gen_key_public (dap_enc_key_t *a_key, void * a_output)
{
if(s_callbacks[a_key->type].gen_key_public) {
return s_callbacks[a_key->type].gen_key_public(a_key,a_output);
} else {
log_it(L_ERROR, "No callback for key public generate action");
}
return -1;
}
/**
* @brief dap_enc_key_delete
* @param a_key
*/
void dap_enc_key_signature_delete(dap_enc_key_type_t a_key_type, uint8_t *a_sig_buf)
{
switch (a_key_type) {
case DAP_ENC_KEY_TYPE_SIG_BLISS:
bliss_signature_delete((bliss_signature_t*)a_sig_buf);
break;
case DAP_ENC_KEY_TYPE_SIG_TESLA:
tesla_signature_delete((tesla_signature_t*)a_sig_buf);
break;
case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
dilithium_signature_delete((dilithium_signature_t*)a_sig_buf);
break;
default:
break;
}
DAP_DELETE(a_sig_buf);
}
/**
* @brief dap_enc_key_delete
* @param a_key
*/
void dap_enc_key_delete(dap_enc_key_t * a_key)
{
if(s_callbacks[a_key->type].delete_callback) {
s_callbacks[a_key->type].delete_callback(a_key);
} else {
log_it(L_ERROR, "delete callback is null. Can be leak memory!");
}
/* a_key->_inheritor must be cleaned in delete_callback func */
if ( a_key->pub_key_data)
DAP_DELETE(a_key->pub_key_data);
if (a_key->priv_key_data )
DAP_DELETE(a_key->priv_key_data);
DAP_DELETE(a_key);
}
size_t dap_enc_key_get_enc_size(dap_enc_key_t * a_key, const size_t buf_in_size)
{
if(s_callbacks[a_key->type].enc_out_size) {
return s_callbacks[a_key->type].enc_out_size(buf_in_size);
}
log_it(L_ERROR, "enc_out_size not realize for current key type");
return 0;
}
size_t dap_enc_key_get_dec_size(dap_enc_key_t * a_key, const size_t buf_in_size)
{
if(s_callbacks[a_key->type].dec_out_size) {
return s_callbacks[a_key->type].dec_out_size(buf_in_size);
}
log_it(L_ERROR, "dec_out_size not realize for current key type");
return 0;
}
const char *dap_enc_get_type_name(dap_enc_key_type_t a_key_type)
{
if(s_callbacks[a_key_type].name) {
return s_callbacks[a_key_type].name;
}
log_it(L_ERROR, "name not realize for current key type");
return 0;
}
src/dap_enc_msrln.c
View file @ fb1c4cbf
#include <string.h>
#include "dap_common.h"
#include "dap_enc_msrln.h"
#include "msrln/msrln.h"
#define LOG_TAG "dap_enc_msrln"
void dap_enc_msrln_key_new(struct dap_enc_key* a_key)
{
a_key->type = DAP_ENC_KEY_TYPE_MSRLN;
a_key->dec = NULL;
a_key->enc = NULL;
a_key->gen_bob_shared_key = (dap_enc_gen_bob_shared_key)dap_enc_msrln_gen_bob_shared_key;
a_key->gen_alice_shared_key = (dap_enc_gen_alice_shared_key)dap_enc_msrln_gen_alice_shared_key;
a_key->priv_key_data_size = 0;
a_key->pub_key_data_size = 0;
}
///**
// * @brief dap_enc_msrln_key_new_generate
// * @param a_key Struct for new key
// * @param a_size Not used
// */
//void dap_enc_msrln_key_new_generate(struct dap_enc_key* a_key, size_t a_size)
//{
// (void)a_size;
// a_key = DAP_NEW(dap_enc_key_t);
// if(a_key == NULL) {
// log_it(L_ERROR, "Can't allocate memory for key");
// return;
// }
// a_key->type = DAP_ENC_KEY_TYPE_MSRLN;
// a_key->dec = dap_enc_msrln_decode;
// a_key->enc = dap_enc_msrln_encode;
// a_key->_inheritor = DAP_NEW_Z(dap_enc_msrln_key_t);
// //a_key->delete_callback = dap_enc_msrln_key_delete;
//}
/**
* @brief dap_enc_msrln_key_generate
* @param a_key
* @param kex_buf
* @param kex_size
* @param seed
* @param seed_size
* @param key_size
* @details allocate memory and generate private and public key
*/
void dap_enc_msrln_key_generate(struct dap_enc_key * a_key, const void *kex_buf,
size_t kex_size, const void * seed, size_t seed_size,
size_t key_size)
{
(void)kex_buf; (void)kex_size;
(void)seed; (void)seed_size; (void)key_size;
/* alice_msg is alice's public key */
a_key->pub_key_data = NULL;
a_key->pub_key_data = malloc(MSRLN_PKA_BYTES);
a_key->pub_key_data_size = MSRLN_PKA_BYTES;
if(a_key->pub_key_data == NULL) {
abort();
}
a_key->priv_key_data = malloc(MSRLN_PKA_BYTES * sizeof(uint32_t));
PLatticeCryptoStruct PLCS = LatticeCrypto_allocate();
LatticeCrypto_initialize(PLCS, (RandomBytes)randombytes, MSRLN_generate_a, MSRLN_get_error);
if (MSRLN_KeyGeneration_A((int32_t *) a_key->priv_key_data,
(unsigned char *) a_key->pub_key_data, PLCS) != CRYPTO_MSRLN_SUCCESS) {
abort();
}
free(PLCS);
a_key->priv_key_data_size = MSRLN_SHAREDKEY_BYTES;
return;
}
/**
* @brief dap_enc_msrln16_encode
* @param k
* @param alice_priv
* @param alice_msg
* @param alice_msg_len
* @return
*/
size_t dap_enc_msrln_gen_bob_shared_key(struct dap_enc_key* b_key, const void* a_pub, size_t a_pub_size, void ** b_pub)
{
size_t ret;
uint8_t *bob_tmp_pub = NULL;
*b_pub = NULL;
if(b_key->priv_key_data_size == 0) { // need allocate mamory for priv key
b_key->priv_key_data = malloc(MSRLN_SHAREDKEY_BYTES);
b_key->priv_key_data_size = MSRLN_SHAREDKEY_BYTES;
}
// b_key->priv_key_data = NULL;
if(a_pub_size != MSRLN_PKA_BYTES) {
ret = 0;
DAP_DELETE(b_pub);
b_pub = NULL;
DAP_DELETE(b_key->priv_key_data);
b_key->priv_key_data = NULL;
return ret;
}
*b_pub = malloc(MSRLN_PKB_BYTES);
if(b_pub == NULL) {
ret = 0;
DAP_DELETE(b_pub);
b_pub = NULL;
DAP_DELETE(b_key->priv_key_data);
b_key->priv_key_data = NULL;
return ret;
}
bob_tmp_pub = *b_pub;
// b_key->priv_key_data = malloc(MSRLN_SHAREDKEY_BYTES);
if(b_key->priv_key_data == NULL) {
ret = 0;
DAP_DELETE(b_pub);
b_pub = NULL;
DAP_DELETE(b_key->priv_key_data);
b_key->priv_key_data = NULL;
return ret;
}
PLatticeCryptoStruct PLCS = LatticeCrypto_allocate();
LatticeCrypto_initialize(PLCS, (RandomBytes)randombytes, MSRLN_generate_a, MSRLN_get_error);
if (MSRLN_SecretAgreement_B((unsigned char *) a_pub, (unsigned char *) b_key->priv_key_data, (unsigned char *) bob_tmp_pub, PLCS) != CRYPTO_MSRLN_SUCCESS) {
ret = 0;
DAP_DELETE(b_pub);
b_pub = NULL;
DAP_DELETE(b_key->priv_key_data);
b_key->priv_key_data = NULL;
return ret;
}
free(PLCS);
b_key->priv_key_data_size = MSRLN_SHAREDKEY_BYTES;
b_key->pub_key_data_size = MSRLN_PKB_BYTES;
// *a_pub_size = MSRLN_PKB_BYTES;
ret = 1;
return ret;
}
/**
* @brief dap_enc_msrln_decode
* @param k
* @param alice_msg
* @param alice_msg_len
* @param bob_msg
* @param bob_msg_len
* @param key
* @param key_len
* @return
*/
size_t dap_enc_msrln_gen_alice_shared_key(struct dap_enc_key* a_key, const void* a_priv, const size_t b_key_len, unsigned char * b_pub)
{
size_t ret = 1;
if(a_key->priv_key_data_size == 0) { // need allocate mamory for priv key
a_key->priv_key_data = malloc(MSRLN_SHAREDKEY_BYTES);
a_key->priv_key_data_size = MSRLN_SHAREDKEY_BYTES;
}
if(a_key->priv_key_data == NULL || b_key_len != MSRLN_PKB_BYTES) {
ret = 0;
DAP_DELETE(b_pub);
b_pub = NULL;
a_priv = NULL;
DAP_DELETE(a_key->priv_key_data);
a_key->priv_key_data = NULL;
}
if (MSRLN_SecretAgreement_A((unsigned char *) b_pub, (int32_t *) a_priv, (unsigned char *) a_key->priv_key_data) != CRYPTO_MSRLN_SUCCESS) {
ret = 0;
DAP_DELETE(b_pub);
b_pub = NULL;
a_priv = NULL;
DAP_DELETE(a_key->priv_key_data);
a_key->priv_key_data = NULL;
}
a_key->priv_key_data_size = MSRLN_SHAREDKEY_BYTES;
return ret;
}
/**
* @brief dap_enc_msrln_key_new_from_data_public
* @param a_key
* @param a_in
* @param a_in_size
*/
void dap_enc_msrln_key_new_from_data_public(dap_enc_key_t * a_key, const void * a_in, size_t a_in_size)
{
(void)a_key;
(void)a_in;
(void)a_in_size;
}
/**
* @brief dap_enc_msrln_key_delete
* @param a_key
*/
void dap_enc_msrln_key_delete(struct dap_enc_key* a_key)
{
(void) a_key;
if(!a_key){
return;
}
// DAP_DELETE(a_key);
}
/**
* @brief dap_enc_msrln_key_public_base64
* @param a_key
* @return
*/
char* dap_enc_msrln_key_public_base64(dap_enc_key_t *a_key)
{
(void)a_key;
return NULL;
}
/**
* @brief dap_enc_msrln_key_public_raw
* @param a_key
* @param a_key_public
* @return
*/
size_t dap_enc_msrln_key_public_raw(dap_enc_key_t *a_key, void ** a_key_public)
{
(void)a_key;
(void)a_key_public;
return 0;
}
#include <string.h>
#include "dap_common.h"
#include "dap_enc_msrln.h"
#include "msrln/msrln.h"
#define LOG_TAG "dap_enc_msrln"
void dap_enc_msrln_key_new(struct dap_enc_key* a_key)
{
a_key->type = DAP_ENC_KEY_TYPE_MSRLN;
a_key->dec = NULL;
a_key->enc = NULL;
a_key->gen_bob_shared_key = (dap_enc_gen_bob_shared_key)dap_enc_msrln_gen_bob_shared_key;
a_key->gen_alice_shared_key = (dap_enc_gen_alice_shared_key)dap_enc_msrln_gen_alice_shared_key;
a_key->priv_key_data_size = 0;
a_key->pub_key_data_size = 0;
}
///**
// * @brief dap_enc_msrln_key_new_generate
// * @param a_key Struct for new key
// * @param a_size Not used
// */
//void dap_enc_msrln_key_new_generate(struct dap_enc_key* a_key, size_t a_size)
//{
// (void)a_size;
// a_key = DAP_NEW(dap_enc_key_t);
// if(a_key == NULL) {
// log_it(L_ERROR, "Can't allocate memory for key");
// return;
// }
// a_key->type = DAP_ENC_KEY_TYPE_MSRLN;
// a_key->dec = dap_enc_msrln_decode;
// a_key->enc = dap_enc_msrln_encode;
// a_key->_inheritor = DAP_NEW_Z(dap_enc_msrln_key_t);
// //a_key->delete_callback = dap_enc_msrln_key_delete;
//}
/**
* @brief dap_enc_msrln_key_generate
* @param a_key
* @param kex_buf
* @param kex_size
* @param seed
* @param seed_size
* @param key_size
* @details allocate memory and generate private and public key
*/
void dap_enc_msrln_key_generate(struct dap_enc_key * a_key, const void *kex_buf,
size_t kex_size, const void * seed, size_t seed_size,
size_t key_size)
{
(void)kex_buf; (void)kex_size;
(void)seed; (void)seed_size; (void)key_size;
/* alice_msg is alice's public key */
a_key->pub_key_data = NULL;
a_key->pub_key_data = malloc(MSRLN_PKA_BYTES);
a_key->pub_key_data_size = MSRLN_PKA_BYTES;
if(a_key->pub_key_data == NULL) {
abort();
}
a_key->priv_key_data = malloc(MSRLN_PKA_BYTES * sizeof(uint32_t));
PLatticeCryptoStruct PLCS = LatticeCrypto_allocate();
LatticeCrypto_initialize(PLCS, (RandomBytes)randombytes, MSRLN_generate_a, MSRLN_get_error);
if (MSRLN_KeyGeneration_A((int32_t *) a_key->priv_key_data,
(unsigned char *) a_key->pub_key_data, PLCS) != CRYPTO_MSRLN_SUCCESS) {
abort();
}
free(PLCS);
a_key->priv_key_data_size = MSRLN_SHAREDKEY_BYTES;
return;
}
/**
* @brief dap_enc_msrln16_encode
* @param k
* @param alice_priv
* @param alice_msg
* @param alice_msg_len
* @return
*/
size_t dap_enc_msrln_gen_bob_shared_key(struct dap_enc_key* b_key, const void* a_pub, size_t a_pub_size, void ** b_pub)
{
size_t ret;
uint8_t *bob_tmp_pub = NULL;
*b_pub = NULL;
if(b_key->priv_key_data_size == 0) { // need allocate mamory for priv key
b_key->priv_key_data = malloc(MSRLN_SHAREDKEY_BYTES);
b_key->priv_key_data_size = MSRLN_SHAREDKEY_BYTES;
}
// b_key->priv_key_data = NULL;
if(a_pub_size != MSRLN_PKA_BYTES) {
ret = 0;
DAP_DELETE(b_pub);
b_pub = NULL;
DAP_DELETE(b_key->priv_key_data);
b_key->priv_key_data = NULL;
return ret;
}
*b_pub = malloc(MSRLN_PKB_BYTES);
if(b_pub == NULL) {
ret = 0;
DAP_DELETE(b_key->priv_key_data);
b_key->priv_key_data = NULL;
return ret;
}
bob_tmp_pub = *b_pub;
// b_key->priv_key_data = malloc(MSRLN_SHAREDKEY_BYTES);
if(b_key->priv_key_data == NULL) {
ret = 0;
DAP_DELETE(b_pub);
b_pub = NULL;
return ret;
}
PLatticeCryptoStruct PLCS = LatticeCrypto_allocate();
LatticeCrypto_initialize(PLCS, (RandomBytes)randombytes, MSRLN_generate_a, MSRLN_get_error);
if (MSRLN_SecretAgreement_B((unsigned char *) a_pub, (unsigned char *) b_key->priv_key_data, (unsigned char *) bob_tmp_pub, PLCS) != CRYPTO_MSRLN_SUCCESS) {
ret = 0;
DAP_DELETE(b_pub);
b_pub = NULL;
DAP_DELETE(b_key->priv_key_data);
b_key->priv_key_data = NULL;
return ret;
}
free(PLCS);
b_key->priv_key_data_size = MSRLN_SHAREDKEY_BYTES;
b_key->pub_key_data_size = MSRLN_PKB_BYTES;
// *a_pub_size = MSRLN_PKB_BYTES;
ret = 1;
return ret;
}
/**
* @brief dap_enc_msrln_decode
* @param k
* @param alice_msg
* @param alice_msg_len
* @param bob_msg
* @param bob_msg_len
* @param key
* @param key_len
* @return
*/
size_t dap_enc_msrln_gen_alice_shared_key(struct dap_enc_key* a_key, const void* a_priv, const size_t b_key_len, unsigned char * b_pub)
{
size_t ret = 1;
if(a_key->priv_key_data_size == 0) { // need allocate mamory for priv key
a_key->priv_key_data = malloc(MSRLN_SHAREDKEY_BYTES);
a_key->priv_key_data_size = MSRLN_SHAREDKEY_BYTES;
}
if(a_key->priv_key_data == NULL || b_key_len != MSRLN_PKB_BYTES) {
ret = 0;
DAP_DELETE(b_pub);
b_pub = NULL;
a_priv = NULL;
DAP_DELETE(a_key->priv_key_data);
a_key->priv_key_data = NULL;
}
if (MSRLN_SecretAgreement_A((unsigned char *) b_pub, (int32_t *) a_priv, (unsigned char *) a_key->priv_key_data) != CRYPTO_MSRLN_SUCCESS) {
ret = 0;
DAP_DELETE(b_pub);
b_pub = NULL;
a_priv = NULL;
DAP_DELETE(a_key->priv_key_data);
a_key->priv_key_data = NULL;
}
a_key->priv_key_data_size = MSRLN_SHAREDKEY_BYTES;
return ret;
}
/**
* @brief dap_enc_msrln_key_new_from_data_public
* @param a_key
* @param a_in
* @param a_in_size
*/
void dap_enc_msrln_key_new_from_data_public(dap_enc_key_t * a_key, const void * a_in, size_t a_in_size)
{
(void)a_key;
(void)a_in;
(void)a_in_size;
}
/**
* @brief dap_enc_msrln_key_delete
* @param a_key
*/
void dap_enc_msrln_key_delete(struct dap_enc_key* a_key)
{
(void) a_key;
if(!a_key){
return;
}
// DAP_DELETE(a_key);
}
/**
* @brief dap_enc_msrln_key_public_base64
* @param a_key
* @return
*/
char* dap_enc_msrln_key_public_base64(dap_enc_key_t *a_key)
{
(void)a_key;
return NULL;
}
/**
* @brief dap_enc_msrln_key_public_raw
* @param a_key
* @param a_key_public
* @return
*/
size_t dap_enc_msrln_key_public_raw(dap_enc_key_t *a_key, void ** a_key_public)
{
(void)a_key;
(void)a_key_public;
return 0;
}
src/dap_enc_oaes.c
View file @ fb1c4cbf
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <stddef.h>
#include <string.h>
#include "oaes_lib.h"
#include "dap_enc_oaes.h"
#include "dap_common.h"
#define LOG_TAG "dap_enc_oaes"
static OAES_CTX* get_oaes_ctx(struct dap_enc_key *a_key)
{
OAES_CTX *ctx = NULL;
if(a_key && a_key->_inheritor &&
a_key->_inheritor_size == sizeof(oaes_ctx)) {
ctx = a_key->_inheritor;
}
return ctx;
}
void dap_enc_oaes_key_new(struct dap_enc_key * a_key)
{
a_key->_inheritor = (uint8_t *) oaes_alloc();
a_key->_inheritor_size = sizeof(oaes_ctx);
a_key->type = DAP_ENC_KEY_TYPE_OAES;
a_key->enc = dap_enc_oaes_encrypt;
a_key->dec = dap_enc_oaes_decrypt;
a_key->enc_na = dap_enc_oaes_encrypt_fast;
a_key->dec_na = dap_enc_oaes_decrypt_fast;
}
void dap_enc_oaes_key_delete(struct dap_enc_key *a_key)
{
OAES_CTX *ctx = get_oaes_ctx(a_key);
if(ctx) {
oaes_free(&ctx); // free(a_key->_inheritor);
a_key->_inheritor_size = 0;
}
}
void dap_enc_oaes_key_generate(struct dap_enc_key * a_key, const void *kex_buf,
size_t kex_size, const void * seed, size_t seed_size, size_t key_size)
{
a_key->last_used_timestamp = time(NULL);
oaes_ctx *ctx = get_oaes_ctx(a_key);
if(kex_size < key_size) {
log_it(L_ERROR, "kex_size can't be less than key_size");
return;
}
OAES_RET r = oaes_key_import_data(ctx, kex_buf, key_size);
if(r != OAES_RET_SUCCESS) {
log_it(L_ERROR, "Error generate key");
return;
}
if(seed_size >= OAES_BLOCK_SIZE)
memcpy(ctx->iv, seed, OAES_BLOCK_SIZE);
else
memset(ctx->iv, 0, OAES_BLOCK_SIZE);
}
size_t dap_enc_oaes_calc_encode_size(const size_t size_in)
{
size_t a_out_size = 2 * OAES_BLOCK_SIZE + size_in
+ (size_in % OAES_BLOCK_SIZE == 0 ? 0 :
OAES_BLOCK_SIZE - size_in % OAES_BLOCK_SIZE);
return a_out_size;
}
size_t dap_enc_oaes_calc_decode_size(const size_t size_in)
{
return size_in - 2 * OAES_BLOCK_SIZE;
}
size_t dap_enc_oaes_decrypt(struct dap_enc_key *a_key, const void * a_in,
size_t a_in_size, void ** a_out) {
OAES_CTX *ctx = get_oaes_ctx(a_key);
if(!ctx)
return 0;
size_t a_out_size = dap_enc_oaes_calc_decode_size(a_in_size);
*a_out = calloc(a_out_size, 1);
OAES_RET ret = oaes_decrypt(ctx, a_in, a_in_size, *a_out, &a_out_size);
if(ret != OAES_RET_SUCCESS) {
a_out_size = 0;
free(*a_out);
}
return a_out_size;
}
size_t dap_enc_oaes_encrypt(struct dap_enc_key * a_key, const void * a_in, size_t a_in_size, void ** a_out)
{
OAES_CTX *ctx = get_oaes_ctx(a_key);
if(!ctx)
return 0;
size_t a_out_size = dap_enc_oaes_calc_encode_size(a_in_size);
*a_out = calloc(a_out_size, 1);
OAES_RET ret = oaes_encrypt(ctx, a_in, a_in_size, *a_out, &a_out_size);
if(ret != OAES_RET_SUCCESS) {
a_out_size = 0;
free(*a_out);
}
return a_out_size;
}
// Writes result ( out ) in already allocated buffer
size_t dap_enc_oaes_decrypt_fast(struct dap_enc_key * a_key, const void * a_in, size_t a_in_size,
void * buf_out, size_t buf_out_size)
{
OAES_CTX *ctx = get_oaes_ctx(a_key);
if(!ctx)
return 0;
OAES_RET ret = oaes_decrypt(ctx, a_in, a_in_size, buf_out, &buf_out_size);
if(ret != OAES_RET_SUCCESS) {
buf_out_size = 0;
}
return buf_out_size;
}
// Writes result ( out ) in already allocated buffer
size_t dap_enc_oaes_encrypt_fast(struct dap_enc_key * a_key, const void * a_in,
size_t a_in_size, void * buf_out, size_t buf_out_size)
{
OAES_CTX *ctx = get_oaes_ctx(a_key);
if(!ctx)
return 0;
OAES_RET ret = oaes_encrypt(ctx, a_in, a_in_size, buf_out, &buf_out_size);
if(ret != OAES_RET_SUCCESS) {
buf_out_size = 0;
}
return buf_out_size;
}
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <stddef.h>
#include <string.h>
#include "oaes_lib.h"
#include "dap_enc_oaes.h"
#include "dap_common.h"
#define LOG_TAG "dap_enc_oaes"
static OAES_CTX* get_oaes_ctx(struct dap_enc_key *a_key)
{
OAES_CTX *ctx = NULL;
if(a_key && a_key->_inheritor &&
a_key->_inheritor_size == sizeof(oaes_ctx)) {
ctx = a_key->_inheritor;
}
return ctx;
}
void dap_enc_oaes_key_new(struct dap_enc_key * a_key)
{
a_key->_inheritor = (uint8_t *) oaes_alloc();
a_key->_inheritor_size = sizeof(oaes_ctx);
a_key->type = DAP_ENC_KEY_TYPE_OAES;
a_key->enc = dap_enc_oaes_encrypt;
a_key->dec = dap_enc_oaes_decrypt;
a_key->enc_na = dap_enc_oaes_encrypt_fast;
a_key->dec_na = dap_enc_oaes_decrypt_fast;
}
void dap_enc_oaes_key_delete(struct dap_enc_key *a_key)
{
OAES_CTX *ctx = get_oaes_ctx(a_key);
if(ctx) {
oaes_free(&ctx); // free(a_key->_inheritor);
a_key->_inheritor_size = 0;
}
}
void dap_enc_oaes_key_generate(struct dap_enc_key * a_key, const void *kex_buf,
size_t kex_size, const void * seed, size_t seed_size, size_t key_size)
{
a_key->last_used_timestamp = time(NULL);
oaes_ctx *ctx = get_oaes_ctx(a_key);
if(kex_size < key_size) {
log_it(L_ERROR, "kex_size can't be less than key_size");
return;
}
OAES_RET r = oaes_key_import_data(ctx, kex_buf, key_size);
if(r != OAES_RET_SUCCESS) {
log_it(L_ERROR, "Error generate key");
return;
}
if(seed_size >= OAES_BLOCK_SIZE)
memcpy(ctx->iv, seed, OAES_BLOCK_SIZE);
else
memset(ctx->iv, 0, OAES_BLOCK_SIZE);
}
size_t dap_enc_oaes_calc_encode_size(const size_t size_in)
{
size_t a_out_size = 2 * OAES_BLOCK_SIZE + size_in
+ (size_in % OAES_BLOCK_SIZE == 0 ? 0 :
OAES_BLOCK_SIZE - size_in % OAES_BLOCK_SIZE);
return a_out_size;
}
size_t dap_enc_oaes_calc_decode_size(const size_t size_in)
{
return size_in - 2 * OAES_BLOCK_SIZE;
}
size_t dap_enc_oaes_decrypt(struct dap_enc_key *a_key, const void * a_in,
size_t a_in_size, void ** a_out) {
OAES_CTX *ctx = get_oaes_ctx(a_key);
if(!ctx)
return 0;
size_t a_out_size = dap_enc_oaes_calc_decode_size(a_in_size);
*a_out = calloc(a_out_size, 1);
OAES_RET ret = oaes_decrypt(ctx, a_in, a_in_size, *a_out, &a_out_size);
if(ret != OAES_RET_SUCCESS) {
a_out_size = 0;
free(*a_out);
}
return a_out_size;
}
size_t dap_enc_oaes_encrypt(struct dap_enc_key * a_key, const void * a_in, size_t a_in_size, void ** a_out)
{
OAES_CTX *ctx = get_oaes_ctx(a_key);
if(!ctx)
return 0;
size_t a_out_size = dap_enc_oaes_calc_encode_size(a_in_size);
*a_out = calloc(a_out_size, 1);
OAES_RET ret = oaes_encrypt(ctx, a_in, a_in_size, *a_out, &a_out_size);
if(ret != OAES_RET_SUCCESS) {
a_out_size = 0;
free(*a_out);
}
return a_out_size;
}
// Writes result ( out ) in already allocated buffer
size_t dap_enc_oaes_decrypt_fast(struct dap_enc_key * a_key, const void * a_in, size_t a_in_size,
void * buf_out, size_t buf_out_size)
{
OAES_CTX *ctx = get_oaes_ctx(a_key);
if(!ctx)
return 0;
OAES_RET ret = oaes_decrypt(ctx, a_in, a_in_size, buf_out, &buf_out_size);
if(ret != OAES_RET_SUCCESS) {
buf_out_size = 0;
}
return buf_out_size;
}
// Writes result ( out ) in already allocated buffer
size_t dap_enc_oaes_encrypt_fast(struct dap_enc_key * a_key, const void * a_in,
size_t a_in_size, void * buf_out, size_t buf_out_size)
{
OAES_CTX *ctx = get_oaes_ctx(a_key);
if(!ctx)
return 0;
OAES_RET ret = oaes_encrypt(ctx, a_in, a_in_size, buf_out, &buf_out_size);
if(ret != OAES_RET_SUCCESS) {
buf_out_size = 0;
}
return buf_out_size;
}
src/dap_enc_picnic.c
View file @ fb1c4cbf
#include "dap_common.h"
#include "dap_enc_picnic.h"
#include <stdio.h>
#include <stddef.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include "picnic.h"
#include "picnic_impl.h"
#define LOG_TAG "dap_enc_picnic_sig"
/**
* Set the mark that valid keys are present
*/
static void set_picnic_params_t(struct dap_enc_key *key)
{
picnic_params_t *param = (key) ? (picnic_params_t*) key->_inheritor : NULL;
if(param && key->_inheritor_size == sizeof(picnic_params_t)){
if(key->priv_key_data)
*param = ((picnic_privatekey_t*) key->priv_key_data)->params;
else if(key->pub_key_data)
*param = ((picnic_publickey_t*) key->pub_key_data)->params;
}
}
/**
* Check present of valid keys
*/
static bool check_picnic_params_t(struct dap_enc_key *key)
{
picnic_params_t *param = (key) ? (picnic_params_t*) key->_inheritor : NULL;
if(param && *param > PARAMETER_SET_INVALID && *param < PARAMETER_SET_MAX_INDEX)
return true;
return false;
}
size_t dap_enc_picnic_calc_signature_size(struct dap_enc_key *key)
{
picnic_params_t *param = (picnic_params_t*) key->_inheritor;
size_t max_signature_size = picnic_signature_size(*param);
return max_signature_size;
}
void dap_enc_sig_picnic_key_new(struct dap_enc_key *key) {
key->type = DAP_ENC_KEY_TYPE_SIG_PICNIC;
key->_inheritor = calloc(sizeof(picnic_params_t), 1);
key->_inheritor_size = sizeof(picnic_params_t);
key->enc = NULL;
key->enc = NULL;
key->gen_bob_shared_key = NULL; //(dap_enc_gen_bob_shared_key) dap_enc_sig_picnic_get_sign;
key->gen_alice_shared_key = NULL; //(dap_enc_gen_alice_shared_key) dap_enc_sig_picnic_verify_sign;
key->enc_na = (dap_enc_callback_dataop_na_t) dap_enc_sig_picnic_get_sign;
key->dec_na = (dap_enc_callback_dataop_na_t) dap_enc_sig_picnic_verify_sign;
key->priv_key_data = NULL;
key->pub_key_data = NULL;
}
void dap_enc_sig_picnic_key_delete(struct dap_enc_key *key)
{
if(key->_inheritor_size > 0)
free(key->_inheritor);
key->_inheritor = NULL;
key->_inheritor_size = 0;
// free memory will be in dap_enc_key_delete()
//picnic_keypair_delete((picnic_privatekey_t*) key->priv_key_data, (picnic_publickey_t *) key->pub_key_data);
key->priv_key_data_size = 0;
key->pub_key_data_size = 0;
}
void dap_enc_sig_picnic_update(struct dap_enc_key * a_key)
{
if(a_key) {
if(!a_key->priv_key_data ||
!picnic_validate_keypair((picnic_privatekey_t *) a_key->priv_key_data, (picnic_publickey_t *) a_key->pub_key_data))
set_picnic_params_t(a_key);
}
}
void dap_enc_sig_picnic_key_new_generate(struct dap_enc_key * key, const void *kex_buf, size_t kex_size,
const void * seed, size_t seed_size, size_t key_size)
{
(void) kex_buf;
(void) kex_size;
(void) key_size;
picnic_params_t parameters;
// Parameter name from Picnic_L1_FS = 1 to PARAMETER_SET_MAX_INDEX
if(seed_size >= sizeof(unsigned char) && seed)
parameters = (((unsigned char*) seed)[0] % (PARAMETER_SET_MAX_INDEX - 1)) + 1;
else
parameters = DAP_PICNIC_SIGN_PARAMETR;
key->priv_key_data_size = sizeof(picnic_privatekey_t);
key->pub_key_data_size = sizeof(picnic_publickey_t);
key->priv_key_data = calloc(1, key->priv_key_data_size);
key->pub_key_data = calloc(1, key->pub_key_data_size);
picnic_keys_gen((picnic_privatekey_t *) key->priv_key_data, (picnic_publickey_t *) key->pub_key_data, parameters, seed, seed_size);
if(!picnic_validate_keypair((picnic_privatekey_t *) key->priv_key_data, (picnic_publickey_t *) key->pub_key_data))
set_picnic_params_t(key);
}
size_t dap_enc_sig_picnic_get_sign(struct dap_enc_key * key, const void* message, size_t message_len,
void* signature, size_t signature_len)
{
int ret;
if(!check_picnic_params_t(key))
return -1;
picnic_privatekey_t* sk = key->priv_key_data;
signature_t* sig = (signature_t*) malloc(sizeof(signature_t));
paramset_t paramset;
ret = get_param_set(sk->params, &paramset);
if(ret != EXIT_SUCCESS) {
free(sig);
return -1;
}
allocateSignature(sig, &paramset);
if(sig == NULL) {
return -1;
}
ret = sign((uint32_t*) sk->data, (uint32_t*) sk->pk.ciphertext, (uint32_t*) sk->pk.plaintext, (const uint8_t*)message,
message_len, sig, &paramset);
if(ret != EXIT_SUCCESS) {
freeSignature(sig, &paramset);
free(sig);
return -1;
}
ret = serializeSignature(sig, (uint8_t*)signature, signature_len, &paramset);
if(ret == -1) {
freeSignature(sig, &paramset);
free(sig);
return -1;
}
// *signature_len = ret;
freeSignature(sig, &paramset);
free(sig);
return ret;
}
size_t dap_enc_sig_picnic_verify_sign(struct dap_enc_key * key, const void* message, size_t message_len,
void* signature, size_t signature_len)
{
int ret;
if(!check_picnic_params_t(key))
return -1;
picnic_publickey_t* pk = key->pub_key_data;
paramset_t paramset;
ret = get_param_set(pk->params, &paramset);
if(ret != EXIT_SUCCESS)
return -1;
signature_t* sig = (signature_t*) malloc(sizeof(signature_t));
allocateSignature(sig, &paramset);
if(sig == NULL) {
return -1;
}
ret = deserializeSignature(sig, (const uint8_t*)signature, signature_len, &paramset);
if(ret != EXIT_SUCCESS) {
freeSignature(sig, &paramset);
free(sig);
return -1;
}
ret = verify(sig, (uint32_t*) pk->ciphertext,
(uint32_t*) pk->plaintext, (const uint8_t*)message, message_len, &paramset);
if(ret != EXIT_SUCCESS) {
/* Signature is invalid, or verify function failed */
freeSignature(sig, &paramset);
free(sig);
return -1;
}
freeSignature(sig, &paramset);
free(sig);
return 0;
}
/*
uint8_t* dap_enc_sig_picnic_write_public_key(struct dap_enc_key * a_key, size_t *a_buflen_out)
{
const picnic_publickey_t *l_key = a_key->pub_key_data;
size_t buflen = picnic_get_public_key_size(l_key); // Get public key size for serialize
uint8_t* l_buf = DAP_NEW_SIZE(uint8_t, buflen);
// Serialize public key
if(picnic_write_public_key(l_key, l_buf, buflen)>0){
if(a_buflen_out)
*a_buflen_out = buflen;
return l_buf;
}
return NULL;
}
uint8_t* dap_enc_sig_picnic_read_public_key(struct dap_enc_key * a_key, uint8_t a_buf, size_t *a_buflen)
{
const picnic_publickey_t *l_key = a_key->pub_key_data;
size_t buflen = picnic_get_public_key_size(l_key); Get public key size for serialize
uint8_t* l_buf = DAP_NEW_SIZE(uint8_t, buflen);
// Deserialize public key
if(!picnic_read_public_key(l_key, a_l_buf, buflen)>0){
if(a_buflen_out)
*a_buflen_out = buflen;
return l_buf;
}
return NULL;
}*/
#include "dap_common.h"
#include "dap_enc_picnic.h"
#include <stdio.h>
#include <stddef.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include "picnic.h"
#include "picnic_impl.h"
#define LOG_TAG "dap_enc_picnic_sig"
/**
* Set the mark that valid keys are present
*/
static void set_picnic_params_t(struct dap_enc_key *key)
{
picnic_params_t *param = (key) ? (picnic_params_t*) key->_inheritor : NULL;
if(param && key->_inheritor_size == sizeof(picnic_params_t)){
if(key->priv_key_data)
*param = ((picnic_privatekey_t*) key->priv_key_data)->params;
else if(key->pub_key_data)
*param = ((picnic_publickey_t*) key->pub_key_data)->params;
}
}
/**
* Check present of valid keys
*/
static bool check_picnic_params_t(struct dap_enc_key *key)
{
picnic_params_t *param = (key) ? (picnic_params_t*) key->_inheritor : NULL;
if(param && *param > PARAMETER_SET_INVALID && *param < PARAMETER_SET_MAX_INDEX)
return true;
return false;
}
size_t dap_enc_picnic_calc_signature_size(struct dap_enc_key *key)
{
picnic_params_t *param = (picnic_params_t*) key->_inheritor;
size_t max_signature_size = picnic_signature_size(*param);
return max_signature_size;
}
void dap_enc_sig_picnic_key_new(struct dap_enc_key *key) {
key->type = DAP_ENC_KEY_TYPE_SIG_PICNIC;
key->_inheritor = calloc(sizeof(picnic_params_t), 1);
key->_inheritor_size = sizeof(picnic_params_t);
key->enc = NULL;
key->enc = NULL;
key->gen_bob_shared_key = NULL; //(dap_enc_gen_bob_shared_key) dap_enc_sig_picnic_get_sign;
key->gen_alice_shared_key = NULL; //(dap_enc_gen_alice_shared_key) dap_enc_sig_picnic_verify_sign;
key->enc_na = (dap_enc_callback_dataop_na_t) dap_enc_sig_picnic_get_sign;
key->dec_na = (dap_enc_callback_dataop_na_t) dap_enc_sig_picnic_verify_sign;
key->priv_key_data = NULL;
key->pub_key_data = NULL;
}
void dap_enc_sig_picnic_key_delete(struct dap_enc_key *key)
{
if(key->_inheritor_size > 0)
free(key->_inheritor);
key->_inheritor = NULL;
key->_inheritor_size = 0;
// free memory will be in dap_enc_key_delete()
//picnic_keypair_delete((picnic_privatekey_t*) key->priv_key_data, (picnic_publickey_t *) key->pub_key_data);
key->priv_key_data_size = 0;
key->pub_key_data_size = 0;
}
void dap_enc_sig_picnic_update(struct dap_enc_key * a_key)
{
if(a_key) {
if(!a_key->priv_key_data ||
!picnic_validate_keypair((picnic_privatekey_t *) a_key->priv_key_data, (picnic_publickey_t *) a_key->pub_key_data))
set_picnic_params_t(a_key);
}
}
void dap_enc_sig_picnic_key_new_generate(struct dap_enc_key * key, const void *kex_buf, size_t kex_size,
const void * seed, size_t seed_size, size_t key_size)
{
(void) kex_buf;
(void) kex_size;
(void) key_size;
picnic_params_t parameters;
// Parameter name from Picnic_L1_FS = 1 to PARAMETER_SET_MAX_INDEX
if(seed_size >= sizeof(unsigned char) && seed)
parameters = (((unsigned char*) seed)[0] % (PARAMETER_SET_MAX_INDEX - 1)) + 1;
else
parameters = DAP_PICNIC_SIGN_PARAMETR;
key->priv_key_data_size = sizeof(picnic_privatekey_t);
key->pub_key_data_size = sizeof(picnic_publickey_t);
key->priv_key_data = calloc(1, key->priv_key_data_size);
key->pub_key_data = calloc(1, key->pub_key_data_size);
picnic_keys_gen((picnic_privatekey_t *) key->priv_key_data, (picnic_publickey_t *) key->pub_key_data, parameters, seed, seed_size);
if(!picnic_validate_keypair((picnic_privatekey_t *) key->priv_key_data, (picnic_publickey_t *) key->pub_key_data))
set_picnic_params_t(key);
}
size_t dap_enc_sig_picnic_get_sign(struct dap_enc_key * key, const void* message, size_t message_len,
void* signature, size_t signature_len)
{
int ret;
if(!check_picnic_params_t(key))
return -1;
picnic_privatekey_t* sk = key->priv_key_data;
signature_t* sig = (signature_t*) malloc(sizeof(signature_t));
paramset_t paramset;
ret = get_param_set(sk->params, &paramset);
if(ret != EXIT_SUCCESS) {
free(sig);
return -1;
}
allocateSignature(sig, &paramset);
if(sig == NULL) {
return -1;
}
ret = sign((uint32_t*) sk->data, (uint32_t*) sk->pk.ciphertext, (uint32_t*) sk->pk.plaintext, (const uint8_t*)message,
message_len, sig, &paramset);
if(ret != EXIT_SUCCESS) {
freeSignature(sig, &paramset);
free(sig);
return -1;
}
ret = serializeSignature(sig, (uint8_t*)signature, signature_len, &paramset);
if(ret == -1) {
freeSignature(sig, &paramset);
free(sig);
return -1;
}
// *signature_len = ret;
freeSignature(sig, &paramset);
free(sig);
return ret;
}
size_t dap_enc_sig_picnic_verify_sign(struct dap_enc_key * key, const void* message, size_t message_len,
void* signature, size_t signature_len)
{
int ret;
if(!check_picnic_params_t(key))
return -1;
picnic_publickey_t* pk = key->pub_key_data;
paramset_t paramset;
ret = get_param_set(pk->params, &paramset);
if(ret != EXIT_SUCCESS)
return -1;
signature_t* sig = (signature_t*) malloc(sizeof(signature_t));
allocateSignature(sig, &paramset);
if(sig == NULL) {
return -1;
}
ret = deserializeSignature(sig, (const uint8_t*)signature, signature_len, &paramset);
if(ret != EXIT_SUCCESS) {
freeSignature(sig, &paramset);
free(sig);
return -1;
}
ret = verify(sig, (uint32_t*) pk->ciphertext,
(uint32_t*) pk->plaintext, (const uint8_t*)message, message_len, &paramset);
if(ret != EXIT_SUCCESS) {
/* Signature is invalid, or verify function failed */
freeSignature(sig, &paramset);
free(sig);
return -1;
}
freeSignature(sig, &paramset);
free(sig);
return 0;
}
/*
uint8_t* dap_enc_sig_picnic_write_public_key(struct dap_enc_key * a_key, size_t *a_buflen_out)
{
const picnic_publickey_t *l_key = a_key->pub_key_data;
size_t buflen = picnic_get_public_key_size(l_key); // Get public key size for serialize
uint8_t* l_buf = DAP_NEW_SIZE(uint8_t, buflen);
// Serialize public key
if(picnic_write_public_key(l_key, l_buf, buflen)>0){
if(a_buflen_out)
*a_buflen_out = buflen;
return l_buf;
}
return NULL;
}
uint8_t* dap_enc_sig_picnic_read_public_key(struct dap_enc_key * a_key, uint8_t a_buf, size_t *a_buflen)
{
const picnic_publickey_t *l_key = a_key->pub_key_data;
size_t buflen = picnic_get_public_key_size(l_key); Get public key size for serialize
uint8_t* l_buf = DAP_NEW_SIZE(uint8_t, buflen);
// Deserialize public key
if(!picnic_read_public_key(l_key, a_l_buf, buflen)>0){
if(a_buflen_out)
*a_buflen_out = buflen;
return l_buf;
}
return NULL;
}*/
src/dap_enc_ringct20.c 0 → 100644
View file @ fb1c4cbf
#include <assert.h>
#include <inttypes.h>
#include <string.h>
#include "dap_enc_ringct20.h"
#include "dap_common.h"
#include "dap_rand.h"
#define LOG_TAG "dap_enc_sig_ringct20"
DAP_RINGCT20_SIGN_SECURITY _ringct20_type = RINGCT20_MINSEC; // by default
//poly_ringct20 Afixed[10];
//poly_ringct20 Hfixed[10];
int32_t ringct20_private_and_public_keys_init(ringct20_private_key_t *private_key, ringct20_public_key_t *public_key, ringct20_param_t *p);
void SetupPrintAH(poly_ringct20 *A, poly_ringct20 * H, const int mLen)
{
LRCT_Setup(A, H, mLen);
uint8_t polyb_tmp[NEWHOPE_POLYBYTES];
printf("A_bpoly[%d][NEWHOPE_POLYBYTES] = {\n", mLen);
for(int i = 0; i < mLen; ++i)
{
poly_tobytes(polyb_tmp,A + i);
printf("{");
for(int j = 0; j < NEWHOPE_POLYBYTES; ++j)
{
printf("0x%.2x", polyb_tmp[j]);
if(j < NEWHOPE_POLYBYTES - 1)
printf(", ");
}
printf("}");
if(i < mLen - 1)
printf(",\n");
}
printf("};\n");
printf("H_bpoly[%d][NEWHOPE_POLYBYTES] = {\n", mLen);
for(int i = 0; i < mLen; ++i)
{
poly_tobytes(polyb_tmp,H + i);
printf("{");
for(int j = 0; j < NEWHOPE_POLYBYTES; ++j)
{
printf("0x%.2x", polyb_tmp[j]);
if(j < NEWHOPE_POLYBYTES - 1)
printf(", ");
}
printf("}");
if(i < mLen - 1)
printf(",\n");
}
printf("};\n");
}
void ringct20_pack_prk(uint8_t *prk, const poly_ringct20 *S, const ringct20_param_t *rct_p)
{
for(int i = 0; i < rct_p->M - 1; ++i)
poly_tobytes(prk + i*rct_p->POLY_RINGCT20_SIZE_PACKED, S +i);
}
void ringct20_unpack_prk(const uint8_t *prk, poly_ringct20 *S, const ringct20_param_t *rct_p)
{
for(int i = 0; i < rct_p->M - 1; ++i)
poly_frombytes(S +i, prk + i*rct_p->POLY_RINGCT20_SIZE_PACKED);
}
void ringct20_pack_pbk(uint8_t *pbk, const poly_ringct20 *a, const ringct20_param_t *rct_p)
{
uint32_t packed_size = 0;
//pack a
poly_tobytes(pbk + packed_size, a);
packed_size += rct_p->POLY_RINGCT20_SIZE_PACKED;
}
void ringct20_unpack_pbk(const uint8_t *pbk, poly_ringct20 *a, const ringct20_param_t *rct_p)
{
uint32_t unpacked_size = 0;
//unpack a
poly_frombytes(a, pbk + unpacked_size);
unpacked_size += rct_p->POLY_RINGCT20_SIZE_PACKED;
}
void ringct20_unpack_sig(const uint8_t *sig, DAP_RINGCT20_SIGN_SECURITY *sec_kind, poly_ringct20 **a_list,
poly_ringct20 *c1, poly_ringct20 ***t, poly_ringct20 *h, const ringct20_param_t *rct_p, int *wLen)
{
uint32_t unpacked_size = 0;
//unpack sec_kind
memcpy(sec_kind, sig + unpacked_size, sizeof(DAP_RINGCT20_SIGN_SECURITY));
unpacked_size += sizeof(DAP_RINGCT20_SIGN_SECURITY);
//unpack wLen
memcpy(wLen, sig + unpacked_size, sizeof(*wLen));
unpacked_size += sizeof(*wLen);
//unpack a_list
*a_list = malloc(rct_p->POLY_RINGCT20_SIZE* *wLen);
for(int i = 0; i < *wLen; ++i)
{
poly_frombytes(*a_list + i, sig + unpacked_size);
unpacked_size += rct_p->POLY_RINGCT20_SIZE_PACKED;
}
//unpack t[W][M]
*t = malloc(*wLen *sizeof(poly_ringct20*));
for(int j = 0; j < *wLen; ++j)
{
(*t)[j] = malloc(rct_p->M*rct_p->POLY_RINGCT20_SIZE);
for(int i = 0; i < rct_p->M; ++i)
{
poly_frombytes((*t)[j] + i, sig + unpacked_size);
unpacked_size += rct_p->POLY_RINGCT20_SIZE_PACKED;
}
}
//unpack h
poly_frombytes(h, sig + unpacked_size);
unpacked_size += rct_p->POLY_RINGCT20_SIZE_PACKED;
//unpack c1
poly_frombytes(c1, sig + unpacked_size);
unpacked_size += rct_p->POLY_RINGCT20_SIZE_PACKED;
}
void ringct20_pack_sig(uint8_t *sig, const poly_ringct20 *a_list,
poly_ringct20 *c1, poly_ringct20 **t, const poly_ringct20 *h, const ringct20_param_t *rct_p, const int wLen)
{
uint32_t packed_size = 0;
//pack sec_kind
memcpy(sig + packed_size, &(rct_p->kind), sizeof(DAP_RINGCT20_SIGN_SECURITY));
packed_size += sizeof(DAP_RINGCT20_SIGN_SECURITY);
//pack wLen
memcpy(sig + packed_size, &(wLen), sizeof(wLen));
packed_size += sizeof(wLen);
//pack a_list
for(int i = 0; i < wLen; ++i)
{
poly_tobytes(sig + packed_size, a_list + i);
packed_size += rct_p->POLY_RINGCT20_SIZE_PACKED;
}
// for(int i = 0; i < 16; ++i)
// printf("%.2x ", sig[i]);
// printf(" = sig\n"); fflush(stdout);
//pack t[W][M]
for(int j = 0; j < wLen; ++j)
{
for(int i = 0; i < rct_p->M; ++i)
{
poly_tobytes(sig + packed_size,t[j] + i);
packed_size += rct_p->POLY_RINGCT20_SIZE_PACKED;
}
}
//pack h
poly_tobytes(sig + packed_size, h);
packed_size += rct_p->POLY_RINGCT20_SIZE_PACKED;
//pack c1
poly_tobytes(sig + packed_size, c1);
packed_size += rct_p->POLY_RINGCT20_SIZE_PACKED;
}
int get_pbk_list(poly_ringct20 *aList, const ringct20_param_t *p, const int Pi, const int wLen,
const ringct20_public_key_t *allpbk, const int allpbknum)
{
if(allpbk == 0 || allpbknum == 0)
return -1;
if(wLen < allpbknum/2)
{
log_it(L_ERROR, "Too big wLen chosen");
return -1;
}
int *pos_pbk_ist = DAP_NEW_SIZE(int, sizeof(int)*wLen);
int try_count = 0;
for(int i = 0; i < wLen && try_count < 3*wLen; ++i)
{
if(i == Pi)
continue;
pos_pbk_ist[i] = -1;
do
{
pos_pbk_ist[i] = random_uint32_t(allpbknum);
pos_pbk_ist[i]++;
if(allpbk[pos_pbk_ist[i]].kind != p->kind)
pos_pbk_ist[i] = -1;
for(int j = 0; j < i && pos_pbk_ist[i] != -1; ++j)
if(j != Pi && pos_pbk_ist[j] == pos_pbk_ist[i])
pos_pbk_ist[i] = -1;
}while(pos_pbk_ist[i] != -1 && try_count < 3*wLen);
ringct20_unpack_pbk(allpbk[pos_pbk_ist[i]].data, aList + i, p);
if(try_count >= 3*wLen)
{
log_it(L_ERROR, "tired to choise so many pbk");
DAP_DELETE(pos_pbk_ist);
return -1;
}
}
DAP_DELETE(pos_pbk_ist);
return 0;//Здесь должно быть обращение за списком публичных ключей
return 0;
}
size_t CRUTCH_gen_pbk_list(const ringct20_param_t *p, void **pbklist, const int pbknum)
{
size_t size_pbkkey = p->RINGCT20_PBK_SIZE + sizeof (DAP_RINGCT20_SIGN_SECURITY);
size_t pbklistsize = size_pbkkey*pbknum;
//get a list of some pbk
{
poly_ringct20 pbk_poly;
poly_ringct20 *Stmp = malloc(p->POLY_RINGCT20_SIZE*p->mLen);
*pbklist = DAP_NEW_SIZE(uint8_t, size_pbkkey*pbknum);
for(int i = 0; i < pbknum; ++i)
{
LRCT_SampleKey(Stmp, p->mLen);
LRCT_KeyGen(&pbk_poly, p->A, Stmp, p->mLen);
*(DAP_RINGCT20_SIGN_SECURITY*)((*pbklist) + size_pbkkey*i) = p->kind;
ringct20_pack_pbk(((*pbklist) + size_pbkkey*i + sizeof(DAP_RINGCT20_SIGN_SECURITY)), &pbk_poly, p);
}
free(Stmp);
}
return pbklistsize;
}
int CRUTCH_get_pbk_list(poly_ringct20 *aList, const ringct20_param_t *p, const int Pi, const int wLen)
{
int allpbknum = 4*wLen;
ringct20_public_key_t *allpbk = DAP_NEW_SIZE(ringct20_public_key_t, sizeof(ringct20_public_key_t)*allpbknum);
void *allpbk_buf = NULL;
CRUTCH_gen_pbk_list(p, &allpbk_buf, allpbknum);
size_t size_pbkkey = p->RINGCT20_PBK_SIZE + sizeof (DAP_RINGCT20_SIGN_SECURITY);
for(int i = 0; i < allpbknum; ++i)
{
allpbk[i].kind = *(DAP_RINGCT20_SIGN_SECURITY*)(allpbk_buf + size_pbkkey*i);
allpbk[i].data = allpbk_buf + size_pbkkey*i + sizeof(DAP_RINGCT20_SIGN_SECURITY);
}
// poly_ringct20 pbk_poly;
// //get a list of some pbk
// {
// poly_ringct20 *Stmp = malloc(p->POLY_RINGCT20_SIZE*p->mLen);
// for(int i = 0; i < allpbknum; ++i)
// {
// LRCT_SampleKey(Stmp, p->mLen);
// LRCT_KeyGen(&pbk_poly, p->A, Stmp, p->mLen);
// allpbk[i].kind = p->kind;
// allpbk[i].data = DAP_NEW_SIZE(uint8_t,p->RINGCT20_PBK_SIZE);
// ringct20_pack_pbk(allpbk[i].data, &pbk_poly, p);
// }
// free(Stmp);
// }
int res = get_pbk_list(aList,p,Pi,wLen, allpbk,allpbknum);
//free the list of some pbk
// for(int i = 0; i < allpbknum; ++i)
// {
// DAP_DELETE(allpbk[i].data);
// }
DAP_DELETE(allpbk);
DAP_DELETE(allpbk_buf);
return res;
}
int ringct20_crypto_sign( ringct20_signature_t *sig, const unsigned char *m, unsigned long long mlen, const ringct20_private_key_t *private_key)
{
ringct20_param_t *p = calloc(sizeof(ringct20_param_t),1);
if (! ringct20_params_init( p, private_key->kind)){
ringct20_params_free(p);
return -1;
}
uint32_t Pi;
randombytes(&Pi, sizeof(Pi));
Pi %= p->wLen;
poly_ringct20 *aList = malloc(p->POLY_RINGCT20_SIZE*p->wLen);
poly_ringct20 *S = malloc(p->POLY_RINGCT20_SIZE*p->mLen);
ringct20_unpack_prk(private_key->data,S,p);
LRCT_KeyGen(aList + Pi, p->A,S,p->mLen);
CRUTCH_get_pbk_list(aList, p, Pi, p->mLen);
poly_ringct20 h;
poly_ringct20 *u = malloc(p->POLY_RINGCT20_SIZE*p->M);
poly_ringct20 c1;
poly_ringct20** t;//[w][M]//TOCORRECT to *t;
t = malloc(p->wLen*sizeof(poly_ringct20*));
for(int i = 0; i < p->wLen; ++i)
t[i] = malloc(p->M*p->POLY_RINGCT20_SIZE);
unsigned char *bt = malloc(NEWHOPE_POLYBYTES);
for (int i = 0; i < p->wLen; i++)
{
for (int k = 0; k < p->M; k++)
{
poly_init(t[i] + k);
}
}
for (int k = 0; k < p->M; k++)
{
randombytes(bt, NEWHOPE_POLYBYTES);
poly_frombytes(u + k, bt);
poly_serial(u + k);
//poly_print(u+k);
}
free(bt);
LRCT_SigGen(&c1, t, &h, p->A, p->H, S, u, p->mLen, aList, p->wLen, Pi, m, mlen);
sig->sig_len = p->RINGCT20_SIG_SIZE;// + mlen;
sig->sig_data = malloc(sig->sig_len);
// memcpy(sig->sig_data,m,mlen);//TOCORRECT
ringct20_pack_sig(sig->sig_data, aList,&c1, t, &h, p, p->wLen);
free(aList);
free(S);
free(u);
for(int i = 0; i < p->wLen; ++i)
free(t[i]);
free(t);
ringct20_params_free(p);
return 0;
}
void ringct20_signature_delete(ringct20_signature_t *sig){
assert(sig != NULL);
free(sig->sig_data);
sig->sig_data = NULL;
}
/**
* @brief check msg[msg_size] sig with pbkList[wpbkList]
* @param msg
* @param msg_size
* @param sig
* @param pbkList
* @param wpbkList
* @return 0 if sign ckeck with pbkList[wpbkList]
*/
int ringct20_crypto_sign_open_with_pbkList(const unsigned char * msg, const unsigned long long msg_size,
const ringct20_signature_t * sig, const void *pbkList_buf, const int wpbkList)
//const ringct20_public_key_t* pbkList)
{
int wLenSig;
if(sig->sig_len < sizeof(DAP_RINGCT20_SIGN_SECURITY) + sizeof(wLenSig))
return -1;
DAP_RINGCT20_SIGN_SECURITY sec_kind = *(DAP_RINGCT20_SIGN_SECURITY*)sig->sig_data;
wLenSig = *(typeof (&wLenSig))(sig->sig_data + sizeof(DAP_RINGCT20_SIGN_SECURITY));
if(wpbkList != 0 && wLenSig != wpbkList)
{
return -1;
}
ringct20_param_t *p = calloc(sizeof(ringct20_param_t),1);
if (! ringct20_params_init( p, sec_kind))
{
ringct20_params_free(p);
return -1;
}
if(sig->sig_len < p->RINGCT20_SIG_SIZE)
{
ringct20_params_free(p);
return -1;
}
poly_ringct20 *aList = NULL;
poly_ringct20 h;
poly_ringct20 c1;
poly_ringct20** t = NULL;//[w][M]//TOCORRECT to *t;
ringct20_unpack_sig(sig->sig_data, &sec_kind, &aList,&c1, &t, &h, p, &wLenSig);
if(wpbkList)
{
ringct20_public_key_t* pbkList = DAP_NEW_SIZE(ringct20_public_key_t, sizeof(ringct20_public_key_t)*wpbkList);
size_t size_pbkkey = p->RINGCT20_PBK_SIZE + sizeof (DAP_RINGCT20_SIGN_SECURITY);
for(int i = 0; i < wpbkList; i++)
{
pbkList[i].kind = *(DAP_RINGCT20_SIGN_SECURITY*)(pbkList_buf+size_pbkkey*i);
pbkList[i].data = (uint8_t*)(pbkList_buf+size_pbkkey*i + sizeof(DAP_RINGCT20_SIGN_SECURITY));
//printf("i = %d secKind = %d, kind = %d\n",i, sec_kind , pbkList[i].kind);fflush(stdout);
if(sec_kind != pbkList[i].kind)
{
if(aList)
free(aList);
if(t)
{
for(int i = 0; i < wLenSig; ++i)
free(t[i]);
free(t);
}
ringct20_params_free(p);
DAP_DELETE(pbkList);
return -1;
}
}
for(int i = 0; i < wLenSig; ++i)
ringct20_unpack_pbk(pbkList[i].data, aList + i, p);
DAP_DELETE(pbkList);
}
int result = 1;
result = 1 ^ LRCT_SigVer(&c1, t, p->A, p->H, p->mLen, &h, aList, wLenSig, msg, msg_size);
if(aList)
free(aList);
if(t)
{
for(int i = 0; i < wLenSig; ++i)
free(t[i]);
free(t);
}
ringct20_params_free(p);
return result;
}
int ringct20_crypto_sign_open( const unsigned char * msg, const unsigned long long msg_size, const ringct20_signature_t * sig, const ringct20_public_key_t* public_key)
{
if(sig->sig_len < sizeof(DAP_RINGCT20_SIGN_SECURITY))
return -1;
DAP_RINGCT20_SIGN_SECURITY sec_kind = *(DAP_RINGCT20_SIGN_SECURITY*)sig->sig_data;
if(sec_kind != public_key->kind)
return -1;
ringct20_param_t *p = calloc(sizeof(ringct20_param_t),1);
if (! ringct20_params_init( p, public_key->kind)){
ringct20_params_free(p);
return -1;
}
if(sig->sig_len < p->RINGCT20_SIG_SIZE)
{
ringct20_params_free(p);
return -1;
}
poly_ringct20 *aList = NULL;
poly_ringct20 h;
poly_ringct20 c1;
poly_ringct20** t = NULL;//[w][M]//TOCORRECT to *t;
int wLenSig = 0;
ringct20_unpack_sig(sig->sig_data, &sec_kind, &aList,&c1, &t, &h, p, &wLenSig);
int pbk_in_aList = 0;
poly_ringct20 a_pi;
ringct20_unpack_pbk(public_key->data, &a_pi, p);
for(int i = 0; i < wLenSig; ++i)
{
if(poly_equal(&a_pi, aList + i))
{
pbk_in_aList = 1;
break;
}
}
int result = 1;
if(pbk_in_aList)
result = 1 ^ LRCT_SigVer(&c1, t, p->A, p->H, p->mLen, &h, aList, wLenSig, msg, msg_size);
if(aList)
free(aList);
if(t)
{
for(int i = 0; i < wLenSig; ++i)
free(t[i]);
free(t);
}
ringct20_params_free(p);
return result;
}
int ringct20_crypto_sign_keypair(ringct20_public_key_t *pbk, ringct20_private_key_t *prk, DAP_RINGCT20_SIGN_SECURITY kind)
{
ringct20_param_t *p;
p = calloc(sizeof (ringct20_param_t),1);
ringct20_params_init(p, kind);
if(ringct20_private_and_public_keys_init(prk,pbk,p) != 0)
{
ringct20_params_free(p);//free(p);
return -1;
}
poly_ringct20 *S;
poly_ringct20 *a;
S = (poly_ringct20*)malloc(sizeof(poly_ringct20)*p->mLen);
a = (poly_ringct20*)malloc(sizeof(poly_ringct20));
// LRCT_Setup(A,H,p->mLen);
LRCT_SampleKey(S, p->mLen);
LRCT_KeyGen(a, p->A, S, p->mLen);
ringct20_pack_pbk(pbk->data, a, p);
ringct20_pack_prk(prk->data, S, p);
free(S);
free(a);
ringct20_params_free(p);
return 0;
}
void ringct20_private_key_delete(ringct20_private_key_t *private_key)
{
if(private_key) {
free(private_key->data);
private_key->data = NULL;
free(private_key);
}
}
void ringct20_public_key_delete(ringct20_public_key_t *public_key)
{
if(public_key) {
free(public_key->data);
public_key->data = NULL;
free(public_key);
}
}
void ringct20_private_and_public_keys_delete(ringct20_private_key_t *private_key, ringct20_public_key_t *public_key){
free(private_key->data);
private_key->data = NULL;
free(public_key->data);
public_key->data = NULL;
}
int32_t ringct20_private_and_public_keys_init(ringct20_private_key_t *private_key, ringct20_public_key_t *public_key, ringct20_param_t *p){
unsigned char *f = NULL, *g = NULL;
f = calloc(p->RINGCT20_PBK_SIZE, sizeof(char));
if (f == NULL) {
free(f);
return -1;
}
public_key->kind = p->kind;
public_key->data = f;
g = calloc(p->RINGCT20_PRK_SIZE, sizeof(char));
if (g == NULL) {
free(f);
free(g);
return -1;
}
private_key->kind = p->kind;
private_key->data = g;
return 0;
}
void dap_enc_sig_ringct20_set_type(DAP_RINGCT20_SIGN_SECURITY type)
{
_ringct20_type = type;
}
size_t dap_enc_sig_ringct20_getallpbk(dap_enc_key_t *key, const void *allpbkList, const int allpbknum);
void dap_enc_sig_ringct20_key_new(struct dap_enc_key *key) {
key->type = DAP_ENC_KEY_TYPE_SIG_RINGCT20;
key->enc = NULL;
key->enc_na = (dap_enc_callback_dataop_na_t) dap_enc_sig_ringct20_get_sign_with_pb_list;//dap_enc_sig_ringct20_get_sign;
key->dec_na = (dap_enc_callback_dataop_na_t) dap_enc_sig_ringct20_verify_sign;
key->dec_na_ext = (dap_enc_callback_dataop_na_ext_t) dap_enc_sig_ringct20_verify_sign_with_pbk_list;//dap_enc_sig_ringct20_verify_sign;
key->getallpbkList = (dap_enc_get_allpbk_list) dap_enc_sig_ringct20_getallpbk;
key->pbkListsize = 0;
key->pbkListdata = NULL;
}
size_t dap_enc_sig_ringct20_getallpbk(dap_enc_key_t *key, const void *allpbk_list, const int allpbk_list_size)
{
key->pbkListdata = DAP_NEW_SIZE(uint8_t, allpbk_list_size);
memcpy(key->pbkListdata, allpbk_list, allpbk_list_size);
key->pbkListsize= allpbk_list_size;
return 0;
}
void dap_enc_sig_ringct20_key_new_generate(struct dap_enc_key * a_key, const void *kex_buf,
size_t kex_size, const void * seed, size_t seed_size,
size_t key_size)
{
int32_t retcode;
DAP_RINGCT20_SIGN_SECURITY ringct20_type = RINGCT20_MINSEC;
dap_enc_sig_ringct20_set_type(ringct20_type);
a_key->priv_key_data_size = sizeof(ringct20_private_key_t);
a_key->pub_key_data_size = sizeof(ringct20_public_key_t);
a_key->priv_key_data = malloc(a_key->priv_key_data_size);
a_key->pub_key_data = malloc(a_key->pub_key_data_size);
retcode = ringct20_crypto_sign_keypair((ringct20_public_key_t *) a_key->pub_key_data,
(ringct20_private_key_t *) a_key->priv_key_data, _ringct20_type);
if(retcode != 0) {
ringct20_private_and_public_keys_delete((ringct20_private_key_t *) a_key->pub_key_data,
(ringct20_public_key_t *) a_key->pub_key_data);
log_it(L_CRITICAL, "Error");
return;
}
}
int ringct20_crypto_sign_with_pbk_list( ringct20_signature_t *sig, const unsigned char *m,
unsigned long long mlen, const ringct20_private_key_t *private_key, const void *allpbk_buf, const int allpbk_size)
{
ringct20_param_t *p = calloc(sizeof(ringct20_param_t),1);
if (! ringct20_params_init( p, private_key->kind)){
ringct20_params_free(p);
return -1;
}
const int wLen = p->wLen;
int Pi = random_uint32_t(wLen);
poly_ringct20 *aList = malloc(p->POLY_RINGCT20_SIZE*wLen);
poly_ringct20 *S = malloc(p->POLY_RINGCT20_SIZE*p->mLen);
ringct20_unpack_prk(private_key->data,S,p);
LRCT_KeyGen(aList + Pi, p->A,S,p->mLen);
//CRUTCH_get_pbk_list(aList, p, Pi, p->mLen);
size_t size_pbkkey = p->RINGCT20_PBK_SIZE + sizeof (DAP_RINGCT20_SIGN_SECURITY);
int filled_pbk_num = 0, sizeused = 0;
for(; filled_pbk_num < wLen && sizeused < allpbk_size;++filled_pbk_num)
{
if(filled_pbk_num == Pi)
continue;
DAP_RINGCT20_SIGN_SECURITY curkind = *(DAP_RINGCT20_SIGN_SECURITY*)(allpbk_buf + sizeused);
if(curkind != p->kind)
break;
ringct20_unpack_pbk((allpbk_buf + sizeused + sizeof(DAP_RINGCT20_SIGN_SECURITY)), aList + filled_pbk_num, p);
sizeused += size_pbkkey;
}
if(filled_pbk_num < wLen)
{
log_it(L_ERROR, "RINGCT20: not enough pbkeys use CRUTCH_gen_pbk_list and key->getallpbkList");
DAP_DELETE(aList);
DAP_DELETE(S);
return -1;
}
poly_ringct20 h;
poly_ringct20 *u = malloc(p->POLY_RINGCT20_SIZE*p->M);
poly_ringct20 c1;
poly_ringct20** t;//[w][M]//TOCORRECT to *t;
t = malloc(wLen*sizeof(poly_ringct20*));
for(int i = 0; i < wLen; ++i)
t[i] = malloc(p->M*p->POLY_RINGCT20_SIZE);
unsigned char *bt = malloc(NEWHOPE_POLYBYTES);
for (int i = 0; i < wLen; i++)
{
for (int k = 0; k < p->M; k++)
{
poly_init(t[i] + k);
}
}
for (int k = 0; k < p->M; k++)
{
randombytes(bt, NEWHOPE_POLYBYTES);
poly_frombytes(u + k, bt);
poly_serial(u + k);
//poly_print(u+k);
}
free(bt);
LRCT_SigGen(&c1, t, &h, p->A, p->H, S, u, p->mLen, aList, wLen, Pi, m, mlen);
sig->sig_len = p->RINGCT20_SIG_SIZE;// + mlen;
sig->sig_data = malloc(sig->sig_len);
// memcpy(sig->sig_data,m,mlen);//TOCORRECT
ringct20_pack_sig(sig->sig_data, aList,&c1, t, &h, p, wLen);
free(aList);
free(S);
free(u);
for(int i = 0; i < wLen; ++i)
free(t[i]);
free(t);
ringct20_params_free(p);
return 0;
}
size_t dap_enc_sig_ringct20_get_sign_with_pb_list(struct dap_enc_key * a_key, const void * msg,
const size_t msg_size, void * signature, const size_t signature_size)
{
if(signature_size < sizeof(ringct20_signature_t)) {
log_it(L_ERROR, "bad signature size");
return 0;
}
if(!ringct20_crypto_sign_with_pbk_list((ringct20_signature_t *) signature, (const unsigned char *) msg, msg_size, a_key->priv_key_data, a_key->pbkListdata, a_key->pbkListsize))
return signature_size;
else
return 0;
}
size_t dap_enc_sig_ringct20_get_sign(struct dap_enc_key * a_key, const void * msg,
const size_t msg_size, void * signature, const size_t signature_size)
{
if(signature_size < sizeof(ringct20_signature_t)) {
log_it(L_ERROR, "bad signature size");
return 0;
}
if(!ringct20_crypto_sign((ringct20_signature_t *) signature, (const unsigned char *) msg, msg_size, a_key->priv_key_data))
return signature_size;
else
return 0;
}
size_t dap_enc_sig_ringct20_verify_sign(struct dap_enc_key * a_key, const void * msg,
const size_t msg_size, void * signature, const size_t signature_size)
{
if(signature_size < sizeof(ringct20_signature_t)) {
log_it(L_ERROR, "bad signature size");
return 1;
}
return (ringct20_crypto_sign_open( (unsigned char *) msg, msg_size, (ringct20_signature_t *) signature, a_key->pub_key_data));
}
size_t dap_enc_sig_ringct20_verify_sign_with_pbk_list(struct dap_enc_key * a_key, const void * msg,
const size_t msg_size, void * signature, const size_t signature_size, const void *pbkList_buf, const int wpbkList)
{
if(signature_size < sizeof(ringct20_signature_t)) {
log_it(L_ERROR, "bad signature size");
return 1;
}
return ringct20_crypto_sign_open_with_pbkList( (unsigned char *) msg, msg_size, (ringct20_signature_t *) signature, pbkList_buf, wpbkList);
}
void dap_enc_sig_ringct20_key_delete(struct dap_enc_key * a_key)
{
if(a_key->pbkListsize)
{
DAP_DELETE(a_key->pbkListdata);
a_key->pbkListsize = 0;
}
ringct20_private_and_public_keys_delete((ringct20_private_key_t *) a_key->priv_key_data,
(ringct20_public_key_t *) a_key->pub_key_data);
}
size_t dap_enc_ringct20_calc_signature_size(void)
{
return sizeof(ringct20_signature_t);
}
/* Serialize a signature */
uint8_t* dap_enc_ringct20_write_signature(ringct20_signature_t* a_sign, size_t *a_sign_out)
{
if(!a_sign || *a_sign_out!=sizeof(ringct20_signature_t)) {
return NULL ;
}
size_t l_shift_mem = 0;
size_t l_buflen = sizeof(size_t) + sizeof(DAP_RINGCT20_SIGN_SECURITY) + a_sign->sig_len + sizeof(unsigned long long);
uint8_t *l_buf = DAP_NEW_SIZE(uint8_t, l_buflen);
memcpy(l_buf, &l_buflen, sizeof(size_t));
l_shift_mem += sizeof(size_t);
memcpy(l_buf + l_shift_mem, &a_sign->kind, sizeof(DAP_RINGCT20_SIGN_SECURITY));
l_shift_mem += sizeof(DAP_RINGCT20_SIGN_SECURITY);
memcpy(l_buf + l_shift_mem, &a_sign->sig_len, sizeof(unsigned long long));
l_shift_mem += sizeof(unsigned long long);
memcpy(l_buf + l_shift_mem, a_sign->sig_data, a_sign->sig_len );
l_shift_mem += a_sign->sig_len ;
if(a_sign_out)
*a_sign_out = l_buflen;
return l_buf;
}
/* Deserialize a signature */
ringct20_signature_t* dap_enc_ringct20_read_signature(uint8_t *a_buf, size_t a_buflen)
{
if(!a_buf || a_buflen < (sizeof(size_t) + sizeof(DAP_RINGCT20_SIGN_SECURITY)))
return NULL ;
DAP_RINGCT20_SIGN_SECURITY kind;
size_t l_buflen = 0;
memcpy(&l_buflen, a_buf, sizeof(size_t));
memcpy(&kind, a_buf + sizeof(size_t), sizeof(DAP_RINGCT20_SIGN_SECURITY));
if(l_buflen != a_buflen)
return NULL ;
ringct20_param_t p;
if(!ringct20_params_init(&p, kind))
return NULL ;
ringct20_signature_t* l_sign = DAP_NEW(ringct20_signature_t);
l_sign->kind = kind;
size_t l_shift_mem = sizeof(size_t) + sizeof(DAP_RINGCT20_SIGN_SECURITY);
memcpy(&l_sign->sig_len, a_buf + l_shift_mem, sizeof(unsigned long long));
l_shift_mem += sizeof(unsigned long long);
l_sign->sig_data = DAP_NEW_SIZE(unsigned char, l_sign->sig_len);
memcpy(l_sign->sig_data, a_buf + l_shift_mem, l_sign->sig_len);
l_shift_mem += l_sign->sig_len;
return l_sign;
}
/* Serialize a private key. */
uint8_t* dap_enc_ringct20_write_private_key(const ringct20_private_key_t* a_private_key, size_t *a_buflen_out)
{
ringct20_param_t *p = calloc(sizeof(ringct20_param_t),1);
if(!ringct20_params_init(p, a_private_key->kind))
{
ringct20_params_free(p);
return NULL;
}
size_t l_buflen = sizeof(size_t) + sizeof(DAP_RINGCT20_SIGN_SECURITY) + p->RINGCT20_PRK_SIZE; //CRYPTO_PUBLICKEYBYTES;
uint8_t *l_buf = DAP_NEW_SIZE(uint8_t, l_buflen);
memcpy(l_buf, &l_buflen, sizeof(size_t));
memcpy(l_buf + sizeof(size_t), &a_private_key->kind, sizeof(DAP_RINGCT20_SIGN_SECURITY));
memcpy(l_buf + sizeof(size_t) + sizeof(DAP_RINGCT20_SIGN_SECURITY), a_private_key->data, p->RINGCT20_PRK_SIZE);
if(a_buflen_out)
*a_buflen_out = l_buflen;
ringct20_params_free(p);
return l_buf;
}
/* Serialize a public key. */
uint8_t* dap_enc_ringct20_write_public_key(const ringct20_public_key_t* a_public_key, size_t *a_buflen_out)
{
ringct20_param_t *p = calloc(sizeof(ringct20_param_t),1);
if(!ringct20_params_init(p, a_public_key->kind))
{
ringct20_params_free(p);
return NULL;
}
size_t l_buflen = sizeof(size_t) + sizeof(DAP_RINGCT20_SIGN_SECURITY) + p->RINGCT20_PBK_SIZE;//.CRYPTO_PUBLICKEYBYTES;
uint8_t *l_buf = DAP_NEW_SIZE(uint8_t, l_buflen);
memcpy(l_buf, &l_buflen, sizeof(size_t));
memcpy(l_buf + sizeof(size_t), &a_public_key->kind, sizeof(DAP_RINGCT20_SIGN_SECURITY));
memcpy(l_buf + sizeof(size_t) + sizeof(DAP_RINGCT20_SIGN_SECURITY), a_public_key->data, p->RINGCT20_PBK_SIZE);//.CRYPTO_PUBLICKEYBYTES);
if(a_buflen_out)
*a_buflen_out = l_buflen;
ringct20_params_free(p);
return l_buf;
}
/* Deserialize a private key. */
ringct20_private_key_t* dap_enc_ringct20_read_private_key(const uint8_t *a_buf, size_t a_buflen)
{
if(!a_buf || a_buflen < (sizeof(size_t) + sizeof(DAP_RINGCT20_SIGN_SECURITY)))
return NULL;
DAP_RINGCT20_SIGN_SECURITY kind;
size_t l_buflen = 0;
memcpy(&l_buflen, a_buf, sizeof(size_t));
memcpy(&kind, a_buf + sizeof(size_t), sizeof(DAP_RINGCT20_SIGN_SECURITY));
if(l_buflen != a_buflen)
return NULL;
ringct20_param_t *p = calloc(sizeof(ringct20_param_t),1);
if(!ringct20_params_init(p, kind))
{
ringct20_params_free(p);
return NULL;
}
ringct20_private_key_t* l_private_key = DAP_NEW(ringct20_private_key_t);
l_private_key->kind = kind;
l_private_key->data = DAP_NEW_SIZE(unsigned char, p->RINGCT20_PRK_SIZE);//.CRYPTO_SECRETKEYBYTES);
memcpy(l_private_key->data, a_buf + sizeof(size_t) + sizeof(DAP_RINGCT20_SIGN_SECURITY), p->RINGCT20_PRK_SIZE);//.CRYPTO_SECRETKEYBYTES);
ringct20_params_free(p);
return l_private_key;
}
/* Deserialize a public key. */
ringct20_public_key_t* dap_enc_ringct20_read_public_key(const uint8_t *a_buf, size_t a_buflen)
{
if(!a_buf || a_buflen < (sizeof(size_t) + sizeof(DAP_RINGCT20_SIGN_SECURITY)))
return NULL;
DAP_RINGCT20_SIGN_SECURITY kind;
size_t l_buflen = 0;
memcpy(&l_buflen, a_buf, sizeof(size_t));
memcpy(&kind, a_buf + sizeof(size_t), sizeof(DAP_RINGCT20_SIGN_SECURITY));
if(l_buflen != a_buflen)
return NULL;
ringct20_param_t *p = calloc(sizeof(ringct20_param_t),1);
if(!ringct20_params_init(p, kind))
{
ringct20_params_free(p);
return NULL;
}
ringct20_public_key_t* l_public_key = DAP_NEW(ringct20_public_key_t);
l_public_key->kind = kind;
l_public_key->data = DAP_NEW_SIZE(unsigned char, p->RINGCT20_PBK_SIZE);//.CRYPTO_PUBLICKEYBYTES);
memcpy(l_public_key->data, a_buf + sizeof(size_t) + sizeof(DAP_RINGCT20_SIGN_SECURITY), p->RINGCT20_PBK_SIZE);//.CRYPTO_PUBLICKEYBYTES);
ringct20_params_free(p);
return l_public_key;
}
src/dap_enc_salsa2012.c 0 → 100644
View file @ fb1c4cbf
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <stddef.h>
#include <string.h>
#include "dap_enc_salsa2012.h"
#include "dap_common.h"
#include "rand/dap_rand.h"
#include "sha3/KeccakHash.h"
#define LOG_TAG "dap_enc_salsa2012"
#define SALSA20_KEY_SIZE 32
#define SALSA20_NONCE_SIZE 8
void dap_enc_salsa2012_key_generate(struct dap_enc_key * a_key, const void *kex_buf,
size_t kex_size, const void * seed, size_t seed_size, size_t key_size)
{
if(key_size < SALSA20_KEY_SIZE)
{
log_it(L_ERROR, "SALSA20 key cannot be less than 32 bytes.");
}
a_key->last_used_timestamp = time(NULL);
a_key->priv_key_data_size = SALSA20_KEY_SIZE;
a_key->priv_key_data = DAP_NEW_SIZE(uint8_t, key_size);
Keccak_HashInstance Keccak_ctx;
Keccak_HashInitialize(&Keccak_ctx, 1088, 512, SALSA20_KEY_SIZE*8, 0x06);
Keccak_HashUpdate(&Keccak_ctx, kex_buf, kex_size*8);
if(seed_size)
Keccak_HashUpdate(&Keccak_ctx, seed, seed_size*8);
Keccak_HashFinal(&Keccak_ctx, a_key->priv_key_data);
}
void dap_enc_salsa2012_key_delete(struct dap_enc_key *a_key)
{
if(a_key->priv_key_data != NULL)
{
randombytes(a_key->priv_key_data,a_key->priv_key_data_size);
DAP_DELETE(a_key->priv_key_data);
}
a_key->priv_key_data_size = 0;
}
//------SALSA2012-----------
void dap_enc_salsa2012_key_new(struct dap_enc_key * a_key)
{
a_key->_inheritor = NULL;
a_key->_inheritor_size = 0;
a_key->type = DAP_ENC_KEY_TYPE_SALSA2012;
a_key->enc = dap_enc_salsa2012_encrypt;
a_key->dec = dap_enc_salsa2012_decrypt;
a_key->enc_na = dap_enc_salsa2012_encrypt_fast;
a_key->dec_na = dap_enc_salsa2012_decrypt_fast;
}
size_t dap_enc_salsa2012_decrypt(struct dap_enc_key *a_key, const void * a_in, size_t a_in_size, void ** a_out)
{
size_t a_out_size = a_in_size - SALSA20_NONCE_SIZE;
if(a_out_size <= 0) {
log_it(L_ERROR, "salsa2012 decryption ct with iv must be more than kBlockLen89 bytes");
return 0;
}
*a_out = DAP_NEW_SIZE(uint8_t, a_in_size - SALSA20_NONCE_SIZE);
a_out_size = dap_enc_salsa2012_decrypt_fast(a_key, a_in, a_in_size, *a_out, a_out_size);
if(a_out_size == 0)
DAP_DEL_Z(*a_out);
return a_out_size;
}
size_t dap_enc_salsa2012_encrypt(struct dap_enc_key * a_key, const void * a_in, size_t a_in_size, void ** a_out)
{
if(a_in_size <= 0) {
log_it(L_ERROR, "gost ofb encryption pt cannot be 0 bytes");
return 0;
}
size_t a_out_size = a_in_size + SALSA20_NONCE_SIZE;
*a_out = DAP_NEW_SIZE(uint8_t, a_out_size);
a_out_size = dap_enc_salsa2012_encrypt_fast(a_key, a_in, a_in_size, *a_out, a_out_size);
if(a_out_size == 0)
DAP_DEL_Z(*a_out);
return a_out_size;
}
size_t dap_enc_salsa2012_calc_encode_size(const size_t size_in)
{
return size_in + SALSA20_NONCE_SIZE;
}
size_t dap_enc_salsa2012_calc_decode_size(const size_t size_in)
{
if(size_in <= SALSA20_NONCE_SIZE) {
log_it(L_ERROR, "salsa2012 decryption size_in ct with iv must be more than kBlockLen89 bytes");
return 0;
}
return size_in - SALSA20_NONCE_SIZE;
}
size_t dap_enc_salsa2012_decrypt_fast(struct dap_enc_key *a_key, const void * a_in,
size_t a_in_size, void * a_out, size_t buf_out_size) {
size_t a_out_size = a_in_size - SALSA20_NONCE_SIZE;
if(a_out_size > buf_out_size) {
log_it(L_ERROR, "salsa2012 fast_decryption too small buf_out_size");
return 0;
}
//memcpy(nonce, a_in, SALSA20_NONCE_SIZE);
crypto_stream_salsa2012_xor(a_out, a_in + SALSA20_NONCE_SIZE, a_in_size - SALSA20_NONCE_SIZE, a_in, a_key->priv_key_data);
return a_out_size;
}
size_t dap_enc_salsa2012_encrypt_fast(struct dap_enc_key * a_key, const void * a_in, size_t a_in_size, void * a_out,size_t buf_out_size)
{
size_t a_out_size = a_in_size + SALSA20_NONCE_SIZE;
if(a_out_size > buf_out_size) {
log_it(L_ERROR, "salsa2012 fast_encryption too small buf_out_size");
return 0;
}
if(randombytes(a_out, SALSA20_NONCE_SIZE) == 1)
{
log_it(L_ERROR, "failed to get SALSA20_NONCE_SIZE bytes nonce");
return 0;
}
crypto_stream_salsa2012_xor(a_out + SALSA20_NONCE_SIZE, a_in, a_in_size, a_out, a_key->priv_key_data);
return a_out_size;
}
src/dap_enc_tesla.c
View file @ fb1c4cbf
#include <assert.h>
#include <inttypes.h>
#include <string.h>
#include "dap_enc_tesla.h"
#include "dap_common.h"
#include "dap_rand.h"
#define LOG_TAG "dap_enc_sig_tesla"
static enum DAP_TESLA_SIGN_SECURITY _tesla_type = HEURISTIC_MAX_SECURITY_AND_MAX_SPEED; // by default
void dap_enc_sig_tesla_set_type(enum DAP_TESLA_SIGN_SECURITY type)
{
_tesla_type = type;
}
void dap_enc_sig_tesla_key_new(struct dap_enc_key *key) {
key->type = DAP_ENC_KEY_TYPE_SIG_TESLA;
key->enc = NULL;
key->enc_na = (dap_enc_callback_dataop_na_t) dap_enc_sig_tesla_get_sign;
key->dec_na = (dap_enc_callback_dataop_na_t) dap_enc_sig_tesla_verify_sign;
// key->gen_bob_shared_key = (dap_enc_gen_bob_shared_key) dap_enc_sig_tesla_get_sign;
// key->gen_alice_shared_key = (dap_enc_gen_alice_shared_key) dap_enc_sig_tesla_verify_sign;
}
// generation key pair for sign Alice
// OUTPUT:
// a_key->data --- Alice's public key
// alice_priv --- Alice's private key
// alice_msg_len --- Alice's private key length
void dap_enc_sig_tesla_key_new_generate(struct dap_enc_key * key, const void *kex_buf,
size_t kex_size, const void * seed, size_t seed_size,
size_t key_size)
{
(void) kex_buf;
(void) kex_size;
(void) key_size;
int32_t retcode;
int tesla_type = (seed && seed_size >= sizeof(uint8_t)) ? ((uint8_t*)seed)[0] % (PROVABLY_MAX_SECURITY + 1) :
HEURISTIC_MAX_SECURITY_AND_MAX_SPEED;
dap_enc_sig_tesla_set_type(tesla_type);
/* type is a param of sign-security
* type = 0 - Heuristic qTESLA, NIST's security category 1
* type = 1 - Heuristic qTESLA, NIST's security category 3 (option for size)
* type = 2 - Heuristic qTESLA, NIST's security category 3 (option for speed)
* type = 3 - Provably-secure qTESLA, NIST's security category 1
* type = 4 - Provably-secure qTESLA, NIST's security category 3 (max security)
*/
//int32_t type = 2;
key->priv_key_data_size = sizeof(tesla_private_key_t);
key->pub_key_data_size = sizeof(tesla_public_key_t);
key->priv_key_data = malloc(key->priv_key_data_size);
key->pub_key_data = malloc(key->pub_key_data_size);
retcode = tesla_crypto_sign_keypair((tesla_public_key_t *) key->pub_key_data,
(tesla_private_key_t *) key->priv_key_data, _tesla_type, seed, seed_size);
if(retcode != 0) {
tesla_private_and_public_keys_delete((tesla_private_key_t *) key->pub_key_data,
(tesla_public_key_t *) key->pub_key_data);
log_it(L_CRITICAL, "Error");
return;
}
}
size_t dap_enc_sig_tesla_get_sign(struct dap_enc_key * key, const void * msg,
const size_t msg_size, void * signature, const size_t signature_size)
{
if(signature_size < sizeof(tesla_signature_t)) {
log_it(L_ERROR, "bad signature size");
return 0;
}
if(!tesla_crypto_sign((tesla_signature_t *) signature, (const unsigned char *) msg, msg_size, key->priv_key_data))
return signature_size;
else
return 0;
}
size_t dap_enc_sig_tesla_verify_sign(struct dap_enc_key * key, const void * msg,
const size_t msg_size, void * signature, const size_t signature_size)
{
if(signature_size < sizeof(tesla_signature_t)) {
log_it(L_ERROR, "bad signature size");
return 0;
}
return (tesla_crypto_sign_open((tesla_signature_t *) signature, (unsigned char *) msg, msg_size, key->pub_key_data));
}
void dap_enc_sig_tesla_key_delete(struct dap_enc_key * key)
{
tesla_private_and_public_keys_delete((tesla_private_key_t *) key->priv_key_data,
(tesla_public_key_t *) key->pub_key_data);
}
size_t dap_enc_tesla_calc_signature_size(void)
{
return sizeof(tesla_signature_t);
}
size_t dap_enc_tesla_calc_signature_serialized_size(tesla_signature_t* a_sign)
{
return sizeof(size_t) + sizeof(tesla_kind_t) + a_sign->sig_len + sizeof(unsigned long long);
}
/* Serialize a signature */
uint8_t* dap_enc_tesla_write_signature(tesla_signature_t* a_sign, size_t *a_sign_out)
{
if(!a_sign || *a_sign_out!=sizeof(tesla_signature_t)) {
return NULL ;
}
size_t l_shift_mem = 0;
size_t l_buflen = dap_enc_tesla_calc_signature_serialized_size(a_sign);
uint8_t *l_buf = DAP_NEW_SIZE(uint8_t, l_buflen);
memcpy(l_buf, &l_buflen, sizeof(size_t));
l_shift_mem += sizeof(size_t);
memcpy(l_buf + l_shift_mem, &a_sign->kind, sizeof(tesla_kind_t));
l_shift_mem += sizeof(tesla_kind_t);
memcpy(l_buf + l_shift_mem, &a_sign->sig_len, sizeof(unsigned long long));
l_shift_mem += sizeof(unsigned long long);
memcpy(l_buf + l_shift_mem, a_sign->sig_data, a_sign->sig_len );
l_shift_mem += a_sign->sig_len ;
if(a_sign_out)
*a_sign_out = l_buflen;
return l_buf;
}
/* Deserialize a signature */
tesla_signature_t* dap_enc_tesla_read_signature(uint8_t *a_buf, size_t a_buflen)
{
if(!a_buf || a_buflen < (sizeof(size_t) + sizeof(tesla_kind_t)))
return NULL ;
tesla_kind_t kind;
size_t l_buflen = 0;
memcpy(&l_buflen, a_buf, sizeof(size_t));
memcpy(&kind, a_buf + sizeof(size_t), sizeof(tesla_kind_t));
if(l_buflen != a_buflen)
return NULL ;
tesla_param_t p;
if(!tesla_params_init(&p, kind))
return NULL ;
tesla_signature_t* l_sign = DAP_NEW(tesla_signature_t);
l_sign->kind = kind;
size_t l_shift_mem = sizeof(size_t) + sizeof(tesla_kind_t);
memcpy(&l_sign->sig_len, a_buf + l_shift_mem, sizeof(unsigned long long));
l_shift_mem += sizeof(unsigned long long);
l_sign->sig_data = DAP_NEW_SIZE(unsigned char, l_sign->sig_len);
memcpy(l_sign->sig_data, a_buf + l_shift_mem, l_sign->sig_len);
l_shift_mem += l_sign->sig_len;
return l_sign;
}
/* Serialize a private key. */
uint8_t* dap_enc_tesla_write_private_key(const tesla_private_key_t* a_private_key, size_t *a_buflen_out)
{
tesla_param_t p;// = malloc(sizeof(tesla_param_t));
if(!tesla_params_init(&p, a_private_key->kind))
return NULL;
size_t l_buflen = sizeof(size_t) + sizeof(tesla_kind_t) + p.CRYPTO_SECRETKEYBYTES; //CRYPTO_PUBLICKEYBYTES;
uint8_t *l_buf = DAP_NEW_SIZE(uint8_t, l_buflen);
memcpy(l_buf, &l_buflen, sizeof(size_t));
memcpy(l_buf + sizeof(size_t), &a_private_key->kind, sizeof(tesla_kind_t));
memcpy(l_buf + sizeof(size_t) + sizeof(tesla_kind_t), a_private_key->data, p.CRYPTO_SECRETKEYBYTES);
if(a_buflen_out)
*a_buflen_out = l_buflen;
return l_buf;
}
/* Serialize a public key. */
uint8_t* dap_enc_tesla_write_public_key(const tesla_public_key_t* a_public_key, size_t *a_buflen_out)
{
tesla_param_t p;
if(!tesla_params_init(&p, a_public_key->kind))
return NULL;
size_t l_buflen = sizeof(size_t) + sizeof(tesla_kind_t) + p.CRYPTO_PUBLICKEYBYTES;
uint8_t *l_buf = DAP_NEW_SIZE(uint8_t, l_buflen);
memcpy(l_buf, &l_buflen, sizeof(size_t));
memcpy(l_buf + sizeof(size_t), &a_public_key->kind, sizeof(tesla_kind_t));
memcpy(l_buf + sizeof(size_t) + sizeof(tesla_kind_t), a_public_key->data, p.CRYPTO_PUBLICKEYBYTES);
if(a_buflen_out)
*a_buflen_out = l_buflen;
return l_buf;
}
/* Deserialize a private key. */
tesla_private_key_t* dap_enc_tesla_read_private_key(const uint8_t *a_buf, size_t a_buflen)
{
if(!a_buf || a_buflen < (sizeof(size_t) + sizeof(tesla_kind_t)))
return NULL;
tesla_kind_t kind;
size_t l_buflen = 0;
memcpy(&l_buflen, a_buf, sizeof(size_t));
memcpy(&kind, a_buf + sizeof(size_t), sizeof(tesla_kind_t));
if(l_buflen != a_buflen)
return NULL;
tesla_param_t p;
if(!tesla_params_init(&p, kind))
return NULL;
tesla_private_key_t* l_private_key = DAP_NEW(tesla_private_key_t);
l_private_key->kind = kind;
l_private_key->data = DAP_NEW_SIZE(unsigned char, p.CRYPTO_SECRETKEYBYTES);
memcpy(l_private_key->data, a_buf + sizeof(size_t) + sizeof(tesla_kind_t), p.CRYPTO_SECRETKEYBYTES);
return l_private_key;
}
/* Deserialize a public key. */
tesla_public_key_t* dap_enc_tesla_read_public_key(const uint8_t *a_buf, size_t a_buflen)
{
if(!a_buf || a_buflen < (sizeof(size_t) + sizeof(tesla_kind_t)))
return NULL;
tesla_kind_t kind;
size_t l_buflen = 0;
memcpy(&l_buflen, a_buf, sizeof(size_t));
memcpy(&kind, a_buf + sizeof(size_t), sizeof(tesla_kind_t));
if(l_buflen != a_buflen)
return NULL;
tesla_param_t p;
if(!tesla_params_init(&p, kind))
return NULL;
tesla_public_key_t* l_public_key = DAP_NEW(tesla_public_key_t);
l_public_key->kind = kind;
l_public_key->data = DAP_NEW_SIZE(unsigned char, p.CRYPTO_PUBLICKEYBYTES);
memcpy(l_public_key->data, a_buf + sizeof(size_t) + sizeof(tesla_kind_t), p.CRYPTO_PUBLICKEYBYTES);
return l_public_key;
}
#include <assert.h>
#include <inttypes.h>
#include <string.h>
#include "dap_enc_tesla.h"
#include "dap_common.h"
#include "dap_rand.h"
#define LOG_TAG "dap_enc_sig_tesla"
static enum DAP_TESLA_SIGN_SECURITY _tesla_type = HEURISTIC_MAX_SECURITY_AND_MAX_SPEED; // by default
void dap_enc_sig_tesla_set_type(enum DAP_TESLA_SIGN_SECURITY type)
{
_tesla_type = type;
}
void dap_enc_sig_tesla_key_new(struct dap_enc_key *key) {
key->type = DAP_ENC_KEY_TYPE_SIG_TESLA;
key->enc = NULL;
key->enc_na = (dap_enc_callback_dataop_na_t) dap_enc_sig_tesla_get_sign;
key->dec_na = (dap_enc_callback_dataop_na_t) dap_enc_sig_tesla_verify_sign;
// key->gen_bob_shared_key = (dap_enc_gen_bob_shared_key) dap_enc_sig_tesla_get_sign;
// key->gen_alice_shared_key = (dap_enc_gen_alice_shared_key) dap_enc_sig_tesla_verify_sign;
}
// generation key pair for sign Alice
// OUTPUT:
// a_key->data --- Alice's public key
// alice_priv --- Alice's private key
// alice_msg_len --- Alice's private key length
void dap_enc_sig_tesla_key_new_generate(struct dap_enc_key * key, const void *kex_buf,
size_t kex_size, const void * seed, size_t seed_size,
size_t key_size)
{
(void) kex_buf;
(void) kex_size;
(void) key_size;
int32_t retcode;
int tesla_type = (seed && seed_size >= sizeof(uint8_t)) ? ((uint8_t*)seed)[0] % (PROVABLY_MAX_SECURITY + 1) :
HEURISTIC_MAX_SECURITY_AND_MAX_SPEED;
dap_enc_sig_tesla_set_type(tesla_type);
/* type is a param of sign-security
* type = 0 - Heuristic qTESLA, NIST's security category 1
* type = 1 - Heuristic qTESLA, NIST's security category 3 (option for size)
* type = 2 - Heuristic qTESLA, NIST's security category 3 (option for speed)
* type = 3 - Provably-secure qTESLA, NIST's security category 1
* type = 4 - Provably-secure qTESLA, NIST's security category 3 (max security)
*/
//int32_t type = 2;
key->priv_key_data_size = sizeof(tesla_private_key_t);
key->pub_key_data_size = sizeof(tesla_public_key_t);
key->priv_key_data = malloc(key->priv_key_data_size);
key->pub_key_data = malloc(key->pub_key_data_size);
retcode = tesla_crypto_sign_keypair((tesla_public_key_t *) key->pub_key_data,
(tesla_private_key_t *) key->priv_key_data, _tesla_type, seed, seed_size);
if(retcode != 0) {
tesla_private_and_public_keys_delete((tesla_private_key_t *) key->pub_key_data,
(tesla_public_key_t *) key->pub_key_data);
log_it(L_CRITICAL, "Error");
return;
}
}
size_t dap_enc_sig_tesla_get_sign(struct dap_enc_key * key, const void * msg,
const size_t msg_size, void * signature, const size_t signature_size)
{
if(signature_size < sizeof(tesla_signature_t)) {
log_it(L_ERROR, "bad signature size");
return 0;
}
if(!tesla_crypto_sign((tesla_signature_t *) signature, (const unsigned char *) msg, msg_size, key->priv_key_data))
return signature_size;
else
return 0;
}
size_t dap_enc_sig_tesla_verify_sign(struct dap_enc_key * key, const void * msg,
const size_t msg_size, void * signature, const size_t signature_size)
{
if(signature_size < sizeof(tesla_signature_t)) {
log_it(L_ERROR, "bad signature size");
return 0;
}
return (tesla_crypto_sign_open((tesla_signature_t *) signature, (unsigned char *) msg, msg_size, key->pub_key_data));
}
void dap_enc_sig_tesla_key_delete(struct dap_enc_key * key)
{
tesla_private_and_public_keys_delete((tesla_private_key_t *) key->priv_key_data,
(tesla_public_key_t *) key->pub_key_data);
}
size_t dap_enc_tesla_calc_signature_size(void)
{
return sizeof(tesla_signature_t);
}
size_t dap_enc_tesla_calc_signature_serialized_size(tesla_signature_t* a_sign)
{
return sizeof(size_t) + sizeof(tesla_kind_t) + a_sign->sig_len + sizeof(unsigned long long);
}
/* Serialize a signature */
uint8_t* dap_enc_tesla_write_signature(tesla_signature_t* a_sign, size_t *a_sign_out)
{
if(!a_sign || *a_sign_out!=sizeof(tesla_signature_t)) {
return NULL ;
}
size_t l_shift_mem = 0;
size_t l_buflen = dap_enc_tesla_calc_signature_serialized_size(a_sign);
uint8_t *l_buf = DAP_NEW_SIZE(uint8_t, l_buflen);
memcpy(l_buf, &l_buflen, sizeof(size_t));
l_shift_mem += sizeof(size_t);
memcpy(l_buf + l_shift_mem, &a_sign->kind, sizeof(tesla_kind_t));
l_shift_mem += sizeof(tesla_kind_t);
memcpy(l_buf + l_shift_mem, &a_sign->sig_len, sizeof(unsigned long long));
l_shift_mem += sizeof(unsigned long long);
memcpy(l_buf + l_shift_mem, a_sign->sig_data, a_sign->sig_len );
l_shift_mem += a_sign->sig_len ;
if(a_sign_out)
*a_sign_out = l_buflen;
return l_buf;
}
/* Deserialize a signature */
tesla_signature_t* dap_enc_tesla_read_signature(uint8_t *a_buf, size_t a_buflen)
{
if(!a_buf || a_buflen < (sizeof(size_t) + sizeof(tesla_kind_t)))
return NULL ;
tesla_kind_t kind;
size_t l_buflen = 0;
memcpy(&l_buflen, a_buf, sizeof(size_t));
memcpy(&kind, a_buf + sizeof(size_t), sizeof(tesla_kind_t));
if(l_buflen != a_buflen)
return NULL ;
tesla_param_t p;
if(!tesla_params_init(&p, kind))
return NULL ;
tesla_signature_t* l_sign = DAP_NEW(tesla_signature_t);
l_sign->kind = kind;
size_t l_shift_mem = sizeof(size_t) + sizeof(tesla_kind_t);
memcpy(&l_sign->sig_len, a_buf + l_shift_mem, sizeof(unsigned long long));
l_shift_mem += sizeof(unsigned long long);
l_sign->sig_data = DAP_NEW_SIZE(unsigned char, l_sign->sig_len);
memcpy(l_sign->sig_data, a_buf + l_shift_mem, l_sign->sig_len);
l_shift_mem += l_sign->sig_len;
return l_sign;
}
/* Serialize a private key. */
uint8_t* dap_enc_tesla_write_private_key(const tesla_private_key_t* a_private_key, size_t *a_buflen_out)
{
tesla_param_t p;// = malloc(sizeof(tesla_param_t));
if(!tesla_params_init(&p, a_private_key->kind))
return NULL;
size_t l_buflen = sizeof(size_t) + sizeof(tesla_kind_t) + p.CRYPTO_SECRETKEYBYTES; //CRYPTO_PUBLICKEYBYTES;
uint8_t *l_buf = DAP_NEW_SIZE(uint8_t, l_buflen);
memcpy(l_buf, &l_buflen, sizeof(size_t));
memcpy(l_buf + sizeof(size_t), &a_private_key->kind, sizeof(tesla_kind_t));
memcpy(l_buf + sizeof(size_t) + sizeof(tesla_kind_t), a_private_key->data, p.CRYPTO_SECRETKEYBYTES);
if(a_buflen_out)
*a_buflen_out = l_buflen;
return l_buf;
}
/* Serialize a public key. */
uint8_t* dap_enc_tesla_write_public_key(const tesla_public_key_t* a_public_key, size_t *a_buflen_out)
{
tesla_param_t p;
if(!tesla_params_init(&p, a_public_key->kind))
return NULL;
size_t l_buflen = sizeof(size_t) + sizeof(tesla_kind_t) + p.CRYPTO_PUBLICKEYBYTES;
uint8_t *l_buf = DAP_NEW_SIZE(uint8_t, l_buflen);
memcpy(l_buf, &l_buflen, sizeof(size_t));
memcpy(l_buf + sizeof(size_t), &a_public_key->kind, sizeof(tesla_kind_t));
memcpy(l_buf + sizeof(size_t) + sizeof(tesla_kind_t), a_public_key->data, p.CRYPTO_PUBLICKEYBYTES);
if(a_buflen_out)
*a_buflen_out = l_buflen;
return l_buf;
}
/* Deserialize a private key. */
tesla_private_key_t* dap_enc_tesla_read_private_key(const uint8_t *a_buf, size_t a_buflen)
{
if(!a_buf || a_buflen < (sizeof(size_t) + sizeof(tesla_kind_t)))
return NULL;
tesla_kind_t kind;
size_t l_buflen = 0;
memcpy(&l_buflen, a_buf, sizeof(size_t));
memcpy(&kind, a_buf + sizeof(size_t), sizeof(tesla_kind_t));
if(l_buflen != a_buflen)
return NULL;
tesla_param_t p;
if(!tesla_params_init(&p, kind))
return NULL;
tesla_private_key_t* l_private_key = DAP_NEW(tesla_private_key_t);
l_private_key->kind = kind;
l_private_key->data = DAP_NEW_SIZE(unsigned char, p.CRYPTO_SECRETKEYBYTES);
memcpy(l_private_key->data, a_buf + sizeof(size_t) + sizeof(tesla_kind_t), p.CRYPTO_SECRETKEYBYTES);
return l_private_key;
}
/* Deserialize a public key. */
tesla_public_key_t* dap_enc_tesla_read_public_key(const uint8_t *a_buf, size_t a_buflen)
{
if(!a_buf || a_buflen < (sizeof(size_t) + sizeof(tesla_kind_t)))
return NULL;
tesla_kind_t kind;
size_t l_buflen = 0;
memcpy(&l_buflen, a_buf, sizeof(size_t));
memcpy(&kind, a_buf + sizeof(size_t), sizeof(tesla_kind_t));
if(l_buflen != a_buflen)
return NULL;
tesla_param_t p;
if(!tesla_params_init(&p, kind))
return NULL;
tesla_public_key_t* l_public_key = DAP_NEW(tesla_public_key_t);
l_public_key->kind = kind;
l_public_key->data = DAP_NEW_SIZE(unsigned char, p.CRYPTO_PUBLICKEYBYTES);
memcpy(l_public_key->data, a_buf + sizeof(size_t) + sizeof(tesla_kind_t), p.CRYPTO_PUBLICKEYBYTES);
return l_public_key;
}
src/dap_hash.c
View file @ fb1c4cbf
......@@ -42,12 +42,14 @@ int dap_chain_str_to_hash_fast( const char * a_hash_str, dap_chain_hash_fast_t *
const size_t c_hash_str_size = sizeof(*a_hash) * 2 + 1 /*trailing zero*/+ 2 /* heading 0x */;
size_t l_hash_str_len = strlen( a_hash_str);
if ( l_hash_str_len + 1 == c_hash_str_size ){
for (size_t l_offset = 2; l_offset < l_hash_str_len; l_offset+=2 ){
if ( ( sscanf(a_hash_str+l_offset,"%02hhx",a_hash->raw+l_offset/2-1) != 1) ||
( sscanf(a_hash_str+l_offset,"%02hhX",a_hash->raw+l_offset/2-1) != 1)
)
log_it(L_ERROR,"dap_chain_str_to_hash_fast parse error: offset=%u, hash_str_len=%u, str=\"%2s\"",l_offset, l_hash_str_len, a_hash_str+l_offset);
return -10* ((int) l_offset); // Wrong char
for(size_t l_offset = 2; l_offset < l_hash_str_len; l_offset += 2) {
if(sscanf(a_hash_str + l_offset, "%02hhx", a_hash->raw + l_offset / 2 - 1) != 1) {
if(sscanf(a_hash_str + l_offset, "%02hhX", a_hash->raw + l_offset / 2 - 1) != 1) {
log_it(L_ERROR, "dap_chain_str_to_hash_fast parse error: offset=%u, hash_str_len=%u, str=\"%2s\"",
l_offset, l_hash_str_len, a_hash_str + l_offset);
return -10 * ((int) l_offset); // Wrong char
}
}
}
return 0;
}else // Wromg string len
......
src/dap_sign.c
View file @ fb1c4cbf
......@@ -25,6 +25,7 @@
#include <string.h>
#include "dap_common.h"
#include "dap_strfuncs.h"
#include "dap_hash.h"
#include "dap_sign.h"
#include "dap_enc_bliss.h"
......@@ -34,12 +35,16 @@
#define LOG_TAG "dap_sign"
static dap_sign_t * s_sign_null = NULL;
//static dap_sign_t * s_sign_null = NULL;
static bliss_signature_t s_sign_bliss_null = {0};
// calc signature size
size_t dap_sign_create_output_unserialized_calc_size(dap_enc_key_t * a_key, size_t a_output_wish_size )
{
(void)a_output_wish_size;
if(!a_key)
return 0;
size_t l_sign_size = 0;
switch (a_key->type){
case DAP_ENC_KEY_TYPE_SIG_BLISS: l_sign_size = sizeof(s_sign_bliss_null); break;
......@@ -102,6 +107,8 @@ const char * dap_sign_type_to_str(dap_sign_type_t a_chain_sign_type)
case SIG_TYPE_TESLA: return "sig_tesla";
case SIG_TYPE_PICNIC: return "sig_picnic";
case SIG_TYPE_DILITHIUM: return "sig_dil";
case SIG_TYPE_MULTI_COMBINED: return "sig_multi2";
case SIG_TYPE_MULTI_CHAINED: return "sig_multi";
default: return "UNDEFINED";//DAP_ENC_KEY_TYPE_NULL;
}
......@@ -120,7 +127,7 @@ dap_sign_type_t dap_pkey_type_from_sign( dap_pkey_type_t a_pkey_type)
case PKEY_TYPE_SIGN_PICNIC: l_sign_type.type = SIG_TYPE_PICNIC; break;
case PKEY_TYPE_SIGN_TESLA: l_sign_type.type = SIG_TYPE_TESLA; break;
case PKEY_TYPE_SIGN_DILITHIUM : l_sign_type.type = SIG_TYPE_DILITHIUM; break;
case PKEY_TYPE_MULTI: l_sign_type.type = SIG_TYPE_MULTI; break;
case PKEY_TYPE_MULTI: l_sign_type.type = SIG_TYPE_MULTI_CHAINED; break;
case PKEY_TYPE_NULL: l_sign_type.type = SIG_TYPE_NULL; break;
}
return l_sign_type;
......@@ -143,6 +150,10 @@ dap_sign_type_t dap_sign_type_from_str(const char * a_type_str)
l_sign_type.type = SIG_TYPE_PICNIC;
}else if ( dap_strcmp (a_type_str,"sig_dil") == 0){
l_sign_type.type = SIG_TYPE_DILITHIUM;
}else if ( dap_strcmp (a_type_str,"sig_multi") == 0){
l_sign_type.type = SIG_TYPE_MULTI_CHAINED;
}else if ( dap_strcmp (a_type_str,"sig_multi2") == 0){
l_sign_type.type = SIG_TYPE_MULTI_COMBINED;
}else{
log_it(L_WARNING, "Wrong sign type string \"%s\"", a_type_str ? a_type_str : "(null)");
}
......@@ -169,11 +180,10 @@ static int dap_sign_create_output(dap_enc_key_t *a_key, const void * a_data, con
case DAP_ENC_KEY_TYPE_SIG_PICNIC:
case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
// For PICNIC a_output_size should decrease
*a_output_size = dap_enc_sig_dilithium_get_sign(a_key,a_data,a_data_size,a_output,sizeof(dilithium_signature_t));
// a_key->enc_na(a_key, a_data, a_data_size, a_output, *a_output_size);
//*a_output_size = dap_enc_sig_dilithium_get_sign(a_key,a_data,a_data_size,a_output,sizeof(dilithium_signature_t));
a_key->enc_na(a_key, a_data, a_data_size, a_output, *a_output_size);
return (*a_output_size > 0) ? 0 : -1;
case DAP_ENC_KEY_TYPE_SIG_BLISS:
return (dap_enc_sig_bliss_get_sign(a_key, a_data, a_data_size, a_output, *a_output_size) == BLISS_B_NO_ERROR)
? 0 : -1;
......@@ -308,33 +318,51 @@ dap_enc_key_t *dap_sign_to_enc_key(dap_sign_t * a_chain_sign)
int dap_sign_verify(dap_sign_t * a_chain_sign, const void * a_data, const size_t a_data_size)
{
int l_ret;
if (!a_chain_sign || !a_data)
return -2;
dap_enc_key_t * l_key = dap_sign_to_enc_key(a_chain_sign);
size_t l_sign_size = a_chain_sign->header.sign_size;
size_t l_sign_ser_size;
uint8_t *l_sign_ser = dap_sign_get_sign(a_chain_sign, &l_sign_ser_size);
if ( ! l_key ){
log_it(L_WARNING,"Incorrect signature, can't extract key");
return -3;
}
size_t l_sign_data_ser_size;
uint8_t *l_sign_data_ser = dap_sign_get_sign(a_chain_sign, &l_sign_data_ser_size);
if ( ! l_sign_data_ser ){
log_it(L_WARNING,"Incorrect signature, can't extract serialized signature's data ");
return -4;
}
size_t l_sign_data_size = a_chain_sign->header.sign_size;
// deserialize signature
uint8_t * l_sign = dap_enc_key_deserealize_sign(l_key->type, l_sign_ser, &l_sign_size);
uint8_t * l_sign_data = dap_enc_key_deserealize_sign(l_key->type, l_sign_data_ser, &l_sign_data_size);
if ( ! l_sign_data ){
log_it(L_WARNING,"Incorrect signature, can't deserialize signature's data");
return -5;
}
//uint8_t * l_sign = a_chain_sign->pkey_n_sign + a_chain_sign->header.sign_pkey_size;
switch (l_key->type) {
case DAP_ENC_KEY_TYPE_SIG_TESLA:
case DAP_ENC_KEY_TYPE_SIG_PICNIC:
case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
if(l_key->dec_na(l_key, a_data, a_data_size, l_sign, l_sign_size) > 0)
l_ret = 0;
else
l_ret = 1;
break;
case DAP_ENC_KEY_TYPE_SIG_BLISS:
if(dap_enc_sig_bliss_verify_sign(l_key, a_data, a_data_size, l_sign, l_sign_size) != BLISS_B_NO_ERROR)
l_ret = 0;
else
l_ret = 1;
break;
default:
l_ret = -1;
}
dap_enc_key_signature_delete(l_key->type, l_sign);
case DAP_ENC_KEY_TYPE_SIG_TESLA:
case DAP_ENC_KEY_TYPE_SIG_PICNIC:
case DAP_ENC_KEY_TYPE_SIG_DILITHIUM:
if(l_key->dec_na(l_key, a_data, a_data_size, l_sign_data, l_sign_data_size) > 0)
l_ret = 0;
else
l_ret = 1;
break;
case DAP_ENC_KEY_TYPE_SIG_BLISS:
if(dap_enc_sig_bliss_verify_sign(l_key, a_data, a_data_size, l_sign_data, l_sign_data_size) != BLISS_B_NO_ERROR)
l_ret = 0;
else
l_ret = 1;
break;
default:
l_ret = -6;
}
dap_enc_key_signature_delete(l_key->type, l_sign_data);
dap_enc_key_delete(l_key);
return l_ret;
}
......@@ -348,3 +376,406 @@ size_t dap_sign_get_size(dap_sign_t * a_chain_sign)
return 0;
return (sizeof(dap_sign_t) + a_chain_sign->header.sign_size + a_chain_sign->header.sign_pkey_size);
}
/**
* @brief dap_multi_sign_calc_size Auxiliary function to calculate multi-signature strucrutre size
* @param a_sign The multi-signature
* @return Multi-signature size
*/
size_t dap_multi_sign_calc_size(dap_multi_sign_t *a_sign)
{
if (!a_sign)
return 0;
size_t l_meta_data_size = sizeof(dap_sign_type_t) + 2 * sizeof(uint8_t) +
a_sign->sign_count * (sizeof(dap_multi_sign_keys_t) + sizeof(dap_multi_sign_meta_t));
size_t l_pkeys_hashes_size = a_sign->total_count * sizeof(dap_chain_hash_fast_t);
size_t l_pkeys_size = 0, l_signes_size = 0;
for (int i = 0; i < a_sign->sign_count; i++) {
l_pkeys_size += a_sign->meta[i].pkey_size;
l_signes_size += a_sign->meta[i].sign_size;
}
return l_meta_data_size + l_pkeys_hashes_size + l_pkeys_size + l_signes_size;
}
/**
* @brief dap_multi_sign_serialize Makes a serialization for multi-signature structure
* @param a_sign Pointer to multi-signature
* @param a_out_len OUT Output data lenght
* @return Pointer to serialized data
*/
uint8_t *dap_multi_sign_serialize(dap_multi_sign_t *a_sign, size_t *a_out_len)
{
if (a_sign->type.type != SIG_TYPE_MULTI_CHAINED) {
log_it(L_ERROR, "Unsupported multi-signature type");
return NULL;
}
*a_out_len = dap_multi_sign_calc_size(a_sign) + sizeof(size_t);
uint8_t *l_ret = DAP_NEW_SIZE(uint8_t, *a_out_len);
size_t l_mem_shift = 0;
memcpy(l_ret, a_out_len, sizeof(size_t));
l_mem_shift += sizeof(size_t);
memcpy(&l_ret[l_mem_shift], &a_sign->type, sizeof(dap_sign_type_t));
l_mem_shift += sizeof(dap_sign_type_t);
memcpy(&l_ret[l_mem_shift], &a_sign->total_count, 1);
l_mem_shift++;
memcpy(&l_ret[l_mem_shift], &a_sign->sign_count, 1);
l_mem_shift++;
for (int i = 0; i < a_sign->sign_count; i++) {
memcpy(&l_ret[l_mem_shift], &a_sign->key_seq[i].num, 1);
l_mem_shift++;
memcpy(&l_ret[l_mem_shift], &a_sign->key_seq[i].type, sizeof(dap_sign_type_t));
l_mem_shift += sizeof(dap_sign_type_t);
}
for (int i = 0; i < a_sign->sign_count; i++) {
memcpy(&l_ret[l_mem_shift], &a_sign->meta[i].pkey_size, sizeof(uint32_t));
l_mem_shift += sizeof(uint32_t);
memcpy(&l_ret[l_mem_shift], &a_sign->meta[i].sign_size, sizeof(uint32_t));
l_mem_shift += sizeof(uint32_t);
}
for (int i = 0; i < a_sign->total_count; i++) {
memcpy(&l_ret[l_mem_shift], &a_sign->key_hashes[i], sizeof(dap_chain_hash_fast_t));
l_mem_shift += sizeof(dap_chain_hash_fast_t);
}
uint32_t l_data_shift = 0, l_data_size = 0;
for (int i = 0; i < a_sign->sign_count; i++) {
l_data_size = a_sign->meta[i].pkey_size;
memcpy(&l_ret[l_mem_shift], &a_sign->pub_keys[l_data_shift], l_data_size);
l_mem_shift += l_data_size;
l_data_shift += l_data_size;
}
l_data_shift = l_data_size = 0;
for (int i = 0; i < a_sign->sign_count; i++) {
l_data_size = a_sign->meta[i].sign_size;
memcpy(&l_ret[l_mem_shift], &a_sign->sign_data[l_data_shift], l_data_size);
l_mem_shift += l_data_size;
l_data_shift += l_data_size;
}
return l_ret;
}
/**
* @brief dap_multi_sign_deserialize Makes a deserialization for multi-signature structure
* @param a_sign Pointer to serialized data
* @param a_sign_len Input data lenght
* @return Pointer to multi-signature
*/
dap_multi_sign_t *dap_multi_sign_deserialize(dap_sign_type_enum_t a_type, uint8_t *a_sign, size_t a_sign_len)
{
if (a_type != SIG_TYPE_MULTI_CHAINED) {
log_it(L_ERROR, "Unsupported multi-signature type");
return NULL;
}
size_t l_sign_len = *(size_t *)a_sign;
if (l_sign_len != a_sign_len) {
return NULL;
}
dap_multi_sign_t *l_sign = DAP_NEW(dap_multi_sign_t);
size_t l_mem_shift = sizeof(size_t);
memcpy(&l_sign->type, &a_sign[l_mem_shift], sizeof(dap_sign_type_t));
l_mem_shift += sizeof(dap_sign_type_t);
memcpy(&l_sign->total_count, &a_sign[l_mem_shift], 1);
l_mem_shift++;
memcpy(&l_sign->sign_count, &a_sign[l_mem_shift], 1);
l_mem_shift++;
l_sign->key_seq = DAP_NEW_SIZE(dap_multi_sign_keys_t, l_sign->sign_count * sizeof(dap_multi_sign_keys_t));
for (int i = 0; i < l_sign->sign_count; i++) {
memcpy(&l_sign->key_seq[i].num, &a_sign[l_mem_shift], 1);
l_mem_shift++;
memcpy(&l_sign->key_seq[i].type, &a_sign[l_mem_shift], sizeof(dap_sign_type_t));
l_mem_shift += sizeof(dap_sign_type_t);
}
l_sign->meta = DAP_NEW_SIZE(dap_multi_sign_meta_t, l_sign->sign_count * sizeof(dap_multi_sign_meta_t));
size_t l_pkeys_size = 0, l_signes_size = 0;
for (int i = 0; i < l_sign->sign_count; i++) {
memcpy(&l_sign->meta[i].pkey_size, &a_sign[l_mem_shift], sizeof(uint32_t));
l_mem_shift += sizeof(uint32_t);
l_pkeys_size += l_sign->meta[i].pkey_size;
memcpy(&l_sign->meta[i].sign_size, &a_sign[l_mem_shift], sizeof(uint32_t));
l_mem_shift += sizeof(uint32_t);
l_signes_size += l_sign->meta[i].sign_size;
}
l_sign->key_hashes = DAP_NEW_SIZE(dap_chain_hash_fast_t, l_sign->total_count * sizeof(dap_chain_hash_fast_t));
for (int i = 0; i < l_sign->total_count; i++) {
memcpy(&l_sign->key_hashes[i], &a_sign[l_mem_shift], sizeof(dap_chain_hash_fast_t));
l_mem_shift += sizeof(dap_chain_hash_fast_t);
}
uint32_t l_data_shift = 0, l_data_size = 0;
l_sign->pub_keys = DAP_NEW_SIZE(uint8_t, l_pkeys_size);
for (int i = 0; i < l_sign->sign_count; i++) {
l_data_size = l_sign->meta[i].pkey_size;
memcpy( &l_sign->pub_keys[l_data_shift], &a_sign[l_mem_shift],l_data_size);
l_mem_shift += l_data_size;
l_data_shift += l_data_size;
}
l_data_shift = l_data_size = 0;
l_sign->sign_data = DAP_NEW_SIZE(uint8_t, l_signes_size);
for (int i = 0; i < l_sign->sign_count; i++) {
l_data_size = l_sign->meta[i].sign_size;
memcpy(&l_sign->sign_data[l_data_shift], &a_sign[l_mem_shift], l_data_size);
l_mem_shift += l_data_size;
l_data_shift += l_data_size;
}
return l_sign;
}
/**
* @brief dap_multi_sign_params_make Auxiliary function which helps fill multi-signature params structure
* @param a_type Type of multi-signature
* @param a_total_count Number of total key count
* @param a_sign_count Number of keys participating in multi-signing algorithm
* @param a_key[1 .. total_count] Set of keys
* @param a_num[1 .. sign_count] Signing keys sequence
* @return Pointer to multi-signature params structure
*/
dap_multi_sign_params_t *dap_multi_sign_params_make(dap_sign_type_enum_t a_type, uint8_t a_total_count, uint8_t a_sign_count, dap_enc_key_t *a_key1, ...)
{
dap_multi_sign_params_t *l_params = DAP_NEW(dap_multi_sign_params_t);
l_params->type.type = a_type;
l_params->total_count = a_total_count;
l_params->keys = DAP_NEW_SIZE(dap_enc_key_t *, a_total_count * sizeof(dap_enc_key_t *));
l_params->sign_count = a_sign_count;
l_params->key_seq = DAP_NEW_SIZE(uint8_t, a_sign_count);
l_params->keys[0] = a_key1;
va_list list;
va_start(list, a_key1);
for (int i = 1; i < a_total_count; i++) {
l_params->keys[i] = va_arg(list, dap_enc_key_t *);
}
for (int i = 0; i < a_sign_count; i++) {
l_params->key_seq[i] = va_arg(list, int) - 1;
}
va_end(list);
return l_params;
}
/**
* @brief dap_multi_sign_delete Destroy multi-signature params structure
* @param a_sign Pointer to multi-signature params structure to destroy
* @return None
*/
void dap_multi_sign_params_delete(dap_multi_sign_params_t *a_params)
{
if (!a_params)
return;
if (a_params->key_seq) {
DAP_DELETE(a_params->key_seq);
}
if (a_params->keys) {
DAP_DELETE(a_params->keys);
}
DAP_DELETE(a_params);
}
/**
* @brief dap_multi_sign_hash_data Make multi-signature hash for specified message
* @param a_sign Pointer to multi-signature structure
* @param a_data Pointer to message to be signed with this multi-signature
* @param a_data_size Message size
* @param a_hash OUT Pointer to calculated hash
* @return True if success, overwise return false
*/
bool dap_multi_sign_hash_data(dap_multi_sign_t *a_sign, const void *a_data, const size_t a_data_size, dap_chain_hash_fast_t *a_hash)
{
uint8_t *l_concatenated_hash = DAP_NEW_SIZE(uint8_t, 3 * sizeof(dap_chain_hash_fast_t));
if (!dap_hash_fast(a_data, a_data_size, a_hash)) {
DAP_DELETE(l_concatenated_hash);
return false;
}
memcpy(l_concatenated_hash, a_hash, sizeof(dap_chain_hash_fast_t));
uint32_t l_meta_data_size = sizeof(dap_sign_type_t) + 2 * sizeof(uint8_t) + a_sign->sign_count * sizeof(dap_multi_sign_keys_t);
uint8_t *l_meta_data = DAP_NEW_SIZE(uint8_t, l_meta_data_size);
int l_meta_data_mem_shift = 0;
memcpy(l_meta_data, &a_sign->type, sizeof(dap_sign_type_t));
l_meta_data_mem_shift += sizeof(dap_sign_type_t);
l_meta_data[l_meta_data_mem_shift++] = a_sign->total_count;
l_meta_data[l_meta_data_mem_shift++] = a_sign->sign_count;
memcpy(&l_meta_data[l_meta_data_mem_shift], a_sign->key_seq, a_sign->sign_count * sizeof(dap_multi_sign_keys_t));
if (!dap_hash_fast(l_meta_data, l_meta_data_size, a_hash)) {
DAP_DELETE(l_meta_data);
DAP_DELETE(l_concatenated_hash);
return false;
}
DAP_DELETE(l_meta_data);
memcpy(l_concatenated_hash + sizeof(dap_chain_hash_fast_t), a_hash, sizeof(dap_chain_hash_fast_t));
if (!dap_hash_fast(a_sign->key_hashes, a_sign->total_count * sizeof(dap_chain_hash_fast_t), a_hash)) {
DAP_DELETE(l_concatenated_hash);
return false;
}
memcpy(l_concatenated_hash + 2 * sizeof(dap_chain_hash_fast_t), a_hash, sizeof(dap_chain_hash_fast_t));
if (!dap_hash_fast(l_concatenated_hash, 3 * sizeof(dap_chain_hash_fast_t), a_hash)) {
DAP_DELETE(l_concatenated_hash);
return false;
}
DAP_DELETE(l_concatenated_hash);
return true;
}
/**
* @brief dap_multi_sign_create Make multi-signature for specified message
* @param a_params Pointer to multi-signature params structure
* @param a_data Pointer to message to be signed with this multi-signature
* @param a_data_size Message size
* @return Pointer to multi-signature structure for specified message
*/
dap_multi_sign_t *dap_multi_sign_create(dap_multi_sign_params_t *a_params, const void *a_data, const size_t a_data_size)
{
if (a_params->type.type != SIG_TYPE_MULTI_CHAINED) {
log_it (L_ERROR, "Unsupported multi-signature type");
return NULL;
}
if (!a_params || !a_params->total_count) {
log_it (L_ERROR, "Wrong parameters of multi-signature");
return NULL;
}
dap_multi_sign_t *l_sign = DAP_NEW_Z(dap_multi_sign_t);
l_sign->type = a_params->type;
l_sign->total_count = a_params->total_count;
l_sign->key_hashes = DAP_NEW_SIZE(dap_chain_hash_fast_t, a_params->total_count * sizeof(dap_chain_hash_fast_t));
for (int i = 0; i < a_params->total_count; i++) {
if (!dap_hash_fast(a_params->keys[i]->pub_key_data, a_params->keys[i]->pub_key_data_size, &l_sign->key_hashes[i])) {
log_it (L_ERROR, "Can't create multi-signature hash");
dap_multi_sign_delete(l_sign);
return NULL;
}
}
l_sign->sign_count = a_params->sign_count;
l_sign->key_seq = DAP_NEW_SIZE(dap_multi_sign_keys_t, a_params->sign_count * sizeof(dap_multi_sign_keys_t));
l_sign->meta = DAP_NEW_SIZE(dap_multi_sign_meta_t, a_params->sign_count * sizeof(dap_multi_sign_meta_t));
for (int i = 0; i < l_sign->sign_count; i++) {
uint8_t l_num = a_params->key_seq[i];
l_sign->key_seq[i].num = l_num;
l_sign->key_seq[i].type = dap_sign_type_from_key_type(a_params->keys[l_num]->type);
}
uint32_t l_pkeys_mem_shift = 0, l_signs_mem_shift = 0;
size_t l_pkey_size, l_sign_size;
dap_chain_hash_fast_t l_data_hash;
bool l_hashed;
for (int i = 0; i < l_sign->sign_count; i++) {
if (i == 0) {
l_hashed = dap_multi_sign_hash_data(l_sign, a_data, a_data_size, &l_data_hash);
} else {
l_hashed = dap_hash_fast(&l_sign->sign_data[l_signs_mem_shift], l_sign_size, &l_data_hash);
l_signs_mem_shift += l_sign_size;
}
if (!l_hashed) {
log_it (L_ERROR, "Can't create multi-signature hash");
dap_multi_sign_delete(l_sign);
return NULL;
}
int l_num = l_sign->key_seq[i].num;
dap_sign_t *l_dap_sign_step = dap_sign_create(a_params->keys[l_num], &l_data_hash, sizeof(dap_chain_hash_fast_t), 0);
if (!l_dap_sign_step) {
log_it (L_ERROR, "Can't create multi-signature step signature");
dap_multi_sign_delete(l_sign);
return NULL;
}
uint8_t *l_pkey = dap_sign_get_pkey(l_dap_sign_step, &l_pkey_size);
l_sign->meta[i].pkey_size = l_pkey_size;
if (l_pkeys_mem_shift == 0) {
l_sign->pub_keys = DAP_NEW_SIZE(uint8_t, l_pkey_size);
} else {
l_sign->pub_keys = DAP_REALLOC(l_sign->pub_keys, l_pkeys_mem_shift + l_pkey_size);
}
memcpy(&l_sign->pub_keys[l_pkeys_mem_shift], l_pkey, l_pkey_size);
l_pkeys_mem_shift += l_pkey_size;
uint8_t *l_sign_step = dap_sign_get_sign(l_dap_sign_step, &l_sign_size);
l_sign->meta[i].sign_size = l_sign_size;
if (l_signs_mem_shift == 0) {
l_sign->sign_data = DAP_NEW_SIZE(uint8_t, l_sign_size);
} else {
l_sign->sign_data = DAP_REALLOC(l_sign->sign_data, l_signs_mem_shift + l_sign_size);
}
memcpy(&l_sign->sign_data[l_signs_mem_shift], l_sign_step, l_sign_size);
DAP_DELETE(l_dap_sign_step);
}
return l_sign;
}
/**
* @brief dap_multi_sign_verify Make verification test for multi-signed message
* @param a_sign Pointer to multi-signature structure
* @param a_data Pointer to message signed with this multi-signature
* @param a_data_size Signed message size
* @return 1 valid signature, 0 invalid signature, -1 verification error
*/
int dap_multi_sign_verify(dap_multi_sign_t *a_sign, const void *a_data, const size_t a_data_size)
{
if (!a_sign || !a_data)
return -1;
if (a_sign->type.type != SIG_TYPE_MULTI_CHAINED) {
log_it (L_ERROR, "Unsupported multi-signature type");
return -1;
}
if (!a_sign->pub_keys || !a_sign->sign_data || !a_sign->key_hashes || !a_sign->meta || !a_sign->key_seq) {
log_it (L_ERROR, "Invalid multi-signature format");
return -1;
}
uint32_t l_pkeys_mem_shift = 0, l_signs_mem_shift = 0;
for (int i = 0; i < a_sign->sign_count - 1; i++) {
l_pkeys_mem_shift += a_sign->meta[i].pkey_size;
l_signs_mem_shift += a_sign->meta[i].sign_size;
}
dap_chain_hash_fast_t l_data_hash;
bool l_hashed;
int l_verified = 0;
for (int i = a_sign->sign_count - 1; i >= 0; i--) {
size_t l_pkey_size = a_sign->meta[i].pkey_size;
size_t l_sign_size = a_sign->meta[i].sign_size;
dap_sign_t *l_step_sign = DAP_NEW_Z_SIZE(dap_sign_t,
sizeof(dap_sign_hdr_t) + l_pkey_size + l_sign_size);
l_step_sign->header.type = a_sign->key_seq[i].type;
l_step_sign->header.sign_pkey_size = l_pkey_size;
l_step_sign->header.sign_size = l_sign_size;
memcpy(l_step_sign->pkey_n_sign, &a_sign->pub_keys[l_pkeys_mem_shift], l_pkey_size);
if (i > 0) {
l_pkeys_mem_shift -= a_sign->meta[i - 1].pkey_size;
}
memcpy(&l_step_sign->pkey_n_sign[l_pkey_size], &a_sign->sign_data[l_signs_mem_shift], l_sign_size);
if (i > 0) {
l_signs_mem_shift -= a_sign->meta[i - 1].sign_size;
}
if (i ==0) {
l_hashed = dap_multi_sign_hash_data(a_sign, a_data, a_data_size, &l_data_hash);
} else {
l_hashed = dap_hash_fast(&a_sign->sign_data[l_signs_mem_shift], a_sign->meta[i - 1].sign_size, &l_data_hash);
}
if (!l_hashed) {
log_it (L_ERROR, "Can't create multi-signature hash");
return -1;
}
l_verified = dap_sign_verify(l_step_sign, &l_data_hash, sizeof(dap_chain_hash_fast_t));
DAP_DELETE(l_step_sign);
if (l_verified != 1) {
return l_verified;
}
}
return l_verified;
}
/**
* @brief dap_multi_sign_delete Destroy multi-signature structure
* @param a_sign Pointer to multi-signature structure to destroy
* @return None
*/
void dap_multi_sign_delete(dap_multi_sign_t *a_sign)
{
if (!a_sign)
return;
if (a_sign->sign_data) {
DAP_DELETE(a_sign->sign_data);
}
if (a_sign->pub_keys) {
DAP_DELETE(a_sign->pub_keys);
}
if (a_sign->key_hashes) {
DAP_DELETE(a_sign->key_hashes);
}
if (a_sign->meta) {
DAP_DELETE(a_sign->meta);
}
if (a_sign->key_seq) {
DAP_DELETE(a_sign->key_seq);
}
DAP_DELETE(a_sign);
}
src/iaes/dap_iaes_proto.h
View file @ fb1c4cbf
......@@ -6,6 +6,10 @@
#define IAES_BLOCK_SIZE 16
#define IAES_KEYSIZE 32
void AES256_enc_cernelT(uint32_t * in, uint32_t * out, uint32_t * masterkey);
void AES256_dec_cernelT(uint32_t * in, uint32_t * out, uint32_t * decr_key);
void swap_endian(uint32_t *buff, unsigned long len);
void Key_Shedule_for_decrypT(uint32_t * key, uint32_t * rounds_keys);
void IAES_256_CBC_encrypt(const uint8_t *data, uint8_t *output, uint8_t * ivec, unsigned long length, uint8_t *masterkey);
size_t IAES_256_CBC_decrypt(const uint8_t *cdata, uint8_t *output, uint8_t * ivec, unsigned long length, uint8_t *key);
......
src/iaes/iaes256_cbc_cernal.c
View file @ fb1c4cbf
......@@ -7,26 +7,12 @@
size_t iaes_calc_block128_size(size_t length_data)
{
if(length_data < IAES_BLOCK_SIZE) {
return IAES_BLOCK_SIZE;
} else if((length_data % IAES_BLOCK_SIZE) == 0) {
return length_data;
}
size_t padding = 16 - length_data % 16;
return length_data + padding;
size_t new_length_data = length_data + 1;
size_t padding = IAES_BLOCK_SIZE - new_length_data % IAES_BLOCK_SIZE;
new_length_data += padding;
return new_length_data;
}
size_t iaes_block128_padding(const void *data, uint8_t **data_new, size_t length_data)
{
size_t length_data_new = iaes_calc_block128_size(length_data);
*data_new = (uint8_t *) malloc(length_data_new);
memcpy(*data_new, data, length_data);
memset(*data_new + length_data, 0x0, length_data_new - length_data);
return length_data_new;
}
void swap_endian(uint32_t *buff, unsigned long len)
{
......@@ -214,7 +200,7 @@ void IAES_256_CBC_encrypt(const uint8_t *data, uint8_t *cdata, uint8_t *ivec, un
AES256_enc_cernelT(((uint32_t *)cdata + count_block * block_in32_size), feedback, (uint32_t *)masterkey);
memcpy ((uint32_t *)cdata + count_block * block_in32_size, &feedback[0], IAES_BLOCK_SIZE);
}
}
swap_endian((uint32_t *)masterkey,IAES_KEYSIZE/sizeof(uint32_t));
}
......@@ -487,19 +473,7 @@ size_t IAES_256_CBC_decrypt(const uint8_t *cdata, uint8_t *data, uint8_t *ivec,
memcpy(&feedback[0], (uint32_t *)cdata + count_block*block_in32_size, IAES_BLOCK_SIZE);
}
swap_endian((uint32_t *)masterkey, IAES_KEYSIZE/sizeof(uint32_t));
size_t i, padding = 0;
size_t end = length > 16 ? length - 16 : 0;
if(length>0)
for(i = length-1; i >= end; i--)
{
if(data[i] == 0)
padding++;
else
break;
}
return length - padding;
return length;
}
src/rand/dap_rand.c
View file @ fb1c4cbf
......@@ -18,6 +18,35 @@ static __inline void delay(unsigned int count)
while (count--) {}
}
uint32_t random_uint32_t(const uint32_t MAX_NUMBER)
{
uint32_t ret;
randombytes(&ret, 4);
ret %= MAX_NUMBER;
return ret;
}
int randombase64(void*random_array, unsigned int size)
{
int off = size - (size/4)*3;
int odd_signs = size - ((size/4)*4);
if(odd_signs < size)
{
randombytes(random_array + off, (size/4)*3);
dap_enc_base64_encode(random_array + off, (size/4)*3,random_array,DAP_ENC_DATA_TYPE_B64);
}
if(odd_signs)
{
uint8_t tmpv[7];
randombytes(tmpv+4,3);
dap_enc_base64_encode(tmpv + 4, 3,tmpv,DAP_ENC_DATA_TYPE_B64);
for(int i = 0; i < odd_signs; ++i)
{
((uint8_t*)random_array)[size - odd_signs + i] = tmpv[i];
}
}
}
int randombytes(void* random_array, unsigned int nbytes)
{ // Generation of "nbytes" of random values
......