Struct SecretKey 

pub struct SecretKey(/* private fields */);

P-224 (secp224r1) ECDSA secret key.

Supports signing and ECDH key agreement. Messages are hashed with SHA-256, truncated to the leftmost 224 bits as specified by FIPS 186-4.

Signing

use crypto::p224::SecretKey;

let key = SecretKey::generate().unwrap();
let signature = key.sign(b"message").unwrap();

ECDH key exchange

use crypto::p224::SecretKey;

let alice = SecretKey::generate().unwrap();
let bob = SecretKey::generate().unwrap();
let alice_shared = alice.ecdh(&bob.public_key()).unwrap();
let bob_shared = bob.ecdh(&alice.public_key()).unwrap();
assert_eq!(alice_shared, bob_shared);

Security

The raw shared secret from ecdh must not be used directly as an encryption key. Apply a KDF (e.g. HKDF) first.

Implementations

impl SecretKey

pub fn generate() -> Result<SecretKey, EllipticCurveError>

Generates a fresh random secret key.

pub fn from_bytes(key: &[u8; 28]) -> Result<SecretKey, EllipticCurveError>

Builds a secret key from its 28-byte big-endian scalar.

Returns EllipticCurveError::InvalidKey when the scalar is zero or greater than or equal to the group order.

pub fn public_key(&self) -> PublicKey

Returns the corresponding public key.

pub fn sign(&self, message: &[u8]) -> Result<[u8; 56], EllipticCurveError>

Signs message with ECDSA using SHA-256 (truncated to the leftmost 224 bits) and deterministic (RFC 6979) nonces.

The emitted signature is always in canonical low-s form (s <= n / 2), so a given key and message always produce the exact same signature bytes. This prevents signature malleability for systems that hash the signature bytes (e.g. transaction ids, replay caches).

Verification remains permissive by default (both s and n - s are accepted); use PublicKey::verify_strict if high-s signatures must be rejected.

pub fn ecdh( &self, peer_public: &PublicKey, ) -> Result<[u8; 28], EllipticCurveError>

Computes the ECDH shared secret with peer_public.

Security

The raw shared secret must not be used directly as an encryption key. Apply a KDF (e.g. HKDF) first.

pub fn to_bytes(&self) -> [u8; 28]

Returns the secret scalar as 28 big-endian bytes.

Trait Implementations

impl Clone for SecretKey

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Drop for SecretKey

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Eq for SecretKey

impl PartialEq for SecretKey

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for SecretKey

impl Zeroize for SecretKey

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.