methanium/mtp
Watch
3
0
Fork
You've already forked mtp
 0
Code Issues Pull requests 3 Projects Releases 22 Packages Wiki Activity Actions

Values, Cleaning, Docs, Tests, Example (Current Example is Wrong)

Browse source
This commit is contained in:
Alex Emmet 2026-06-22 23:29:18 +02:00
commit c2a7afe6c1
37 changed files with 1693 additions and 520 deletions
Download patch file Download diff file Expand all files Collapse all files

102
crypto/src/sign.rs
View file

@ -46,6 +46,14 @@ impl Ed25519Signer {
pub fn public_key(&self) -> SignaturePublicKey {
SignaturePublicKey::new(self.public.to_bytes().to_vec())
}
pub fn signing_key(&self) -> &ed25519_dalek::SigningKey {
&self.secret
}
pub fn verifying_key(&self) -> &ed25519_dalek::VerifyingKey {
&self.public
}
}
#[cfg(feature = "ed25519-dalek")]
@ -104,23 +112,26 @@ impl MlDsaSigner {
secret_key: &SignaturePqPrivateKey,
public_key: &SignaturePqPublicKey,
) -> Result<Self, CryptoError> {
let encoded_sk =
ml_dsa::EncodedSigningKey::<ml_dsa::MlDsa65>::try_from(secret_key.as_bytes())
.map_err(|_| CryptoError::KeyGenerationFailed)?;
let secret = ml_dsa::SigningKey::<ml_dsa::MlDsa65>::decode(&encoded_sk);
let seed_bytes: [u8; 32] = secret_key
.as_bytes()
.try_into()
.map_err(|_| CryptoError::KeyGenerationFailed)?;
let seed = ml_dsa::Seed::from(seed_bytes);
let secret = ml_dsa::SigningKey::<ml_dsa::MlDsa65>::from_seed(&seed);
let encoded_pk =
ml_dsa::EncodedVerifyingKey::<ml_dsa::MlDsa65>::try_from(public_key.as_bytes())
.map_err(|_| CryptoError::KeyGenerationFailed)?;
let public = ml_dsa::VerifyingKey::<ml_dsa::MlDsa65>::decode(&encoded_pk);
Ok(Self { secret, public })
}
pub fn generate() -> (Self, SignaturePqPrivateKey, SignaturePqPublicKey) {
use ml_dsa::KeyGen;
let kp = ml_dsa::MlDsa65::key_gen(&mut rand_core::OsRng);
let secret = kp.signing_key().clone();
let public = kp.verifying_key().clone();
let priv_key = SignaturePqPrivateKey::new(secret.encode().to_vec());
use ml_dsa::{Generate, Keypair};
let secret = ml_dsa::SigningKey::<ml_dsa::MlDsa65>::generate();
let public = secret.verifying_key();
let priv_key = SignaturePqPrivateKey::new(secret.to_seed().to_vec());
let pub_key = SignaturePqPublicKey::new(public.encode().to_vec());
let signer = Self { secret, public };
(signer, priv_key, pub_key)
@ -142,20 +153,17 @@ impl MlDsaSigner {
#[cfg(feature = "ml-dsa")]
impl SignatureScheme for MlDsaSigner {
fn sign(&self, msg: &[u8]) -> Result<Vec<u8>, CryptoError> {
use ml_dsa::signature::Signer;
let signature = self.secret.sign(msg);
use ml_dsa::Signer;
let signature = self.secret.try_sign(msg)
.map_err(|_| CryptoError::SigningFailed)?;
Ok(signature.encode().to_vec())
}
fn verify(&self, msg: &[u8], signature: &[u8]) -> Result<(), CryptoError> {
use ml_dsa::signature::Verifier;
let encoded_sig =
ml_dsa::EncodedSignature::<ml_dsa::MlDsa65>::try_from(signature)
.map_err(|_| CryptoError::InvalidSignature)?;
let sig = ml_dsa::Signature::<ml_dsa::MlDsa65>::decode(&encoded_sig)
.ok_or(CryptoError::InvalidSignature)?;
self.public
.verify(msg, &sig)
use ml_dsa::Verifier;
let sig = ml_dsa::Signature::<ml_dsa::MlDsa65>::try_from(signature)
.map_err(|_| CryptoError::InvalidSignature)?;
self.public.verify(msg, &sig)
.map_err(|_| CryptoError::VerificationFailed)
}
}
@ -166,23 +174,22 @@ pub fn verify_ml_dsa(
msg: &[u8],
signature: &[u8],
) -> Result<(), CryptoError> {
use ml_dsa::signature::Verifier;
use ml_dsa::Verifier;
let encoded_pk =
ml_dsa::EncodedVerifyingKey::<ml_dsa::MlDsa65>::try_from(public_key.as_bytes())
.map_err(|_| CryptoError::InvalidSignature)?;
let public = ml_dsa::VerifyingKey::<ml_dsa::MlDsa65>::decode(&encoded_pk);
let encoded_sig =
ml_dsa::EncodedSignature::<ml_dsa::MlDsa65>::try_from(signature)
.map_err(|_| CryptoError::InvalidSignature)?;
let sig = ml_dsa::Signature::<ml_dsa::MlDsa65>::decode(&encoded_sig)
.ok_or(CryptoError::InvalidSignature)?;
let sig = ml_dsa::Signature::<ml_dsa::MlDsa65>::try_from(signature)
.map_err(|_| CryptoError::InvalidSignature)?;
public
.verify(msg, &sig)
.map_err(|_| CryptoError::VerificationFailed)
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct DualSignature {
pub ed25519: Vec<u8>,
pub mldsa: Vec<u8>,
@ -194,12 +201,18 @@ pub fn sign_dual(
mldsa_sk: &ml_dsa::SigningKey<ml_dsa::MlDsa65>,
message: &[u8],
) -> DualSignature {
use ed25519_dalek::Signer;
DualSignature {
ed25519: ed25519_sk.sign(message).to_bytes().to_vec(),
mldsa: mldsa_sk.sign(message).encode().to_vec(),
}
let ed25519 = {
use ed25519_dalek::Signer;
ed25519_sk.sign(message).to_bytes().to_vec()
};
let mldsa = {
use ml_dsa::Signer;
mldsa_sk.try_sign(message)
.expect("ML-DSA signing failed")
.encode()
.to_vec()
};
DualSignature { ed25519, mldsa }
}
impl DualSignature {
@ -210,22 +223,23 @@ impl DualSignature {
mldsa_vk: &ml_dsa::VerifyingKey<ml_dsa::MlDsa65>,
message: &[u8],
) -> Result<(), CryptoError> {
use ed25519_dalek::Verifier;
let ed_sig = ed25519_dalek::Signature::from_slice(&self.ed25519)
.map_err(|_| CryptoError::InvalidSignature)?;
ed25519_vk
.verify(message, &ed_sig)
.map_err(|_| CryptoError::VerificationFailed)?;
{
use ed25519_dalek::Verifier;
ed25519_vk
.verify(message, &ed_sig)
.map_err(|_| CryptoError::VerificationFailed)?;
}
let encoded_sig =
ml_dsa::EncodedSignature::<ml_dsa::MlDsa65>::try_from(self.mldsa.as_slice())
.map_err(|_| CryptoError::InvalidSignature)?;
let ml_sig = ml_dsa::Signature::<ml_dsa::MlDsa65>::decode(&encoded_sig)
.ok_or(CryptoError::InvalidSignature)?;
mldsa_vk
.verify(message, &ml_sig)
.map_err(|_| CryptoError::VerificationFailed)?;
let ml_sig = ml_dsa::Signature::<ml_dsa::MlDsa65>::try_from(self.mldsa.as_slice())
.map_err(|_| CryptoError::InvalidSignature)?;
{
use ml_dsa::Verifier;
mldsa_vk
.verify(message, &ml_sig)
.map_err(|_| CryptoError::VerificationFailed)?;
}
Ok(())
}