sharpetronics/strongswan
1
0
Fork 0
mirror of https://github.com/strongswan/strongswan.git synced 2025-10-04 00:00:14 -04:00
Code Issues Projects Releases Wiki Activity

oqs: Support of Dilithium signature algorithms

Browse Source
This commit is contained in:
Andreas Steffen 2020-10-28 20:09:41 +01:00 committed by Tobias Brunner
parent 5e07e97a02
commit 77a0f681c8
21 changed files with 1113 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/libstrongswan/asn1/asn1.c
View File

@ -57,6 +57,9 @@ chunk_t asn1_algorithmIdentifier(int oid)
case OID_ECDSA_WITH_SHA512:
case OID_ED25519:
case OID_ED448:
case OID_DILITHIUM_2:
case OID_DILITHIUM_3:
case OID_DILITHIUM_4:
parameters = chunk_empty;
break;
default:

10
src/libstrongswan/asn1/oid.txt
View File

@ -205,6 +205,16 @@
0x01 "internet"
0x04 "private"
0x01 "enterprise"
0x02 "IBM"
0x82 ""
0x0B "QSC"
0x06 "dilithium-raw"
0x04 "d2r"
0x03 "dilithium2" OID_DILITHIUM_2
0x05 "d3r"
0x04 "dilithium3" OID_DILITHIUM_3
0x06 "d4r"
0x05 "dilithium4" OID_DILITHIUM_4
0x82 ""
0x37 "Microsoft"
0x0A ""

39
src/libstrongswan/credentials/auth_cfg.c
View File

@ -590,24 +590,27 @@ METHOD(auth_cfg_t, add_pubkey_constraints, void,
signature_scheme_t scheme;
key_type_t key;
} schemes[] = {
{ "md5", SIGN_RSA_EMSA_PKCS1_MD5, KEY_RSA, },
{ "sha1", SIGN_RSA_EMSA_PKCS1_SHA1, KEY_RSA, },
{ "sha224", SIGN_RSA_EMSA_PKCS1_SHA2_224, KEY_RSA, },
{ "sha256", SIGN_RSA_EMSA_PKCS1_SHA2_256, KEY_RSA, },
{ "sha384", SIGN_RSA_EMSA_PKCS1_SHA2_384, KEY_RSA, },
{ "sha512", SIGN_RSA_EMSA_PKCS1_SHA2_512, KEY_RSA, },
{ "sha1", SIGN_ECDSA_WITH_SHA1_DER, KEY_ECDSA, },
{ "sha256", SIGN_ECDSA_WITH_SHA256_DER, KEY_ECDSA, },
{ "sha384", SIGN_ECDSA_WITH_SHA384_DER, KEY_ECDSA, },
{ "sha512", SIGN_ECDSA_WITH_SHA512_DER, KEY_ECDSA, },
{ "sha256", SIGN_ECDSA_256, KEY_ECDSA, },
{ "sha384", SIGN_ECDSA_384, KEY_ECDSA, },
{ "sha512", SIGN_ECDSA_521, KEY_ECDSA, },
{ "sha256", SIGN_BLISS_WITH_SHA2_256, KEY_BLISS, },
{ "sha384", SIGN_BLISS_WITH_SHA2_384, KEY_BLISS, },
{ "sha512", SIGN_BLISS_WITH_SHA2_512, KEY_BLISS, },
{ "identity", SIGN_ED25519, KEY_ED25519, },
{ "identity", SIGN_ED448, KEY_ED448, },
{ "md5", SIGN_RSA_EMSA_PKCS1_MD5, KEY_RSA, },
{ "sha1", SIGN_RSA_EMSA_PKCS1_SHA1, KEY_RSA, },
{ "sha224", SIGN_RSA_EMSA_PKCS1_SHA2_224, KEY_RSA, },
{ "sha256", SIGN_RSA_EMSA_PKCS1_SHA2_256, KEY_RSA, },
{ "sha384", SIGN_RSA_EMSA_PKCS1_SHA2_384, KEY_RSA, },
{ "sha512", SIGN_RSA_EMSA_PKCS1_SHA2_512, KEY_RSA, },
{ "sha1", SIGN_ECDSA_WITH_SHA1_DER, KEY_ECDSA, },
{ "sha256", SIGN_ECDSA_WITH_SHA256_DER, KEY_ECDSA, },
{ "sha384", SIGN_ECDSA_WITH_SHA384_DER, KEY_ECDSA, },
{ "sha512", SIGN_ECDSA_WITH_SHA512_DER, KEY_ECDSA, },
{ "sha256", SIGN_ECDSA_256, KEY_ECDSA, },
{ "sha384", SIGN_ECDSA_384, KEY_ECDSA, },
{ "sha512", SIGN_ECDSA_521, KEY_ECDSA, },
{ "sha256", SIGN_BLISS_WITH_SHA2_256, KEY_BLISS, },
{ "sha384", SIGN_BLISS_WITH_SHA2_384, KEY_BLISS, },
{ "sha512", SIGN_BLISS_WITH_SHA2_512, KEY_BLISS, },
{ "identity", SIGN_ED25519, KEY_ED25519, },
{ "identity", SIGN_ED448, KEY_ED448, },
{ "identity", SIGN_DILITHIUM_2, KEY_DILITHIUM_2, },
{ "identity", SIGN_DILITHIUM_3, KEY_DILITHIUM_3, },
{ "identity", SIGN_DILITHIUM_4, KEY_DILITHIUM_4, },
};
if (expected_strength != AUTH_RULE_MAX)

2
src/libstrongswan/credentials/builder.c
View File

@ -75,6 +75,8 @@ ENUM(builder_part_names, BUILD_FROM_FILE, BUILD_END,
"BUILD_THRESHOLD",
"BUILD_EDDSA_PUB",
"BUILD_EDDSA_PRIV_ASN1_DER",
"BUILD_PRIV_ASN1_DER",
"BUILD_CRITICAL_EXTENSION",
"BUILD_DRBG",
"BUILD_END",
);

4
src/libstrongswan/credentials/builder.h
View File

@ -160,8 +160,12 @@ enum builder_part_t {
BUILD_EDDSA_PUB,
/** DER encoded ASN.1 EdDSA private key */
BUILD_EDDSA_PRIV_ASN1_DER,
/** DER encoded ASN.1 private key (usually OCTET_STRING) */
BUILD_PRIV_ASN1_DER,
/** OID of an [unsupported] critical extension */
BUILD_CRITICAL_EXTENSION,
/** DRBG to be used for crypto tests */
BUILD_DRBG,
/** end of variable argument builder list */
BUILD_END,
};

4
src/libstrongswan/credentials/cred_encoding.h
View File

@ -144,6 +144,10 @@ enum cred_encoding_part_t {
CRED_PART_PKCS10_ASN1_DER,
/** a PGP encoded certificate */
CRED_PART_PGP_CERT,
/** a DER encoded public key */
CRED_PART_PUB_ASN1_DER,
/** a DER encoded private key */
CRED_PART_PRIV_ASN1_DER,
/** a DER encoded EdDSA public key */
CRED_PART_EDDSA_PUB_ASN1_DER,
/** a DER encoded EdDSA private key */

104
src/libstrongswan/credentials/keys/public_key.c
View File

@ -1,6 +1,6 @@
/*
* Copyright (C) 2015-2017 Tobias Brunner
* Copyright (C) 2014-2016 Andreas Steffen
* Copyright (C) 2014-2020 Andreas Steffen
* Copyright (C) 2007 Martin Willi
* HSR Hochschule fuer Technik Rapperswil
*
@ -27,6 +27,9 @@ ENUM(key_type_names, KEY_ANY, KEY_BLISS,
"DSA",
"ED25519",
"ED448",
"Dilithium2",
"Dilithium3",
"Dilithium4",
"BLISS"
);
@ -54,6 +57,9 @@ ENUM(signature_scheme_names, SIGN_UNKNOWN, SIGN_BLISS_WITH_SHA3_512,
"ECDSA-521",
"ED25519",
"ED448",
"DILITHIUM_2",
"DILITHIUM_3",
"DILITHIUM_4",
"BLISS_WITH_SHA2_256",
"BLISS_WITH_SHA2_384",
"BLISS_WITH_SHA2_512",
@ -115,6 +121,50 @@ bool public_key_has_fingerprint(public_key_t *public, chunk_t fingerprint)
return FALSE;
}
/**
* See header.
*/
int key_type_to_oid(key_type_t type)
{
switch (type)
{
case KEY_ED25519:
return OID_ED25519;
case KEY_ED448:
return OID_ED448;
case KEY_DILITHIUM_2:
return OID_DILITHIUM_2;
case KEY_DILITHIUM_3:
return OID_DILITHIUM_3;
case KEY_DILITHIUM_4:
return OID_DILITHIUM_4;
default:
return OID_UNKNOWN;
}
}
/**
* See header.
*/
key_type_t key_type_from_oid(int oid)
{
switch (oid)
{
case OID_ED25519:
return KEY_ED25519;
case OID_ED448:
return KEY_ED448;
case OID_DILITHIUM_2:
return KEY_DILITHIUM_2;
case OID_DILITHIUM_3:
return KEY_DILITHIUM_3;
case OID_DILITHIUM_4:
return KEY_DILITHIUM_4;
default:
return KEY_ANY;
}
}
/*
* Defined in header.
*/
@ -163,6 +213,12 @@ signature_scheme_t signature_scheme_from_oid(int oid)
return SIGN_ED25519;
case OID_ED448:
return SIGN_ED448;
case OID_DILITHIUM_2:
return SIGN_DILITHIUM_2;
case OID_DILITHIUM_3:
return SIGN_DILITHIUM_3;
case OID_DILITHIUM_4:
return SIGN_DILITHIUM_4;
case OID_BLISS_PUBLICKEY:
case OID_BLISS_WITH_SHA2_512:
return SIGN_BLISS_WITH_SHA2_512;
@ -228,6 +284,12 @@ int signature_scheme_to_oid(signature_scheme_t scheme)
return OID_ED25519;
case SIGN_ED448:
return OID_ED448;
case SIGN_DILITHIUM_2:
return OID_DILITHIUM_2;
case SIGN_DILITHIUM_3:
return OID_DILITHIUM_3;
case SIGN_DILITHIUM_4:
return OID_DILITHIUM_4;
case SIGN_BLISS_WITH_SHA2_256:
return OID_BLISS_WITH_SHA2_256;
case SIGN_BLISS_WITH_SHA2_384:
@ -267,20 +329,26 @@ static struct {
int max_keysize;
signature_params_t params;
} scheme_map[] = {
{ KEY_RSA, 3072, { .scheme = SIGN_RSA_EMSA_PSS, .params = &pss_params_sha256, }},
{ KEY_RSA, 7680, { .scheme = SIGN_RSA_EMSA_PSS, .params = &pss_params_sha384, }},
{ KEY_RSA, 0, { .scheme = SIGN_RSA_EMSA_PSS, .params = &pss_params_sha512, }},
{ KEY_RSA, 3072, { .scheme = SIGN_RSA_EMSA_PKCS1_SHA2_256 }},
{ KEY_RSA, 7680, { .scheme = SIGN_RSA_EMSA_PKCS1_SHA2_384 }},
{ KEY_RSA, 0, { .scheme = SIGN_RSA_EMSA_PKCS1_SHA2_512 }},
{ KEY_ECDSA, 256, { .scheme = SIGN_ECDSA_WITH_SHA256_DER }},
{ KEY_ECDSA, 384, { .scheme = SIGN_ECDSA_WITH_SHA384_DER }},
{ KEY_ECDSA, 0, { .scheme = SIGN_ECDSA_WITH_SHA512_DER }},
{ KEY_ED25519, 0, { .scheme = SIGN_ED25519 }},
{ KEY_ED448, 0, { .scheme = SIGN_ED448 }},
{ KEY_BLISS, 128, { .scheme = SIGN_BLISS_WITH_SHA2_256 }},
{ KEY_BLISS, 192, { .scheme = SIGN_BLISS_WITH_SHA2_384 }},
{ KEY_BLISS, 0, { .scheme = SIGN_BLISS_WITH_SHA2_512 }},
{ KEY_RSA, 3072, { .scheme = SIGN_RSA_EMSA_PSS,
.params = &pss_params_sha256, }},
{ KEY_RSA, 7680, { .scheme = SIGN_RSA_EMSA_PSS,
.params = &pss_params_sha384, }},
{ KEY_RSA, 0, { .scheme = SIGN_RSA_EMSA_PSS,
.params = &pss_params_sha512, }},
{ KEY_RSA, 3072, { .scheme = SIGN_RSA_EMSA_PKCS1_SHA2_256 }},
{ KEY_RSA, 7680, { .scheme = SIGN_RSA_EMSA_PKCS1_SHA2_384 }},
{ KEY_RSA, 0, { .scheme = SIGN_RSA_EMSA_PKCS1_SHA2_512 }},
{ KEY_ECDSA, 256, { .scheme = SIGN_ECDSA_WITH_SHA256_DER }},
{ KEY_ECDSA, 384, { .scheme = SIGN_ECDSA_WITH_SHA384_DER }},
{ KEY_ECDSA, 0, { .scheme = SIGN_ECDSA_WITH_SHA512_DER }},
{ KEY_ED25519, 0, { .scheme = SIGN_ED25519 }},
{ KEY_ED448, 0, { .scheme = SIGN_ED448 }},
{ KEY_DILITHIUM_2, 0, { .scheme = SIGN_DILITHIUM_2}},
{ KEY_DILITHIUM_3, 0, { .scheme = SIGN_DILITHIUM_3}},
{ KEY_DILITHIUM_4, 0, { .scheme = SIGN_DILITHIUM_4}},
{ KEY_BLISS, 128, { .scheme = SIGN_BLISS_WITH_SHA2_256 }},
{ KEY_BLISS, 192, { .scheme = SIGN_BLISS_WITH_SHA2_384 }},
{ KEY_BLISS, 0, { .scheme = SIGN_BLISS_WITH_SHA2_512 }},
};
/**
@ -369,6 +437,12 @@ key_type_t key_type_from_signature_scheme(signature_scheme_t scheme)
return KEY_ED25519;
case SIGN_ED448:
return KEY_ED448;
case SIGN_DILITHIUM_2:
return KEY_DILITHIUM_2;
case SIGN_DILITHIUM_3:
return KEY_DILITHIUM_3;
case SIGN_DILITHIUM_4:
return KEY_DILITHIUM_4;
case SIGN_BLISS_WITH_SHA2_256:
case SIGN_BLISS_WITH_SHA2_384:
case SIGN_BLISS_WITH_SHA2_512:

32
src/libstrongswan/credentials/keys/public_key.h
View File

@ -1,6 +1,6 @@
/*
* Copyright (C) 2015-2017 Tobias Brunner
* Copyright (C) 2014-2017 Andreas Steffen
* Copyright (C) 2014-2020 Andreas Steffen
* Copyright (C) 2007 Martin Willi
* HSR Hochschule fuer Technik Rapperswil
*
@ -47,8 +47,14 @@ enum key_type_t {
KEY_ED25519 = 4,
/** Ed448 PureEdDSA instance as in RFC 8032 */
KEY_ED448 = 5,
/** Dilithium2 NIST Round 3 Submission candidate */
KEY_DILITHIUM_2 = 6,
/** Dilithium3 NIST Round 3 Submission candidate */
KEY_DILITHIUM_3 = 7,
/** Dilithium4 NIST Round 3 Submission candidate */
KEY_DILITHIUM_4 = 8,
/** BLISS */
KEY_BLISS = 6,
KEY_BLISS = 9,
};
/**
@ -110,6 +116,12 @@ enum signature_scheme_t {
SIGN_ED25519,
/** PureEdDSA on Curve448 as in RFC 8410 */
SIGN_ED448,
/** Dilithium2 NIST Round 3 Submission signature */
SIGN_DILITHIUM_2,
/** Dilithium3 NIST Round 3 Submission signature */
SIGN_DILITHIUM_3,
/** Dilithium4 NIST Round 3 Submission signature */
SIGN_DILITHIUM_4,
/** BLISS with SHA-2_256 */
SIGN_BLISS_WITH_SHA2_256,
/** BLISS with SHA-2_384 */
@ -264,6 +276,22 @@ bool public_key_equals(public_key_t *public, public_key_t *other);
*/
bool public_key_has_fingerprint(public_key_t *public, chunk_t fingerprint);
/**
* Return OID for a given key type
*
* @param type type of the key
* @return OID
*/
int key_type_to_oid(key_type_t type);
/**
* Return key type for a given OID
*
* @param oid OID
* @return type of the key
*/
key_type_t key_type_from_oid(int oid);
/**
* Conversion of ASN.1 signature or hash OID to signature scheme.
*

31
src/libstrongswan/crypto/hashers/hasher.c
View File

@ -155,6 +155,9 @@ hash_algorithm_t hasher_algorithm_from_oid(int oid)
return HASH_SHA3_512;
case OID_ED25519:
case OID_ED448:
case OID_DILITHIUM_2:
case OID_DILITHIUM_3:
case OID_DILITHIUM_4:
return HASH_IDENTITY;
default:
return HASH_UNKNOWN;
@ -476,6 +479,31 @@ int hasher_signature_algorithm_to_oid(hash_algorithm_t alg, key_type_t key)
default:
return OID_UNKNOWN;
}
case KEY_DILITHIUM_2:
switch (alg)
{
case HASH_IDENTITY:
return OID_DILITHIUM_2;
default:
return OID_UNKNOWN;
}
case KEY_DILITHIUM_3:
switch (alg)
{
case HASH_IDENTITY:
return OID_DILITHIUM_3;
default:
return OID_UNKNOWN;
}
case KEY_DILITHIUM_4:
switch (alg)
{
case HASH_IDENTITY:
return OID_DILITHIUM_4;
default:
return OID_UNKNOWN;
}
case KEY_BLISS:
switch (alg)
{
@ -520,6 +548,9 @@ hash_algorithm_t hasher_from_signature_scheme(signature_scheme_t scheme,
break;
case SIGN_ED25519:
case SIGN_ED448:
case SIGN_DILITHIUM_2:
case SIGN_DILITHIUM_3:
case SIGN_DILITHIUM_4:
return HASH_IDENTITY;
case SIGN_RSA_EMSA_PKCS1_MD5:
return HASH_MD5;

4
src/libstrongswan/plugins/oqs/Makefile.am
View File

@ -20,7 +20,9 @@ plugin_LTLIBRARIES = libstrongswan-oqs.la
endif
libstrongswan_oqs_la_SOURCES = \
oqs_plugin.h oqs_plugin.c
oqs_plugin.h oqs_plugin.c \
oqs_public_key.h oqs_public_key.c \
oqs_private_key.h oqs_private_key.c
libstrongswan_oqs_la_LDFLAGS = -module -avoid-version

24
src/libstrongswan/plugins/oqs/oqs_plugin.c
View File

@ -16,6 +16,8 @@
#include "oqs_plugin.h"
#include "oqs_kem.h"
#include "oqs_drbg.h"
#include "oqs_public_key.h"
#include "oqs_private_key.h"
#include <library.h>
#include <threading/thread_value.h>
@ -65,6 +67,28 @@ METHOD(plugin_t, get_features, int,
PLUGIN_PROVIDE(KE, KE_SIKE_L2),
PLUGIN_PROVIDE(KE, KE_SIKE_L3),
PLUGIN_PROVIDE(KE, KE_SIKE_L5),
/* private/public keys */
PLUGIN_REGISTER(PRIVKEY, oqs_private_key_load, TRUE),
PLUGIN_PROVIDE(PRIVKEY, KEY_DILITHIUM_2),
PLUGIN_PROVIDE(PRIVKEY, KEY_DILITHIUM_3),
PLUGIN_PROVIDE(PRIVKEY, KEY_DILITHIUM_4),
PLUGIN_REGISTER(PRIVKEY_GEN, oqs_private_key_gen, FALSE),
PLUGIN_PROVIDE(PRIVKEY_GEN, KEY_DILITHIUM_2),
PLUGIN_PROVIDE(PRIVKEY_GEN, KEY_DILITHIUM_3),
PLUGIN_PROVIDE(PRIVKEY_GEN, KEY_DILITHIUM_4),
PLUGIN_REGISTER(PUBKEY, oqs_public_key_load, TRUE),
PLUGIN_PROVIDE(PUBKEY, KEY_DILITHIUM_2),
PLUGIN_PROVIDE(PUBKEY, KEY_DILITHIUM_3),
PLUGIN_PROVIDE(PUBKEY, KEY_DILITHIUM_4),
PLUGIN_PROVIDE(PUBKEY, KEY_ANY),
/* signature schemes, private */
PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_DILITHIUM_2),
PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_DILITHIUM_3),
PLUGIN_PROVIDE(PRIVKEY_SIGN, SIGN_DILITHIUM_4),
/* signature verification schemes */
PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_DILITHIUM_2),
PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_DILITHIUM_3),
PLUGIN_PROVIDE(PUBKEY_VERIFY, SIGN_DILITHIUM_4),
};
*features = f;
return countof(f);

374
src/libstrongswan/plugins/oqs/oqs_private_key.c Normal file
View File

@ -0,0 +1,374 @@
/*
* Copyright (C) 2020 Andreas Steffen
* HSR Hochschule fuer Technik Rapperswil
*
* This program 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 2 of the License, or (at your
* option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
*
* This program 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.
*/
#include "oqs_private_key.h"
#include "oqs_public_key.h"
#include "oqs_drbg.h"
#include <asn1/asn1.h>
#include <asn1/asn1_parser.h>
#include <asn1/oid.h>
#include <crypto/rngs/rng_tester.h>
#include <oqs/oqs.h>
#define _GNU_SOURCE
#include <stdlib.h>
typedef struct private_oqs_private_key_t private_oqs_private_key_t;
/**
* Private data of a oqs_private_key_t object.
*/
struct private_oqs_private_key_t {
/**
* Public interface for this signer.
*/
oqs_private_key_t public;
/**
* Key type
*/
key_type_t type;
/**
* OID of the key type
*/
int oid;
/**
* Internal OQS_SIG object
*/
OQS_SIG *sig;
/**
* Public Key
*/
chunk_t public_key;
/**
* Secret Key
*/
chunk_t secret_key;
/**
* Deterministic Random Bit Generator (DRBG)
*/
drbg_t *drbg;
/**
* reference count
*/
refcount_t ref;
};
METHOD(private_key_t, get_type, key_type_t,
private_oqs_private_key_t *this)
{
return this->type;
}
METHOD(private_key_t, sign, bool,
private_oqs_private_key_t *this, signature_scheme_t scheme, void *params,
chunk_t data, chunk_t *signature)
{
if (key_type_from_signature_scheme(scheme) != this->type)
{
DBG1(DBG_LIB, "signature scheme %N not supported",
signature_scheme_names, scheme);
return FALSE;
}
*signature = chunk_alloc(this->sig->length_signature);
if (OQS_SIG_sign(this->sig, signature->ptr, &signature->len,
data.ptr, data.len, this->secret_key.ptr) != OQS_SUCCESS)
{
chunk_free(signature);
return FALSE;
}
return TRUE;
}
METHOD(private_key_t, decrypt, bool,
private_oqs_private_key_t *this, encryption_scheme_t scheme,
chunk_t crypto, chunk_t *plain)
{
DBG1(DBG_LIB, "encryption scheme %N not supported",
encryption_scheme_names, scheme);
return FALSE;
}
METHOD(private_key_t, get_keysize, int,
private_oqs_private_key_t *this)
{
return this->public_key.len;
}
METHOD(private_key_t, get_public_key, public_key_t*,
private_oqs_private_key_t *this)
{
return lib->creds->create(lib->creds, CRED_PUBLIC_KEY, this->type,
BUILD_BLOB, this->public_key, BUILD_END);
}
METHOD(private_key_t, get_encoding, bool,
private_oqs_private_key_t *this, cred_encoding_type_t type,
chunk_t *encoding)
{
switch (type)
{
case PRIVKEY_ASN1_DER:
case PRIVKEY_PEM:
{
bool success = TRUE;
chunk_t blob;
blob = chunk_cat("cc", this->secret_key, this->public_key);
*encoding = asn1_wrap(ASN1_SEQUENCE, "cms",
ASN1_INTEGER_0,
asn1_algorithmIdentifier(this->oid),
asn1_wrap(ASN1_OCTET_STRING, "s",
asn1_simple_object(ASN1_OCTET_STRING, blob)
)
);
if (type == PRIVKEY_PEM)
{
chunk_t asn1_encoding = *encoding;
success = lib->encoding->encode(lib->encoding, PRIVKEY_PEM,
NULL, encoding, CRED_PART_PRIV_ASN1_DER,
asn1_encoding, CRED_PART_END);
chunk_clear(&asn1_encoding);
}
chunk_clear(&blob);
return success;
}
default:
return FALSE;
}
}
METHOD(private_key_t, get_fingerprint, bool,
private_oqs_private_key_t *this, cred_encoding_type_t type,
chunk_t *fp)
{
bool success;
if (lib->encoding->get_cache(lib->encoding, type, this, fp))
{
return TRUE;
}
success = oqs_public_key_fingerprint(this->public_key, this->oid, type, fp);
if (success)
{
lib->encoding->cache(lib->encoding, type, this, *fp);
}
return success;
}
METHOD(private_key_t, get_ref, private_key_t*,
private_oqs_private_key_t *this)
{
ref_get(&this->ref);
return &this->public.key;
}
METHOD(private_key_t, destroy, void,
private_oqs_private_key_t *this)
{
if (ref_put(&this->ref))
{
lib->encoding->clear_cache(lib->encoding, this);
DESTROY_IF(this->drbg);
OQS_SIG_free(this->sig);
chunk_clear(&this->secret_key);
chunk_free(&this->public_key);
free(this);
}
}
/**
* Internal generic constructor
*/
static private_oqs_private_key_t *oqs_private_key_create_empty(key_type_t type)
{
private_oqs_private_key_t *this;
char *sig_alg = NULL;
OQS_SIG *sig;
switch (type)
{
case KEY_DILITHIUM_2:
sig_alg = OQS_SIG_alg_dilithium_2;
break;
case KEY_DILITHIUM_3:
sig_alg = OQS_SIG_alg_dilithium_3;
break;
case KEY_DILITHIUM_4:
sig_alg = OQS_SIG_alg_dilithium_4;
break;
default:
return NULL;
}
if (OQS_randombytes_switch_algorithm(OQS_RAND_alg_openssl) != OQS_SUCCESS)
{
DBG1(DBG_LIB, "OQS RNG could not be switched to openssl");
return NULL;
}
sig = OQS_SIG_new(sig_alg);
if (!sig)
{
DBG1(DBG_LIB, "OQS '%s' signature algorithm not available", sig_alg);
return NULL;
}
INIT(this,
.public = {
.key = {
.get_type = _get_type,
.sign = _sign,
.decrypt = _decrypt,
.get_keysize = _get_keysize,
.get_public_key = _get_public_key,
.equals = private_key_equals,
.belongs_to = private_key_belongs_to,
.get_fingerprint = _get_fingerprint,
.has_fingerprint = private_key_has_fingerprint,
.get_encoding = _get_encoding,
.get_ref = _get_ref,
.destroy = _destroy,
},
},
.type = type,
.oid = key_type_to_oid(type),
.sig = sig,
.secret_key = chunk_alloc(sig->length_secret_key),
.public_key = chunk_alloc(sig->length_public_key),
.ref = 1,
);
return this;
}
/**
* See header.
*/
oqs_private_key_t *oqs_private_key_gen(key_type_t type, va_list args)
{
private_oqs_private_key_t *this;
drbg_t *drbg = NULL;
if (!oqs_supported(type))
{
return NULL;
}
while (TRUE)
{
switch (va_arg(args, builder_part_t))
{
case BUILD_KEY_SIZE:
/* key_size argument is not needed */
va_arg(args, u_int);
continue;
case BUILD_DRBG:
drbg = va_arg(args, drbg_t*);
continue;
case BUILD_END:
break;
default:
return NULL;
}
break;
}
this = oqs_private_key_create_empty(type);
if (!this)
{
return NULL;
}
if (drbg)
{
this->drbg = drbg->get_ref(drbg);
OQS_randombytes_custom_algorithm(oqs_drbg_rand);
oqs_drbg_set(this->drbg);
}
if (OQS_SIG_keypair(this->sig, this->public_key.ptr,
this->secret_key.ptr) != OQS_SUCCESS)
{
DBG1(DBG_LIB, "OQS_SIG_keypair failed!");
destroy(this);
return NULL;
}
return &this->public;
}
/**
* See header.
*/
oqs_private_key_t *oqs_private_key_load(key_type_t type, va_list args)
{
private_oqs_private_key_t *this;
chunk_t blob = chunk_empty;
if (!oqs_supported(type))
{
return NULL;
}
while (TRUE)
{
switch (va_arg(args, builder_part_t))
{
case BUILD_PRIV_ASN1_DER:
blob = va_arg(args, chunk_t);
continue;
case BUILD_END:
break;
default:
return NULL;
}
break;
}
if (!asn1_parse_simple_object(&blob, ASN1_OCTET_STRING, 0, "PrivateKey"))
{
return NULL;
}
this = oqs_private_key_create_empty(type);
if (!this)
{
return NULL;
}
/* Dilithium private keys contain the public key */
if (blob.len != this->sig->length_public_key + this->sig->length_secret_key)
{
return NULL;
}
memcpy(this->secret_key.ptr, blob.ptr, this->secret_key.len);
blob = chunk_skip(blob, this->secret_key.len);
memcpy(this->public_key.ptr, blob.ptr, this->public_key.len);
return &this->public;
}

58
src/libstrongswan/plugins/oqs/oqs_private_key.h Normal file
View File

@ -0,0 +1,58 @@
/*
* Copyright (C) 2020 Andreas Steffen
* HSR Hochschule fuer Technik Rapperswil
*
* This program 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 2 of the License, or (at your
* option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
*
* This program 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.
*/
/**
* @defgroup oqs_private_key oqs_private_key
* @{ @ingroup oqs_p
*/
#ifndef OQS_PRIVATE_KEY_H_
#define OQS_PRIVATE_KEY_H_
#include <credentials/builder.h>
#include <credentials/keys/private_key.h>
typedef struct oqs_private_key_t oqs_private_key_t;
/**
* Private_key_t implementation of OQS signature algorithm.
*/
struct oqs_private_key_t {
/**
* Implements private_key_t interface
*/
private_key_t key;
};
/**
* Generate a OQS private key.
*
* @param type type of the key
* @param args builder_part_t argument list
* @return generated key, NULL on failure
*/
oqs_private_key_t *oqs_private_key_gen(key_type_t type, va_list args);
/**
* Load a OQS private key.
*
* @param type type of the key
* @param args builder_part_t argument list
* @return loaded key, NULL on failure
*/
oqs_private_key_t *oqs_private_key_load(key_type_t type, va_list args);
#endif /** OQS_PRIVATE_KEY_H_ @}*/

344
src/libstrongswan/plugins/oqs/oqs_public_key.c Normal file
View File

@ -0,0 +1,344 @@
/*
* Copyright (C) 2020 Andreas Steffen
* HSR Hochschule fuer Technik Rapperswil
*
* This program 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 2 of the License, or (at your
* option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
*
* This program 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.
*/
#include "oqs_public_key.h"
#include <asn1/asn1.h>
#include <asn1/asn1_parser.h>
#include <asn1/oid.h>
#include <oqs/oqs.h>
typedef struct private_oqs_public_key_t private_oqs_public_key_t;
/**
* Private data structure with signing context.
*/
struct private_oqs_public_key_t {
/**
* Public interface for this signer.
*/
oqs_public_key_t public;
/**
* Key type
*/
key_type_t type;
/**
* OID of the key type
*/
int oid;
/**
* Internal OQS_SiG object
*/
OQS_SIG *sig;
/**
* Public key
*/
chunk_t public_key;
/**
* reference counter
*/
refcount_t ref;
};
METHOD(public_key_t, get_type, key_type_t,
private_oqs_public_key_t *this)
{
return this->type;
}
METHOD(public_key_t, verify, bool,
private_oqs_public_key_t *this, signature_scheme_t scheme, void *params,
chunk_t data, chunk_t signature)
{
if (key_type_from_signature_scheme(scheme) != this->type)
{
DBG1(DBG_LIB, "signature scheme %N not supported",
signature_scheme_names, scheme);
return FALSE;
}
return OQS_SIG_verify(this->sig, data.ptr, data.len, signature.ptr,
signature.len, this->public_key.ptr) == OQS_SUCCESS;
}
METHOD(public_key_t, encrypt_, bool,
private_oqs_public_key_t *this, encryption_scheme_t scheme,
chunk_t plain, chunk_t *crypto)
{
DBG1(DBG_LIB, "encryption scheme %N not supported",
encryption_scheme_names, scheme);
return FALSE;
}
METHOD(public_key_t, get_keysize, int,
private_oqs_public_key_t *this)
{
return this->public_key.len;
}
static chunk_t public_key_info_encode(chunk_t pubkey, int oid)
{
return asn1_wrap(ASN1_SEQUENCE, "mm",
asn1_algorithmIdentifier(oid),
asn1_bitstring("c", pubkey)
);
}
METHOD(public_key_t, get_encoding, bool,
private_oqs_public_key_t *this, cred_encoding_type_t type,
chunk_t *encoding)
{
bool success = TRUE;
*encoding = public_key_info_encode(this->public_key, this->oid);
if (type != PUBKEY_SPKI_ASN1_DER)
{
chunk_t asn1_encoding = *encoding;
success = lib->encoding->encode(lib->encoding, type,
NULL, encoding, CRED_PART_PUB_ASN1_DER,
asn1_encoding, CRED_PART_END);
chunk_clear(&asn1_encoding);
}
return success;
}
METHOD(public_key_t, get_fingerprint, bool,
private_oqs_public_key_t *this, cred_encoding_type_t type, chunk_t *fp)
{
bool success;
if (lib->encoding->get_cache(lib->encoding, type, this, fp))
{
return TRUE;
}
success = oqs_public_key_fingerprint(this->public_key, this->oid, type, fp);
if (success)
{
lib->encoding->cache(lib->encoding, type, this, *fp);
}
return success;
}
METHOD(public_key_t, get_ref, public_key_t*,
private_oqs_public_key_t *this)
{
ref_get(&this->ref);
return &this->public.key;
}
METHOD(public_key_t, destroy, void,
private_oqs_public_key_t *this)
{
if (ref_put(&this->ref))
{
chunk_free(&this->public_key);
lib->encoding->clear_cache(lib->encoding, this);
free(this);
}
}
/**
* ASN.1 definition of an OQS public key
*/
static const asn1Object_t pubkeyObjects[] = {
{ 0, "subjectPublicKeyInfo",ASN1_SEQUENCE, ASN1_OBJ }, /* 0 */
{ 1, "algorithm", ASN1_EOC, ASN1_RAW }, /* 1 */
{ 1, "subjectPublicKey", ASN1_BIT_STRING, ASN1_BODY }, /* 2 */
{ 0, "exit", ASN1_EOC, ASN1_EXIT }
};
#define OQS_SUBJECT_PUBLIC_KEY_ALGORITHM 1
#define OQS_SUBJECT_PUBLIC_KEY 2
/**
* See header.
*/
oqs_public_key_t *oqs_public_key_load(key_type_t type, va_list args)
{
private_oqs_public_key_t *this;
chunk_t asn1 = chunk_empty, blob = chunk_empty, object, param;
asn1_parser_t *parser;
bool success = FALSE;
int objectID;
char *sig_alg = NULL;
while (TRUE)
{
switch (va_arg(args, builder_part_t))
{
case BUILD_BLOB:
blob = va_arg(args, chunk_t);
continue;
case BUILD_BLOB_ASN1_DER:
asn1 = va_arg(args, chunk_t);
continue;
case BUILD_END:
break;
default:
return NULL;
}
break;
}
if ((blob.len == 0 && asn1.len == 0) ||
(blob.len > 0 && !oqs_supported(type)))
{
return NULL;
}
INIT(this,
.public = {
.key = {
.get_type = _get_type,
.verify = _verify,
.encrypt = _encrypt_,
.equals = public_key_equals,
.get_keysize = _get_keysize,
.get_fingerprint = _get_fingerprint,
.has_fingerprint = public_key_has_fingerprint,
.get_encoding = _get_encoding,
.get_ref = _get_ref,
.destroy = _destroy,
},
},
.ref = 1,
);
if (blob.len > 0)
{
/* raw public key */
this->type = type;
this->oid = key_type_to_oid(type);
this->public_key = chunk_clone(blob);
}
else
{
/* PKCS#1-encoded public key in ASN.1 DER format */
parser = asn1_parser_create(pubkeyObjects, asn1);
while (parser->iterate(parser, &objectID, &object))
{
switch (objectID)
{
case OQS_SUBJECT_PUBLIC_KEY_ALGORITHM:
this->oid = asn1_parse_algorithmIdentifier(object,
parser->get_level(parser)+1, &param);
this->type = key_type_from_oid(this->oid);
if (this->type == KEY_ANY)
{
goto end;
}
break;
case OQS_SUBJECT_PUBLIC_KEY:
this->public_key = chunk_clone(chunk_skip(object, 1));
break;
}
}
success = parser->success(parser);
end:
parser->destroy(parser);
if (!success)
{
destroy(this);
return NULL;
}
}
switch (this->type)
{
case KEY_DILITHIUM_2:
sig_alg = OQS_SIG_alg_dilithium_2;
break;
case KEY_DILITHIUM_3:
sig_alg = OQS_SIG_alg_dilithium_3;
break;
case KEY_DILITHIUM_4:
sig_alg = OQS_SIG_alg_dilithium_4;
break;
default:
destroy(this);
return NULL;
}
this->sig = OQS_SIG_new(sig_alg);
if (!this->sig)
{
DBG1(DBG_LIB, "OQS '%s' signature algorithm not available", sig_alg);
destroy(this);
return NULL;
}
return &this->public;
}
/**
* See header.
*/
bool oqs_supported(key_type_t type)
{
switch (type)
{
case KEY_DILITHIUM_2:
case KEY_DILITHIUM_3:
case KEY_DILITHIUM_4:
return TRUE;
default:
return FALSE;
}
}
/**
* See header.
*/
bool oqs_public_key_fingerprint(chunk_t pubkey, int oid,
cred_encoding_type_t type, chunk_t *fp)
{
hasher_t *hasher;
chunk_t key;
switch (type)
{
case KEYID_PUBKEY_SHA1:
key = chunk_clone(pubkey);
break;
case KEYID_PUBKEY_INFO_SHA1:
key = public_key_info_encode(pubkey, oid);
break;
default:
return FALSE;
}
hasher = lib->crypto->create_hasher(lib->crypto, HASH_SHA1);
if (!hasher || !hasher->allocate_hash(hasher, key, fp))
{
DBG1(DBG_LIB, "SHA1 hash algorithm not supported");
DESTROY_IF(hasher);
free(key.ptr);
return FALSE;
}
hasher->destroy(hasher);
free(key.ptr);
return TRUE;
}

72
src/libstrongswan/plugins/oqs/oqs_public_key.h Normal file
View File

@ -0,0 +1,72 @@
/*
* Copyright (C) 2020 Andreas Steffen
* HSR Hochschule fuer Technik Rapperswil
*
* This program 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 2 of the License, or (at your
* option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
*
* This program 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.
*/
/**
* @defgroup oqs_public_key oqs_public_key
* @{ @ingroup oqs_p
*/
#ifndef OQS_PUBLIC_KEY_H_
#define OQS_PUBLIC_KEY_H_
#include <credentials/builder.h>
#include <credentials/cred_encoding.h>
#include <credentials/keys/public_key.h>
typedef struct oqs_public_key_t oqs_public_key_t;
/**
* public_key_t implementation of OQS signature algorithm
*/
struct oqs_public_key_t {
/**
* Implements the public_key_t interface
*/
public_key_t key;
};
/**
* Load an OQS public key.
*
* @param type type of the key
* @param args builder_part_t argument list
* @return loaded key, NULL on failure
*/
oqs_public_key_t *oqs_public_key_load(key_type_t type, va_list args);
/* The following functions are shared with the oqs_private_key class */
/**
* Is the key type supported by OQS?
*
* @param type type of the key
* @return TRUE if key type is supported
*/
bool oqs_supported(key_type_t type);
/**
* Generate a public key fingerprint
*
* @param pubkey public key
* @param oid OID of the key type
* @param type type of fingerprint to be generated
* @param fp generated fingerprint (must be freed by caller)
* @result TRUE if generation was successful
*/
bool oqs_public_key_fingerprint(chunk_t pubkey, int oid,
cred_encoding_type_t type, chunk_t *fp);
#endif /** OQS_PUBLIC_KEY_H_ @}*/

6
src/libstrongswan/plugins/pem/pem_encoder.c
View File

@ -40,6 +40,8 @@ bool pem_encoder_encode(cred_encoding_type_t type, chunk_t *encoding,
&asn1, CRED_PART_END) ||
cred_encoding_args(args, CRED_PART_ECDSA_PUB_ASN1_DER,
&asn1, CRED_PART_END) ||
cred_encoding_args(args, CRED_PART_PUB_ASN1_DER,
&asn1, CRED_PART_END) ||
cred_encoding_args(args, CRED_PART_EDDSA_PUB_ASN1_DER,
&asn1, CRED_PART_END) ||
cred_encoding_args(args, CRED_PART_BLISS_PUB_ASN1_DER,
@ -98,7 +100,9 @@ bool pem_encoder_encode(cred_encoding_type_t type, chunk_t *encoding,
label ="BLISS PRIVATE KEY";
break;
}
if (cred_encoding_args(args, CRED_PART_EDDSA_PRIV_ASN1_DER,
if (cred_encoding_args(args, CRED_PART_PRIV_ASN1_DER,
&asn1, CRED_PART_END) ||
cred_encoding_args(args, CRED_PART_EDDSA_PRIV_ASN1_DER,
&asn1, CRED_PART_END))
{
label ="PRIVATE KEY";

7
src/libstrongswan/plugins/pem/pem_plugin.c
View File

@ -69,6 +69,13 @@ METHOD(plugin_t, get_features, int,
PLUGIN_REGISTER(PRIVKEY, pem_private_key_load, FALSE),
PLUGIN_PROVIDE(PRIVKEY, KEY_ED448),
PLUGIN_DEPENDS(PRIVKEY, KEY_ED448),
PLUGIN_REGISTER(PRIVKEY, pem_private_key_load, FALSE),
PLUGIN_PROVIDE(PRIVKEY, KEY_DILITHIUM_2),
PLUGIN_DEPENDS(PRIVKEY, KEY_DILITHIUM_2),
PLUGIN_PROVIDE(PRIVKEY, KEY_DILITHIUM_3),
PLUGIN_DEPENDS(PRIVKEY, KEY_DILITHIUM_3),
PLUGIN_PROVIDE(PRIVKEY, KEY_DILITHIUM_4),
PLUGIN_DEPENDS(PRIVKEY, KEY_DILITHIUM_4),
/* public key PEM decoding */
PLUGIN_REGISTER(PUBKEY, pem_public_key_load, FALSE),

12
src/libstrongswan/plugins/pkcs8/pkcs8_builder.c
View File

@ -88,6 +88,18 @@ static private_key_t *parse_private_key(chunk_t blob)
type = KEY_ED448;
part = BUILD_EDDSA_PRIV_ASN1_DER;
break;
case OID_DILITHIUM_2:
type = KEY_DILITHIUM_2;
part = BUILD_PRIV_ASN1_DER;
break;
case OID_DILITHIUM_3:
type = KEY_DILITHIUM_3;
part = BUILD_PRIV_ASN1_DER;
break;
case OID_DILITHIUM_4:
type = KEY_DILITHIUM_4;
part = BUILD_PRIV_ASN1_DER;
break;
default:
/* key type not supported */
goto end;

3
src/libstrongswan/plugins/pkcs8/pkcs8_plugin.c
View File

@ -48,6 +48,9 @@ METHOD(plugin_t, get_features, int,
PLUGIN_PROVIDE(PRIVKEY, KEY_ECDSA),
PLUGIN_PROVIDE(PRIVKEY, KEY_ED25519),
PLUGIN_PROVIDE(PRIVKEY, KEY_ED448),
PLUGIN_PROVIDE(PRIVKEY, KEY_DILITHIUM_2),
PLUGIN_PROVIDE(PRIVKEY, KEY_DILITHIUM_3),
PLUGIN_PROVIDE(PRIVKEY, KEY_DILITHIUM_4),
};
*features = f;
return countof(f);

17
src/pki/commands/gen.c
View File

@ -52,6 +52,18 @@ static int gen()
{
type = KEY_ED448;
}
else if (streq(arg, "dilithium2"))
{
type = KEY_DILITHIUM_2;
}
else if (streq(arg, "dilithium3"))
{
type = KEY_DILITHIUM_3;
}
else if (streq(arg, "dilithium4"))
{
type = KEY_DILITHIUM_4;
}
else if (streq(arg, "bliss"))
{
type = KEY_BLISS;
@ -173,8 +185,9 @@ static void __attribute__ ((constructor))reg()
{
command_register((command_t) {
gen, 'g', "gen", "generate a new private key",
{"[--type rsa|ecdsa|ed25519|ed448|bliss] [--size bits] [--safe-primes]",
"[--shares n] [--threshold l] [--outform der|pem]"},
{"[--type rsa|ecdsa|ed25519|ed448|dilithium2|dilithium3|dilithium4|bliss]",
"[--size bits] [--safe-primes] [--shares n] [--threshold l]",
"[--outform der|pem]"},
{
{"help", 'h', 0, "show usage information"},
{"type", 't', 1, "type of key, default: rsa"},

4
src/pki/commands/issue.c
View File

@ -1,6 +1,6 @@
/*
* Copyright (C) 2009 Martin Willi
* Copyright (C) 2015-2019 Andreas Steffen
* Copyright (C) 2015-2020 Andreas Steffen
* HSR Hochschule fuer Technik Rapperswil
*
* This program is free software; you can redistribute it and/or modify it
@ -399,7 +399,7 @@ static int issue()
goto end;
}
DBG2(DBG_LIB, "Reading ca private key:");
DBG2(DBG_LIB, "Reading CA private key:");
if (cakey)
{
private = lib->creds->create(lib->creds, CRED_PRIVATE_KEY,