Struct ecdsa_fun::ECDSA

pub struct ECDSA<NG> {
    pub nonce_gen: NG,
    pub enforce_low_s: bool,
}

An instance of the ECDSA signature scheme.

Fields

nonce_gen: NG

An instance of NonceGen to produce nonces.

enforce_low_s: bool

enforce_low_s: Whether the verify algorithm should enforce that the s component of the signature is low (see BIP-146).

Implementations

impl ECDSA<()>

pub fn verify_only() -> Self

Creates an ECDSA instance that cannot be used to sign messages but can verify signatures.

impl<NG> ECDSA<NG>

pub fn new(nonce_gen: NG) -> Self where
    NG: AddTag, 

Creates a ECDSA instance.

The caller chooses how nonces are generated by providing a NonceGen.

Example

use ecdsa_fun::{nonce, ECDSA};
use rand::rngs::ThreadRng;
use sha2::Sha256;
let nonce_gen = nonce::Synthetic::<Sha256, nonce::GlobalRng<ThreadRng>>::default();
let ecdsa = ECDSA::new(nonce_gen);

pub fn enforce_low_s(self) -> Self

Transforms the ECDSA instance into one which enforces the BIP-146 low s constraint when verifying (it is always low s when signing).

*** DO NOT USE THIS IF VERIFYING BITCOIN TRANSACTIONS FROM THE CHAIN***: BIP-146 is only enforced for transaction relay so you can still have valid high s signatures. This is especially true if you are using the ECDSA adaptor scheme.

impl<NG> ECDSA<NG>

pub fn verification_key_for(&self, secret_key: &Scalar) -> Point

Get the corresponding verification key for a secret key

Example

use ecdsa_fun::{fun::Scalar, ECDSA};
let ecdsa = ECDSA::verify_only();
let secret_key = Scalar::random(&mut rand::thread_rng());
let verification_key = ecdsa.verification_key_for(&secret_key);

#[must_use]pub fn verify(
    &self,
    verification_key: &Point<impl PointType, Public, NonZero>,
    message: &[u8; 32],
    signature: &Signature<impl Secrecy>
) -> bool

Verify an ECDSA signature.

impl<NG: NonceGen> ECDSA<NG>

pub fn sign(&self, secret_key: &Scalar, message_hash: &[u8; 32]) -> Signature

Deterministically produce a ECDSA signature on a message hash.

Examples

use ecdsa_fun::{
    fun::{digest::Digest, g, marker::*, Scalar, G},
    nonce, ECDSA,
};
use rand::rngs::ThreadRng;
use sha2::Sha256;
let secret_key = Scalar::random(&mut rand::thread_rng());
let nonce_gen = nonce::Synthetic::<Sha256, nonce::GlobalRng<ThreadRng>>::default();
let ecdsa = ECDSA::new(nonce_gen);
let verification_key = ecdsa.verification_key_for(&secret_key);
let message_hash = {
    let message = b"Attack at dawn";
    let mut message_hash = [0u8; 32];
    let hash = Sha256::default().chain(message);
    message_hash.copy_from_slice(hash.finalize().as_ref());
    message_hash
};
let signature = ecdsa.sign(&secret_key, &message_hash);
assert!(ecdsa.verify(&verification_key, &message_hash, &signature));

Trait Implementations

impl<NG: Clone> Clone for ECDSA<NG>

pub fn clone(&self) -> ECDSA<NG>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<NG: Debug> Debug for ECDSA<NG>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<NG: Default> Default for ECDSA<NG>

pub fn default() -> ECDSA<NG>

Returns the "default value" for a type.