Struct CoseVerifyKey 

pub struct CoseVerifyKey { /* private fields */ }

A key a message may be verified with, bound to exactly one algorithm.

Opaque: built from bytes (ed25519, p256_sec1, hmac, hmac_from_secret) and read back as bytes (ed25519_bytes, p256_sec1_uncompressed), so no ed25519-dalek or p256 type is part of this crate’s public API and either can be upgraded without a breaking change.

Internally an enum over key types, not a bag of bytes, so the classic COSE/JOSE mistake is unrepresentable: an Ed25519 public key can never be used as an HMAC secret (an attacker who knows the public key could otherwise MAC anything with it), and a P-256 key can never verify an Ed25519 signature.

One key, one algorithm. An HMAC key carries the algorithm it was configured for, and supports matches it exactly: a secret deployed for HMAC 256/256 never accepts a 64-bit HMAC 256/64 tag, which a sender could otherwise pick to cut a forger’s work from 2²⁵⁶ to 2⁶⁴ online attempts. (The two share a kid: RFC 9679’s symmetric thumbprint covers only the secret. A deployment that wants both lists the secret twice, once per algorithm.)

The RFC 9679 thumbprint is computed once, at construction.

Implementations

impl CoseVerifyKey

pub fn ed25519(public: &[u8; 32]) -> Result<CoseVerifyKey, CratestackError>

An Ed25519 (-19) public key from its 32 bytes. Fails with CratestackError::Validation for bytes that are not a point encoding.

pub fn p256_sec1(sec1: &[u8]) -> Result<CoseVerifyKey, CratestackError>

A P-256 (-9) public key from its SEC1 encoding (compressed or not). Fails with CratestackError::Validation for a point not on the curve.

pub fn hmac( alg: CoseAlg, secret: impl Into<Vec<u8>>, ) -> Result<CoseVerifyKey, CratestackError>

An HMAC secret for exactly alg (CoseAlg::Hmac256_64 or CoseAlg::Hmac256_256). Fails with CratestackError::Validation for another algorithm or a secret below 32 bytes (see HmacSecret).

pub fn hmac_from_secret( alg: CoseAlg, secret: HmacSecret, ) -> Result<CoseVerifyKey, CratestackError>

As hmac, from an already validated HmacSecret (the counterpart of HmacSigner::from_secret), so a secret loaded once can back a signer and a verification key without its bytes passing through a plain Vec again. Fails with CratestackError::Validation for a non-HMAC alg.

pub fn alg(&self) -> CoseAlg

The one algorithm this key verifies.

pub fn supports(&self, alg: CoseAlg) -> bool

Whether this key can verify messages of alg: exactly alg.

pub fn thumbprint(&self) -> [u8; 32]

The key’s RFC 9679 thumbprint.

pub fn kid(&self) -> [u8; 8]

The key’s kid (§3): the first 8 bytes of its thumbprint.

pub fn ed25519_bytes(&self) -> Option<[u8; 32]>

The 32-byte Ed25519 public key, or None for another key type.

pub fn p256_sec1_uncompressed(&self) -> Option<[u8; 65]>

The uncompressed SEC1 P-256 point (0x04 ‖ x ‖ y, 65 bytes), or None for another key type.

Trait Implementations

impl Clone for CoseVerifyKey

fn clone(&self) -> CoseVerifyKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CoseVerifyKey

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

Formats the value using the given formatter.

impl Eq for CoseVerifyKey

impl PartialEq for CoseVerifyKey

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for CoseVerifyKey