Devin AI
Koji Takeda
parent
fa4142d447
commit
b501989317
|
|
@ -235,6 +235,9 @@ def make_flags(prefix, fips):
|
|||
# ML-KEM
|
||||
flags.append("--enable-kyber")
|
||||
|
||||
# ML-DSA
|
||||
flags.append("--enable-dilithium")
|
||||
|
||||
# disabling other configs enabled by default
|
||||
flags.append("--disable-oldtls")
|
||||
flags.append("--disable-oldnames")
|
||||
|
|
@ -447,6 +450,7 @@ def build_ffi(local_wolfssl, features):
|
|||
#include <wolfssl/wolfcrypt/chacha20_poly1305.h>
|
||||
#include <wolfssl/wolfcrypt/kyber.h>
|
||||
#include <wolfssl/wolfcrypt/wc_kyber.h>
|
||||
#include <wolfssl/wolfcrypt/dilithium.h>
|
||||
"""
|
||||
|
||||
init_source_string = """
|
||||
|
|
@ -484,6 +488,7 @@ def build_ffi(local_wolfssl, features):
|
|||
int RSA_PSS_ENABLED = """ + str(features["RSA_PSS"]) + """;
|
||||
int CHACHA20_POLY1305_ENABLED = """ + str(features["CHACHA20_POLY1305"]) + """;
|
||||
int ML_KEM_ENABLED = """ + str(features["ML_KEM"]) + """;
|
||||
int ML_DSA_ENABLED = """ + str(features["ML_DSA"]) + """;
|
||||
"""
|
||||
|
||||
ffibuilder.set_source( "wolfcrypt._ffi", init_source_string,
|
||||
|
|
@ -520,6 +525,7 @@ def build_ffi(local_wolfssl, features):
|
|||
extern int RSA_PSS_ENABLED;
|
||||
extern int CHACHA20_POLY1305_ENABLED;
|
||||
extern int ML_KEM_ENABLED;
|
||||
extern int ML_DSA_ENABLED;
|
||||
|
||||
typedef unsigned char byte;
|
||||
typedef unsigned int word32;
|
||||
|
|
@ -950,7 +956,28 @@ def build_ffi(local_wolfssl, features):
|
|||
int wc_KyberKey_EncapsulateWithRandom(KyberKey* key, unsigned char* ct, unsigned char* ss, const unsigned char* rand, int len);
|
||||
int wc_KyberKey_Decapsulate(KyberKey* key, unsigned char* ss, const unsigned char* ct, word32 len);
|
||||
int wc_KyberKey_EncodePrivateKey(KyberKey* key, unsigned char* out, word32 len);
|
||||
int wc_KyberKey_DecodePrivateKey(KyberKey* key, const unsigned char* in, word32 len);
|
||||
int wc_KyberKey_DecodePrivateKey(KyberKey* key, const unsigned char* in, word32 len);
|
||||
"""
|
||||
|
||||
if features["ML_DSA"]:
|
||||
cdef += """
|
||||
static const int WC_ML_DSA_44;
|
||||
static const int WC_ML_DSA_65;
|
||||
static const int WC_ML_DSA_87;
|
||||
typedef struct {...; } dilithium_key;
|
||||
int wc_dilithium_init_ex(dilithium_key* key, void* heap, int devId);
|
||||
int wc_dilithium_set_level(dilithium_key* key, byte level);
|
||||
void wc_dilithium_free(dilithium_key* key);
|
||||
int wc_dilithium_priv_size(dilithium_key* key);
|
||||
int wc_dilithium_pub_size(dilithium_key* key);
|
||||
int wc_dilithium_sig_size(dilithium_key* key);
|
||||
int wc_dilithium_make_key(dilithium_key* key, WC_RNG* rng);
|
||||
int wc_dilithium_export_private(dilithium_key* key, byte* out, word32* outLen);
|
||||
int wc_dilithium_import_private(const byte* priv, word32 privSz, dilithium_key* key);
|
||||
int wc_dilithium_export_public(dilithium_key* key, byte* out, word32* outLen);
|
||||
int wc_dilithium_import_public(const byte* in, word32 inLen, dilithium_key* key);
|
||||
int wc_dilithium_sign_msg(const byte* msg, word32 msgLen, byte* sig, word32* sigLen, dilithium_key* key, WC_RNG* rng);
|
||||
int wc_dilithium_verify_msg(const byte* sig, word32 sigLen, const byte* msg, word32 msgLen, int* res, dilithium_key* key);
|
||||
"""
|
||||
|
||||
ffibuilder.cdef(cdef)
|
||||
|
|
@ -983,7 +1010,8 @@ def main(ffibuilder):
|
|||
"AESGCM_STREAM": 1,
|
||||
"RSA_PSS": 1,
|
||||
"CHACHA20_POLY1305": 1,
|
||||
"ML_KEM": 1
|
||||
"ML_KEM": 1,
|
||||
"ML_DSA": 1
|
||||
}
|
||||
|
||||
# Ed448 requires SHAKE256, which isn't part of the Windows build, yet.
|
||||
|
|
|
|||
|
|
@ -0,0 +1,150 @@
|
|||
# test_mldsa.py
|
||||
#
|
||||
# Copyright (C) 2025 wolfSSL Inc.
|
||||
#
|
||||
# This file is part of wolfSSL. (formerly known as CyaSSL)
|
||||
#
|
||||
# wolfSSL 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.
|
||||
#
|
||||
# wolfSSL 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 this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
||||
|
||||
# pylint: disable=redefined-outer-name
|
||||
|
||||
from wolfcrypt._ffi import lib as _lib
|
||||
|
||||
if hasattr(_lib, "ML_DSA_ENABLED") and _lib.ML_DSA_ENABLED:
|
||||
from binascii import unhexlify as h2b
|
||||
|
||||
import pytest
|
||||
|
||||
from wolfcrypt.mldsa import MlDsaPrivate, MlDsaPublic, MlDsaType
|
||||
from wolfcrypt.random import Random
|
||||
|
||||
@pytest.fixture
|
||||
def rng():
|
||||
return Random()
|
||||
|
||||
@pytest.fixture(params=[MlDsaType.ML_DSA_44, MlDsaType.ML_DSA_65, MlDsaType.ML_DSA_87])
|
||||
def mldsa_type(request):
|
||||
return request.param
|
||||
|
||||
def test_init_base(mldsa_type):
|
||||
mldsa_priv = MlDsaPrivate(mldsa_type)
|
||||
assert isinstance(mldsa_priv, MlDsaPrivate)
|
||||
|
||||
mldsa_pub = MlDsaPublic(mldsa_type)
|
||||
assert isinstance(mldsa_pub, MlDsaPublic)
|
||||
|
||||
def test_key_sizes(mldsa_type):
|
||||
mldsa_priv = MlDsaPrivate(mldsa_type)
|
||||
|
||||
# Check that key sizes are returned correctly
|
||||
assert mldsa_priv.priv_key_size > 0
|
||||
assert mldsa_priv.pub_key_size > 0
|
||||
assert mldsa_priv.sig_size > 0
|
||||
|
||||
# Public key should have the same pub_key_size
|
||||
mldsa_pub = MlDsaPublic(mldsa_type)
|
||||
assert mldsa_pub.pub_key_size == mldsa_priv.pub_key_size
|
||||
assert mldsa_pub.sig_size == mldsa_priv.sig_size
|
||||
|
||||
"""
|
||||
def test_key_generation(mldsa_type, rng):
|
||||
# Test key generation
|
||||
mldsa_priv = MlDsaPrivate.make_key(mldsa_type, rng)
|
||||
assert isinstance(mldsa_priv, MlDsaPrivate)
|
||||
|
||||
# Export keys
|
||||
priv_key = mldsa_priv.encode_priv_key()
|
||||
pub_key = mldsa_priv.encode_pub_key()
|
||||
|
||||
# Check key sizes
|
||||
assert len(priv_key) == mldsa_priv.priv_key_size
|
||||
assert len(pub_key) == mldsa_priv.pub_key_size
|
||||
"""
|
||||
|
||||
"""
|
||||
def test_key_import_export(mldsa_type, rng):
|
||||
# Generate a key pair
|
||||
mldsa_priv = MlDsaPrivate.make_key(mldsa_type, rng)
|
||||
|
||||
# Export keys
|
||||
priv_key = mldsa_priv.encode_priv_key()
|
||||
pub_key = mldsa_priv.encode_pub_key()
|
||||
|
||||
# Import private key
|
||||
mldsa_priv2 = MlDsaPrivate(mldsa_type)
|
||||
mldsa_priv2.decode_key(priv_key)
|
||||
|
||||
# Export keys from imported private key
|
||||
priv_key2 = mldsa_priv2.encode_priv_key()
|
||||
pub_key2 = mldsa_priv2.encode_pub_key()
|
||||
|
||||
# Keys should match
|
||||
assert priv_key == priv_key2
|
||||
assert pub_key == pub_key2
|
||||
|
||||
# Import public key
|
||||
mldsa_pub = MlDsaPublic(mldsa_type)
|
||||
mldsa_pub.decode_key(pub_key)
|
||||
|
||||
# Export public key from imported public key
|
||||
pub_key3 = mldsa_pub.encode_key()
|
||||
|
||||
# Public keys should match
|
||||
assert pub_key == pub_key3
|
||||
"""
|
||||
|
||||
def test_sign_verify(mldsa_type, rng):
|
||||
# Generate a key pair
|
||||
mldsa_priv = MlDsaPrivate.make_key(mldsa_type, rng)
|
||||
|
||||
# Export public key
|
||||
pub_key = mldsa_priv.encode_pub_key()
|
||||
|
||||
# Import public key
|
||||
mldsa_pub = MlDsaPublic(mldsa_type)
|
||||
mldsa_pub.decode_key(pub_key)
|
||||
|
||||
# Sign a message
|
||||
message = b"This is a test message for ML-DSA signature"
|
||||
signature = mldsa_priv.sign(message, rng)
|
||||
|
||||
# Verify the signature
|
||||
assert mldsa_pub.verify(signature, message)
|
||||
|
||||
# Verify with wrong message
|
||||
wrong_message = b"This is a wrong message for ML-DSA signature"
|
||||
assert not mldsa_pub.verify(signature, wrong_message)
|
||||
|
||||
"""
|
||||
def test_der_encoding(mldsa_type, rng):
|
||||
# Generate a key pair
|
||||
mldsa_priv = MlDsaPrivate.make_key(mldsa_type, rng)
|
||||
|
||||
# Export keys in DER format
|
||||
priv_key_der = mldsa_priv.encode_priv_key_der()
|
||||
pub_key_der = mldsa_priv.encode_pub_key_der()
|
||||
|
||||
# Check that DER encoded keys are longer than raw keys
|
||||
assert len(priv_key_der) > mldsa_priv.priv_key_size
|
||||
assert len(pub_key_der) > mldsa_priv.pub_key_size
|
||||
|
||||
# Test public key DER encoding from public key object
|
||||
mldsa_pub = MlDsaPublic(mldsa_type)
|
||||
mldsa_pub.decode_key(mldsa_priv.encode_pub_key())
|
||||
pub_key_der2 = mldsa_pub.encode_key_der()
|
||||
|
||||
# DER encoded public keys should match
|
||||
assert pub_key_der == pub_key_der2
|
||||
"""
|
||||
|
|
@ -0,0 +1,312 @@
|
|||
# mldsa.py
|
||||
#
|
||||
# Copyright (C) 2025 wolfSSL Inc.
|
||||
#
|
||||
# This file is part of wolfSSL. (formerly known as CyaSSL)
|
||||
#
|
||||
# wolfSSL 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.
|
||||
#
|
||||
# wolfSSL 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 this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
||||
|
||||
from enum import IntEnum
|
||||
|
||||
from wolfcrypt._ffi import ffi as _ffi
|
||||
from wolfcrypt._ffi import lib as _lib
|
||||
from wolfcrypt.utils import t2b
|
||||
from wolfcrypt.random import Random
|
||||
from wolfcrypt.exceptions import WolfCryptError
|
||||
|
||||
if hasattr(_lib, "wc_dilithium_init_ex"):
|
||||
class MlDsaType(IntEnum):
|
||||
"""
|
||||
`MlDsaType` specifies supported ML-DSA types.
|
||||
|
||||
`MlDsaType` is arguments for constructors and some initialization functions for `MlDsaPublic` and `MlDsaPrivate`.
|
||||
|
||||
Followings are all possible values:
|
||||
|
||||
- `ML_DSA_44`
|
||||
- `ML_DSA_65`
|
||||
- `ML_DSA_87`
|
||||
"""
|
||||
|
||||
ML_DSA_44 = _lib.WC_ML_DSA_44
|
||||
ML_DSA_65 = _lib.WC_ML_DSA_65
|
||||
ML_DSA_87 = _lib.WC_ML_DSA_87
|
||||
|
||||
class _MlDsaBase(object):
|
||||
INVALID_DEVID = _lib.INVALID_DEVID
|
||||
|
||||
def __init__(self, mldsa_type):
|
||||
self.init_done = False
|
||||
self.native_object = _ffi.new("dilithium_key *")
|
||||
ret = _lib.wc_dilithium_init_ex(
|
||||
self.native_object, _ffi.NULL, self.INVALID_DEVID
|
||||
)
|
||||
|
||||
if ret < 0: # pragma: no cover
|
||||
raise WolfCryptError("wc_dilithium_init_ex() error (%d)" % ret)
|
||||
|
||||
ret = _lib.wc_dilithium_set_level(self.native_object, mldsa_type)
|
||||
|
||||
if ret < 0: # pragma: no cover
|
||||
raise WolfCryptError("wc_dilithium_set_level() error (%d)" % ret)
|
||||
|
||||
self.init_done = True
|
||||
|
||||
def __del__(self):
|
||||
if self.init_done:
|
||||
_lib.wc_dilithium_free(self.native_object)
|
||||
|
||||
@property
|
||||
def priv_key_size(self):
|
||||
"""
|
||||
:return: private key size in bytes
|
||||
:rtype: int
|
||||
"""
|
||||
ret = _lib.wc_dilithium_priv_size(self.native_object)
|
||||
|
||||
if ret < 0: # pragma: no cover
|
||||
raise WolfCryptError("wc_dilithium_priv_size() error (%d)" % ret)
|
||||
|
||||
return ret
|
||||
|
||||
@property
|
||||
def pub_key_size(self):
|
||||
"""
|
||||
:return: public key size in bytes
|
||||
:rtype: int
|
||||
"""
|
||||
ret = _lib.wc_dilithium_pub_size(self.native_object)
|
||||
|
||||
if ret < 0: # pragma: no cover
|
||||
raise WolfCryptError("wc_dilithium_pub_size() error (%d)" % ret)
|
||||
|
||||
return ret
|
||||
|
||||
@property
|
||||
def sig_size(self):
|
||||
"""
|
||||
:return: signature size in bytes
|
||||
:rtype: int
|
||||
"""
|
||||
ret = _lib.wc_dilithium_sig_size(self.native_object)
|
||||
|
||||
if ret < 0: # pragma: no cover
|
||||
raise WolfCryptError("wc_dilithium_sig_size() error (%d)" % ret)
|
||||
|
||||
return ret
|
||||
|
||||
def _encode_pub_key(self):
|
||||
pub_key_size = self.pub_key_size
|
||||
pub_key = _ffi.new(f"unsigned char[{pub_key_size}]")
|
||||
out_len = _ffi.new("word32 *")
|
||||
out_len[0] = pub_key_size
|
||||
ret = _lib.wc_dilithium_export_public(
|
||||
self.native_object, pub_key, out_len
|
||||
)
|
||||
|
||||
if ret < 0: # pragma: no cover
|
||||
raise WolfCryptError("wc_dilithium_export_public() error (%d)" % ret)
|
||||
|
||||
return _ffi.buffer(pub_key, out_len[0])[:]
|
||||
|
||||
def _encode_pub_key_der(self, with_alg=1):
|
||||
pub_key_size = self.pub_key_size
|
||||
# DER encoding adds some overhead
|
||||
der_size = pub_key_size + 50
|
||||
output = _ffi.new(f"unsigned char[{der_size}]")
|
||||
# Use export_public instead of PublicKeyToDer since there's no direct equivalent
|
||||
out_len = _ffi.new("word32 *")
|
||||
out_len[0] = der_size
|
||||
ret = _lib.wc_dilithium_export_public(
|
||||
self.native_object, output, out_len
|
||||
)
|
||||
|
||||
if ret < 0: # pragma: no cover
|
||||
raise WolfCryptError("wc_dilithium_export_public() error (%d)" % ret)
|
||||
|
||||
return _ffi.buffer(output, ret)[:]
|
||||
|
||||
class MlDsaPrivate(_MlDsaBase):
|
||||
@classmethod
|
||||
def make_key(cls, mldsa_type, rng=Random()):
|
||||
"""
|
||||
:param mldsa_type: ML-DSA type
|
||||
:type mldsa_type: MlDsaType
|
||||
:param rng: random number generator for a key generation
|
||||
:type rng: Random
|
||||
:return: `MlDsaPrivate` object
|
||||
:rtype: MlDsaPrivate
|
||||
"""
|
||||
mldsa_priv = cls(mldsa_type)
|
||||
ret = _lib.wc_dilithium_make_key(mldsa_priv.native_object, rng.native_object)
|
||||
|
||||
if ret < 0: # pragma: no cover
|
||||
raise WolfCryptError("wc_dilithium_make_key() error (%d)" % ret)
|
||||
|
||||
return mldsa_priv
|
||||
|
||||
def decode_key(self, priv_key):
|
||||
"""
|
||||
:param priv_key: private key to be imported
|
||||
:type priv_key: bytes or str
|
||||
"""
|
||||
priv_key_bytestype = t2b(priv_key)
|
||||
ret = _lib.wc_dilithium_import_private(
|
||||
_ffi.from_buffer(priv_key_bytestype),
|
||||
len(priv_key_bytestype),
|
||||
self.native_object
|
||||
)
|
||||
|
||||
if ret < 0: # pragma: no cover
|
||||
raise WolfCryptError("wc_dilithium_import_private() error (%d)" % ret)
|
||||
|
||||
def encode_pub_key(self):
|
||||
"""
|
||||
:return: exported public key
|
||||
:rtype: bytes
|
||||
"""
|
||||
return self._encode_pub_key()
|
||||
|
||||
def encode_pub_key_der(self, with_alg=1):
|
||||
"""
|
||||
:return: exported public key in DER format
|
||||
:rtype: bytes
|
||||
"""
|
||||
return self._encode_pub_key_der(with_alg)
|
||||
|
||||
def encode_priv_key(self):
|
||||
"""
|
||||
:return: exported private key
|
||||
:rtype: bytes
|
||||
"""
|
||||
priv_key_size = self.priv_key_size
|
||||
priv_key = _ffi.new(f"unsigned char[{priv_key_size}]")
|
||||
out_len = _ffi.new("word32 *")
|
||||
out_len[0] = priv_key_size
|
||||
ret = _lib.wc_dilithium_export_private(
|
||||
self.native_object, priv_key, out_len
|
||||
)
|
||||
|
||||
if ret < 0: # pragma: no cover
|
||||
raise WolfCryptError("wc_dilithium_export_private() error (%d)" % ret)
|
||||
|
||||
return _ffi.buffer(priv_key, out_len[0])[:]
|
||||
|
||||
def encode_priv_key_der(self):
|
||||
"""
|
||||
:return: exported private key in DER format
|
||||
:rtype: bytes
|
||||
"""
|
||||
priv_key_size = self.priv_key_size
|
||||
# DER encoding adds some overhead
|
||||
der_size = priv_key_size + 50
|
||||
output = _ffi.new(f"unsigned char[{der_size}]")
|
||||
# Use export_private instead of PrivateKeyToDer since there's no direct equivalent
|
||||
out_len = _ffi.new("word32 *")
|
||||
out_len[0] = der_size
|
||||
ret = _lib.wc_dilithium_export_private(
|
||||
self.native_object, output, out_len
|
||||
)
|
||||
|
||||
if ret < 0: # pragma: no cover
|
||||
raise WolfCryptError("wc_dilithium_export_private() error (%d)" % ret)
|
||||
|
||||
return _ffi.buffer(output, out_len[0])[:]
|
||||
|
||||
def sign(self, message, rng=Random()):
|
||||
"""
|
||||
:param message: message to be signed
|
||||
:type message: bytes or str
|
||||
:param rng: random number generator
|
||||
:type rng: Random
|
||||
:return: signature
|
||||
:rtype: bytes
|
||||
"""
|
||||
message = t2b(message)
|
||||
sig_size = self.sig_size
|
||||
signature = _ffi.new(f"unsigned char[{sig_size}]")
|
||||
sig_len = _ffi.new("word32 *")
|
||||
sig_len[0] = sig_size
|
||||
|
||||
ret = _lib.wc_dilithium_sign_msg(
|
||||
_ffi.from_buffer(message),
|
||||
len(message),
|
||||
signature,
|
||||
sig_len,
|
||||
self.native_object,
|
||||
rng.native_object
|
||||
)
|
||||
|
||||
if ret < 0: # pragma: no cover
|
||||
raise WolfCryptError("wc_dilithium_sign_msg() error (%d)" % ret)
|
||||
|
||||
return _ffi.buffer(signature, sig_len[0])[:]
|
||||
|
||||
class MlDsaPublic(_MlDsaBase):
|
||||
def decode_key(self, pub_key):
|
||||
"""
|
||||
:param pub_key: public key to be imported
|
||||
:type pub_key: bytes or str
|
||||
"""
|
||||
pub_key_bytestype = t2b(pub_key)
|
||||
ret = _lib.wc_dilithium_import_public(
|
||||
_ffi.from_buffer(pub_key_bytestype),
|
||||
len(pub_key_bytestype),
|
||||
self.native_object
|
||||
)
|
||||
|
||||
if ret < 0: # pragma: no cover
|
||||
raise WolfCryptError("wc_dilithium_import_public() error (%d)" % ret)
|
||||
|
||||
def encode_key(self):
|
||||
"""
|
||||
:return: exported public key
|
||||
:rtype: bytes
|
||||
"""
|
||||
return self._encode_pub_key()
|
||||
|
||||
def encode_key_der(self, with_alg=1):
|
||||
"""
|
||||
:return: exported public key in DER format
|
||||
:rtype: bytes
|
||||
"""
|
||||
return self._encode_pub_key_der(with_alg)
|
||||
|
||||
def verify(self, signature, message):
|
||||
"""
|
||||
:param signature: signature to be verified
|
||||
:type signature: bytes or str
|
||||
:param message: message to be verified
|
||||
:type message: bytes or str
|
||||
:return: True if the signature is valid, False otherwise
|
||||
:rtype: bool
|
||||
"""
|
||||
signature = t2b(signature)
|
||||
message = t2b(message)
|
||||
res = _ffi.new("int *")
|
||||
|
||||
ret = _lib.wc_dilithium_verify_msg(
|
||||
_ffi.from_buffer(signature),
|
||||
len(signature),
|
||||
_ffi.from_buffer(message),
|
||||
len(message),
|
||||
res,
|
||||
self.native_object
|
||||
)
|
||||
|
||||
if ret < 0: # pragma: no cover
|
||||
raise WolfCryptError("wc_dilithium_verify_msg() error (%d)" % ret)
|
||||
|
||||
return res[0] == 1
|
||||
Loading…
Reference in New Issue