moonbitstack/mooncrypt/sign/ed25519

sign

moonbitstack/mooncrypt/sign/ed25519 does not have a README file

PrivateKey

type PrivateKey

An Ed25519 signing key: the 32-byte secret seed, not the expanded scalar.

RFC 8032 calls the seed the private key and derives everything else from it, which is why a key file holds 32 bytes and not 64.

impl Signer for PrivateKey

fn sign(self : PrivateKey, msg : BytesView) -> Bytes

source

Sign a message (RFC 8032 §5.1.6).

The same key and message always give the same signature: the nonce is SHA-512(prefix ∥ message) rather than a random number, which is what makes the scheme immune to the entropy failures that have leaked ECDSA keys.

PrivateKey::bytes

source

fn PrivateKey::bytes(self : PrivateKey) -> Bytes

The secret this key was built from — the 32-byte seed for a key from [PrivateKey::new], and whatever was handed to [PrivateKey::of_secret] otherwise.

PrivateKey::new

source

fn PrivateKey::new(seed : BytesView) -> PrivateKey raise @moonbitstack/mooncrypt/spec.Broken
Broken

Read a signing key from its 32-byte seed.

PrivateKey::of_secret

source

fn PrivateKey::of_secret(secret : BytesView) -> PrivateKey

A signing key from a secret of any length.

[PrivateKey::new] takes the 32-byte seed the key format stores. The expansion itself — SHA-512 over the secret, then clamping — is defined for an input of any length; RFC 8032 fixes the seed at 32 octets so that keys have one written form, not because the arithmetic needs it. MariaDB's client_ed25519 keys a connection with the password directly, which is the protocol this entry point exists for.

Anything that holds a real seed wants new: it is the one that refuses a secret of the wrong length, and a length check is worth having.

PrivateKey::public

source

fn PrivateKey::public(self : PrivateKey) -> PublicKey

The verification key that matches this signing key: A = [s]B.

PrivateKey::sign

source

fn PrivateKey::sign(self : PrivateKey, msg : BytesView) -> Bytes

PublicKey

source

type PublicKey

An Ed25519 verification key: a point on Edwards25519 in its 32-byte compressed form.

impl Verifier for PublicKey

fn verify(self : PublicKey, msg : BytesView, sig : BytesView) -> Bool

source

Check a 64-byte signature (RFC 8032 §5.1.7): [S]B = R + [k]A.

S at or above the group order is rejected, which is what stops a valid signature being rewritten into a second, different, also-valid one.

PublicKey::bytes

source

fn PublicKey::bytes(self : PublicKey) -> Bytes

The 32 bytes this key is written as.

PublicKey::new

source

fn PublicKey::new(raw : BytesView) -> PublicKey raise @moonbitstack/mooncrypt/spec.Broken
Broken

Read a public key from its 32 compressed bytes.

PublicKey::verify

source

fn PublicKey::verify(self : PublicKey, msg : BytesView, sig : BytesView) -> Bool

key_size

source

let key_size : Int

The length of a seed, a public key and half a signature.

sig_size

source

let sig_size : Int

The length of a signature: R ∥ S.

Source Files

ed25519.mbt

Install

Download zip

mooncrypt — cryptographic algorithms for MoonBit, one algorithm per package: SHA-1, SHA-2, MD5, HMAC, HKDF, PBKDF2, Ed25519, ECDSA P-256 and RSA PKCS#1 v1.5, on a small set of traits so a third algorithm drops in without touching the library.

cryptocryptographyhashsha256hmaced25519ecdsarsajwtmoonbit