mirrors/gnss-sdr
1
0
Fork 0
mirror of https://github.com/gnss-sdr/gnss-sdr synced 2024-10-30 14:46:23 +00:00
Code Issues Releases Wiki Activity

Merge branch 'osnma-cesare' of https://github.com/cesaaargm/osnma into osnma-cesare

Browse Source
This commit is contained in:
Carles Fernandez 2024-08-06 12:56:31 +02:00
commit fb2cb56903
No known key found for this signature in database
GPG Key ID: 4C583C52B0C3877D
2 changed files with 99 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
src/core/system_parameters/gnss_crypto.cc
View File

@ -794,13 +794,17 @@ std::vector<uint8_t> Gnss_Crypto::get_merkle_root() const
std::string Gnss_Crypto::get_public_key_type() const
{
if (d_PublicKeyType.empty())
{
return std::string("Unknown");
}
return d_PublicKeyType;
}
void Gnss_Crypto::set_public_key(const std::vector<uint8_t>& publicKey)
{
d_PublicKeyType = "Unknown";
d_PublicKeyType = std::string("Unknown");
#if USE_GNUTLS_FALLBACK
gnutls_pubkey_t pubkey{};
gnutls_ecc_curve_t curve;
@ -812,13 +816,13 @@ void Gnss_Crypto::set_public_key(const std::vector<uint8_t>& publicKey)
if (size_pk == 33)
{
curve = GNUTLS_ECC_CURVE_SECP256R1;
d_PublicKeyType = "ECDSA P-256";
d_PublicKeyType = std::string("ECDSA P-256");
decompress_public_key_secp256r1(publicKey, x, y);
}
else if (size_pk == 67)
{
curve = GNUTLS_ECC_CURVE_SECP521R1;
d_PublicKeyType = "ECDSA P-521";
d_PublicKeyType = std::string("ECDSA P-521");
decompress_public_key_secp521r1(publicKey, x, y);
}
else
@ -836,6 +840,7 @@ void Gnss_Crypto::set_public_key(const std::vector<uint8_t>& publicKey)
{
gnutls_pubkey_deinit(pubkey);
LOG(WARNING) << "GnuTLS: error setting the OSNMA public key: " << gnutls_strerror(ret);
d_PublicKeyType = std::string("Unknown");
return;
}
pubkey_copy(pubkey, &d_PublicKey);
@ -861,11 +866,11 @@ void Gnss_Crypto::set_public_key(const std::vector<uint8_t>& publicKey)
if (public_key_size == 33)
{
d_PublicKeyType = "ECDSA P-256";
d_PublicKeyType = std::string("ECDSA P-256");
}
else if (public_key_size == 67)
{
d_PublicKeyType = "ECDSA P-521";
d_PublicKeyType = std::string("ECDSA P-521");
}
ctx = EVP_PKEY_CTX_new_from_name(nullptr, "EC", nullptr);
@ -875,6 +880,7 @@ void Gnss_Crypto::set_public_key(const std::vector<uint8_t>& publicKey)
EVP_PKEY_CTX_free(ctx);
OSSL_PARAM_free(params);
OSSL_PARAM_BLD_free(param_bld);
d_PublicKeyType = std::string("Unknown");
return;
}
@ -884,6 +890,7 @@ void Gnss_Crypto::set_public_key(const std::vector<uint8_t>& publicKey)
EVP_PKEY_CTX_free(ctx);
OSSL_PARAM_free(params);
OSSL_PARAM_BLD_free(param_bld);
d_PublicKeyType = std::string("Unknown");
return;
}
@ -898,15 +905,16 @@ void Gnss_Crypto::set_public_key(const std::vector<uint8_t>& publicKey)
if (publicKey.size() == 33) // ECDSA-P-256
{
group = EC_GROUP_new_by_curve_name(NID_X9_62_prime256v1);
d_PublicKeyType = "ECDSA P-256";
d_PublicKeyType = std::string("ECDSA P-256");
}
else // ECDSA-P-521
{
group = EC_GROUP_new_by_curve_name(NID_secp521r1);
d_PublicKeyType = "ECDSA P-256";
d_PublicKeyType = std::string("ECDSA P-521");
}
if (!group)
{
d_PublicKeyType = std::string("Unknown");
return;
}
@ -914,6 +922,7 @@ void Gnss_Crypto::set_public_key(const std::vector<uint8_t>& publicKey)
if (!point)
{
EC_GROUP_free(group);
d_PublicKeyType = std::string("Unknown");
return;
}
@ -921,6 +930,7 @@ void Gnss_Crypto::set_public_key(const std::vector<uint8_t>& publicKey)
{
EC_GROUP_free(group);
EC_POINT_free(point);
d_PublicKeyType = std::string("Unknown");
return;
}
@ -936,18 +946,23 @@ void Gnss_Crypto::set_public_key(const std::vector<uint8_t>& publicKey)
{
EC_GROUP_free(group);
EC_POINT_free(point);
d_PublicKeyType = std::string("Unknown");
return;
}
if (!EC_KEY_set_public_key(ec_key, point))
{
EC_KEY_free(ec_key);
EC_POINT_free(point);
EC_GROUP_free(group);
d_PublicKeyType = std::string("Unknown");
return;
}
if (!pubkey_copy(ec_key, &d_PublicKey))
{
EC_KEY_free(ec_key);
EC_POINT_free(point);
EC_GROUP_free(group);
d_PublicKeyType = std::string("Unknown");
return;
}
EC_KEY_free(ec_key);
@ -1034,11 +1049,11 @@ void Gnss_Crypto::read_merkle_xml(const std::string& merkleFilePath)
LOG(INFO) << "OSNMA Merkletree - PK Type: " << pkType;
if (pkType == "ECDSA P-256/SHA-256")
{
d_PublicKeyType = "ECDSA P-256";
d_PublicKeyType = std::string("ECDSA P-256");
}
else if (pkType == "ECDSA P-521/SHA-512")
{
d_PublicKeyType = "ECDSA P-521";
d_PublicKeyType = std::string("ECDSA P-521");
}
}
for (pugi::xml_node treeNode : merkleTree.children("TreeNode"))
@ -1075,7 +1090,7 @@ void Gnss_Crypto::readPublicKeyFromPEM(const std::string& pemFilePath)
{
return;
}
d_PublicKeyType = "Unknown";
d_PublicKeyType = std::string("Unknown");
std::string pemContent((std::istreambuf_iterator<char>(pemFile)), std::istreambuf_iterator<char>());
#if USE_GNUTLS_FALLBACK
// Import the PEM data
@ -1108,8 +1123,7 @@ void Gnss_Crypto::readPublicKeyFromPEM(const std::string& pemFilePath)
}
pk_algorithm = static_cast<gnutls_pk_algorithm_t>(ret);
if (pk_algorithm == GNUTLS_PK_ECDSA)
if (pk_algorithm == GNUTLS_PK_ECC)
{
gnutls_ecc_curve_t curve;
ret = gnutls_pubkey_export_ecc_raw(pubkey, &curve, nullptr, nullptr);
@ -1122,11 +1136,11 @@ void Gnss_Crypto::readPublicKeyFromPEM(const std::string& pemFilePath)
if (curve == GNUTLS_ECC_CURVE_SECP256R1)
{
d_PublicKeyType = "ECDSA P-256";
d_PublicKeyType = std::string("ECDSA P-256");
}
else if (curve == GNUTLS_ECC_CURVE_SECP521R1)
{
d_PublicKeyType = "ECDSA P-521";
d_PublicKeyType = std::string("ECDSA P-521");
}
else
{
@ -1168,11 +1182,11 @@ void Gnss_Crypto::readPublicKeyFromPEM(const std::string& pemFilePath)
{
if (strcmp(curve_name, "prime256v1") == 0 || strcmp(curve_name, "P-256") == 0)
{
d_PublicKeyType = "ECDSA P-256";
d_PublicKeyType = std::string("ECDSA P-256");
}
else if (strcmp(curve_name, "secp521r1") == 0 || strcmp(curve_name, "P-521") == 0)
{
d_PublicKeyType = "ECDSA P-521";
d_PublicKeyType = std::string("ECDSA P-521");
}
else
{
@ -1210,7 +1224,6 @@ void Gnss_Crypto::readPublicKeyFromPEM(const std::string& pemFilePath)
}
const EC_GROUP* group = EC_KEY_get0_group(pubkey);
int nid = EC_GROUP_get_curve_name(group);
if (nid == 0)
{
BIGNUM* p = BN_new();
@ -1220,11 +1233,11 @@ void Gnss_Crypto::readPublicKeyFromPEM(const std::string& pemFilePath)
const std::string pcstr(p_str);
if (pcstr.size() == 64)
{
d_PublicKeyType = "ECDSA P-256";
d_PublicKeyType = std::string("ECDSA P-256");
}
else if (pcstr.size() == 132)
{
d_PublicKeyType = "ECDSA P-521";
d_PublicKeyType = std::string("ECDSA P-521");
}
OPENSSL_free(p_str);
}
@ -1236,11 +1249,11 @@ void Gnss_Crypto::readPublicKeyFromPEM(const std::string& pemFilePath)
const std::string curve_str(curve_name);
if (curve_str == "prime256v1")
{
d_PublicKeyType = "ECDSA P-256";
d_PublicKeyType = std::string("ECDSA P-256");
}
else if (curve_str == "secp521r1")
{
d_PublicKeyType = "ECDSA P-521";
d_PublicKeyType = std::string("ECDSA P-521");
}
}
@ -1262,8 +1275,7 @@ void Gnss_Crypto::readPublicKeyFromPEM(const std::string& pemFilePath)
bool Gnss_Crypto::readPublicKeyFromCRT(const std::string& crtFilePath)
{
d_PublicKeyType = "Unknown";
#if USE_GNUTLS_FALLBACK
d_PublicKeyType = std::string("Unknown");
// Open the .crt file
std::ifstream crtFile(crtFilePath, std::ios::binary);
if (!crtFile.is_open())
@ -1278,8 +1290,8 @@ bool Gnss_Crypto::readPublicKeyFromCRT(const std::string& crtFilePath)
}
const std::vector<unsigned char> buffer((std::istreambuf_iterator<char>(crtFile)), std::istreambuf_iterator<char>());
#if USE_GNUTLS_FALLBACK
const gnutls_datum_t buffer_datum = {const_cast<unsigned char*>(buffer.data()), static_cast<unsigned int>(buffer.size())};
gnutls_x509_crt_t cert;
gnutls_x509_crt_init(&cert);
int ret = gnutls_x509_crt_import(cert, &buffer_datum, GNUTLS_X509_FMT_PEM);
@ -1316,8 +1328,7 @@ bool Gnss_Crypto::readPublicKeyFromCRT(const std::string& crtFilePath)
}
pk_algorithm = static_cast<gnutls_pk_algorithm_t>(ret);
if (pk_algorithm == GNUTLS_PK_ECDSA)
if (pk_algorithm == GNUTLS_PK_ECC)
{
gnutls_ecc_curve_t curve;
ret = gnutls_pubkey_export_ecc_raw(pubkey, &curve, nullptr, nullptr);
@ -1331,11 +1342,11 @@ bool Gnss_Crypto::readPublicKeyFromCRT(const std::string& crtFilePath)
if (curve == GNUTLS_ECC_CURVE_SECP256R1)
{
d_PublicKeyType = "ECDSA P-256";
d_PublicKeyType = std::string("ECDSA P-256");
}
else if (curve == GNUTLS_ECC_CURVE_SECP521R1)
{
d_PublicKeyType = "ECDSA P-521";
d_PublicKeyType = std::string("ECDSA P-521");
}
else
{
@ -1357,16 +1368,7 @@ bool Gnss_Crypto::readPublicKeyFromCRT(const std::string& crtFilePath)
gnutls_x509_crt_deinit(cert);
gnutls_pubkey_deinit(pubkey);
#else // OpenSSL
// Open the .crt file
std::ifstream crtFile(crtFilePath, std::ios::binary);
if (!crtFile.is_open())
{
LOG(WARNING) << "OpenSSL: Unable to open file: " << crtFilePath;
return false;
}
// Read certificate
std::vector<char> buffer((std::istreambuf_iterator<char>(crtFile)), std::istreambuf_iterator<char>());
BIO* bio = BIO_new_mem_buf(buffer.data(), buffer.size());
if (!bio)
{
@ -1387,6 +1389,7 @@ bool Gnss_Crypto::readPublicKeyFromCRT(const std::string& crtFilePath)
{
LOG(WARNING) << "OpenSSL: Failed to extract the public key";
X509_free(cert);
BIO_free(bio);
return false;
}
#if USE_OPENSSL_3
@ -1403,24 +1406,25 @@ bool Gnss_Crypto::readPublicKeyFromCRT(const std::string& crtFilePath)
{
if (strcmp(curve_name, "prime256v1") == 0 || strcmp(curve_name, "P-256") == 0)
{
d_PublicKeyType = "ECDSA P-256";
d_PublicKeyType = std::string("ECDSA P-256");
}
else if (strcmp(curve_name, "secp521r1") == 0 || strcmp(curve_name, "P-521") == 0)
{
d_PublicKeyType = "ECDSA P-521";
d_PublicKeyType = std::string("ECDSA P-521");
}
else
{
LOG(WARNING) << "OpenSSL: Trying to read an unknown EC curve";
X509_free(cert);
BIO_free(bio);
return false;
}
}
else
{
d_PublicKeyType = "Unknown EC curve";
LOG(WARNING) << "OpenSSL: Trying to read an unknown EC curve";
X509_free(cert);
BIO_free(bio);
return false;
}
}
@ -1428,6 +1432,7 @@ bool Gnss_Crypto::readPublicKeyFromCRT(const std::string& crtFilePath)
{
LOG(WARNING) << "OpenSSL: Trying to read an unknown key type";
X509_free(cert);
BIO_free(bio);
return false;
}
pubkey_copy(pubkey, &d_PublicKey);
@ -1441,22 +1446,25 @@ bool Gnss_Crypto::readPublicKeyFromCRT(const std::string& crtFilePath)
{
X509_free(cert);
EC_KEY_free(ec_key);
BIO_free(bio);
return false;
}
const int nid = EC_GROUP_get_curve_name(group);
if (nid == NID_X9_62_prime256v1)
{
d_PublicKeyType = "ECDSA P-256";
d_PublicKeyType = std::string("ECDSA P-256");
}
else if (nid == NID_secp521r1)
{
d_PublicKeyType = "ECDSA P-521";
d_PublicKeyType = std::string("ECDSA P-521");
}
EC_KEY_free(ec_key);
#else
EC_KEY* ec_key = EVP_PKEY_get1_EC_KEY(pubkey);
if (!ec_key)
{
X509_free(cert);
BIO_free(bio);
return false;
}
@ -1466,6 +1474,7 @@ bool Gnss_Crypto::readPublicKeyFromCRT(const std::string& crtFilePath)
{
X509_free(cert);
EC_KEY_free(ec_key);
BIO_free(bio);
return false;
}
const int nid = EC_GROUP_get_curve_name(group);
@ -1478,11 +1487,11 @@ bool Gnss_Crypto::readPublicKeyFromCRT(const std::string& crtFilePath)
const std::string pcstr(p_str);
if (pcstr.size() == 64)
{
d_PublicKeyType = "ECDSA P-256";
d_PublicKeyType = std::string("ECDSA P-256");
}
else if (pcstr.size() == 132)
{
d_PublicKeyType = "ECDSA P-521";
d_PublicKeyType = std::string("ECDSA P-521");
}
OPENSSL_free(p_str);
}
@ -1494,13 +1503,14 @@ bool Gnss_Crypto::readPublicKeyFromCRT(const std::string& crtFilePath)
const std::string curve_str(curve_name);
if (curve_str == "prime256v1")
{
d_PublicKeyType = "ECDSA P-256";
d_PublicKeyType = std::string("ECDSA P-256");
}
else if (curve_str == "secp521r1")
{
d_PublicKeyType = "ECDSA P-521";
d_PublicKeyType = std::string("ECDSA P-521");
}
}
EC_KEY_free(ec_key);
#endif
EC_KEY* ec_pubkey = EVP_PKEY_get1_EC_KEY(pubkey);
EVP_PKEY_free(pubkey);

57
src/tests/unit-tests/signal-processing-blocks/osnma/gnss_crypto_test.cc
View File

@ -49,10 +49,9 @@ TEST(GnssCryptoTest, VerifyPubKeyImport)
TEST(GnssCryptoTest, VerifyPublicKeyStorage)
{
auto d_crypto = std::make_unique<Gnss_Crypto>();
const std::string f1("./osnma_test_file1.pem");
const std::string f2("./osnma_test_file2.pem");
const std::string f3("./osnma_test_file3.pem");
// Input taken from RG 1.3 A7.1
// compressed ECDSA P-256 format
@ -62,15 +61,17 @@ TEST(GnssCryptoTest, VerifyPublicKeyStorage)
0x63, 0xFF, 0xA0, 0x91, 0x41, 0x0F, 0xC1, 0x58, 0xFB, 0xB7,
0x79, 0x80, 0xEA};
auto d_crypto = std::make_unique<Gnss_Crypto>();
ASSERT_FALSE(d_crypto->have_public_key());
ASSERT_TRUE(d_crypto->get_public_key_type() == "Unknown");
d_crypto->set_public_key(publicKey);
bool result = d_crypto->store_public_key(f1);
ASSERT_TRUE(result);
ASSERT_TRUE(d_crypto->have_public_key());
ASSERT_TRUE(d_crypto->store_public_key(f1));
auto d_crypto2 = std::make_unique<Gnss_Crypto>(f1, "");
bool result2 = d_crypto2->store_public_key(f2);
ASSERT_TRUE(result2);
ASSERT_TRUE(d_crypto2->have_public_key());
ASSERT_TRUE(d_crypto2->get_public_key_type() == "ECDSA P-256");
ASSERT_TRUE(d_crypto2->store_public_key(f2));
std::ifstream t(f1);
std::string content_file((std::istreambuf_iterator<char>(t)), std::istreambuf_iterator<char>());
@ -80,9 +81,39 @@ TEST(GnssCryptoTest, VerifyPublicKeyStorage)
ASSERT_EQ(content_file, content_file2);
// P-521 Public key in compressed X format
std::vector<uint8_t> publicKey_P521 = {
0x03, 0x00, 0x28, 0x35, 0xBB, 0xE9, 0x24, 0x59, 0x4E, 0xF0,
0xE3, 0xA2, 0xDB, 0xC0, 0x49, 0x30, 0x60, 0x7C, 0x61, 0x90,
0xE4, 0x03, 0xE0, 0xC7, 0xB8, 0xC2, 0x62, 0x37, 0xF7, 0x58,
0x56, 0xBE, 0x63, 0x5C, 0x97, 0xF7, 0x53, 0x64, 0x7E, 0xE1,
0x0C, 0x07, 0xD3, 0x97, 0x8D, 0x58, 0x46, 0xFD, 0x6E, 0x06,
0x44, 0x01, 0xA7, 0xAA, 0xC4, 0x95, 0x13, 0x5D, 0xC9, 0x77,
0x26, 0xE9, 0xF8, 0x72, 0x0C, 0xD3, 0x88};
d_crypto->set_public_key(publicKey_P521);
ASSERT_TRUE(d_crypto->have_public_key());
ASSERT_TRUE(d_crypto->get_public_key_type() == "ECDSA P-521");
ASSERT_TRUE(d_crypto->store_public_key(f3));
auto d_crypto3 = std::make_unique<Gnss_Crypto>(f3, "");
ASSERT_TRUE(d_crypto3->have_public_key());
ASSERT_TRUE(d_crypto3->get_public_key_type() == "ECDSA P-521");
std::vector<uint8_t> wrong_publicKey = {
0x03, 0x03, 0xB2, 0xCE, 0x64, 0xBC, 0x20, 0x7B, 0xDD, 0x8B,
0xC4, 0xDF, 0x85, 0x91, 0x87, 0xFC, 0xB6, 0x86, 0x32, 0x0D,
0x63, 0xFF, 0xA0};
auto d_crypto4 = std::make_unique<Gnss_Crypto>();
d_crypto4->set_public_key(wrong_publicKey);
ASSERT_FALSE(d_crypto4->have_public_key());
ASSERT_TRUE(d_crypto4->get_public_key_type() == "Unknown");
errorlib::error_code ec;
ASSERT_TRUE(fs::remove(fs::path(f1), ec));
ASSERT_TRUE(fs::remove(fs::path(f2), ec));
ASSERT_TRUE(fs::remove(fs::path(f3), ec));
}
@ -263,13 +294,11 @@ TEST(GnssCryptoTest, VerifySignatureP256)
0x79, 0x80, 0xEA};
d_crypto->set_public_key(publicKey);
bool result = d_crypto->verify_signature_ecdsa_p256(message, signature);
ASSERT_TRUE(result);
ASSERT_TRUE(d_crypto->verify_signature_ecdsa_p256(message, signature));
std::vector<uint8_t> wrong_signature = signature;
wrong_signature[1] = 1;
bool result2 = d_crypto->verify_signature_ecdsa_p256(message, wrong_signature);
ASSERT_TRUE(!result2);
ASSERT_FALSE(d_crypto->verify_signature_ecdsa_p256(message, wrong_signature));
}
@ -309,11 +338,9 @@ TEST(GnssCryptoTest, VerifySignatureP521)
0x28, 0xEF};
d_crypto->set_public_key(publicKey);
bool result = d_crypto->verify_signature_ecdsa_p521(message, signature);
ASSERT_TRUE(result);
ASSERT_TRUE(d_crypto->verify_signature_ecdsa_p521(message, signature));
std::vector<uint8_t> wrong_signature = signature;
wrong_signature[1] = 1;
bool result2 = d_crypto->verify_signature_ecdsa_p521(message, wrong_signature);
ASSERT_TRUE(!result2);
ASSERT_FALSE(d_crypto->verify_signature_ecdsa_p521(message, wrong_signature));
}