Struct PublicKey 

pub struct PublicKey<L: SecurityLevel = Level1> { /* private fields */ }

SQIsign public key: a Montgomery curve coefficient plus a torsion hint byte.

Wire size: 65 bytes (Level 1), 97 bytes (Level 3), 129 bytes (Level 5).

Verify a signature

Use pk.verify(msg, &sig) via the Verifier trait. It accepts any signature type: Signature, ExpandedSignature, CompressedSignature, or AnySignature.

use hex_literal::hex;
use sqisign_verify::{PublicKey, Signature, Verifier};

let pk_bytes = hex!(
    "07CCD21425136F6E865E497D2D4D208F0054AD81372066E817480787AAF7B202"
    "9550C89E892D618CE3230F23510BFBE68FCCDDAEA51DB1436B462ADFAF008A01"
    "0B"
);
let sig_bytes = hex!(
    "84228651F271B0F39F2F19F2E8718F31ED3365AC9E5CB303AFE663D0CFC11F04"
    "55D891B0CA6C7E653F9BA2667730BB77BEFE1B1A31828404284AF8FD7BAACC01"
    "0001D974B5CA671FF65708D8B462A5A84A1443EE9B5FED7218767C9D85CEED04"
    "DB0A69A2F6EC3BE835B3B2624B9A0DF68837AD00BCACC27D1EC806A448402674"
    "71D86EFF3447018ADB0A6551EE8322AB30010202"
);
let msg = hex!(
    "D81C4D8D734FCBFBEADE3D3F8A039FAA2A2C9957E835AD55B22E75BF57BB556A"
    "C8"
);

let pk: PublicKey = PublicKey::from_bytes(&pk_bytes)?;
let sig: Signature = Signature::from_bytes(&sig_bytes)?;
pk.verify(&msg, &sig)?;

Decode and re-encode

use hex_literal::hex;
use sqisign_verify::PublicKey;

let pk_bytes = hex!(
    "07CCD21425136F6E865E497D2D4D208F0054AD81372066E817480787AAF7B202"
    "9550C89E892D618CE3230F23510BFBE68FCCDDAEA51DB1436B462ADFAF008A01"
    "0B"
);
let pk: PublicKey = PublicKey::from_bytes(&pk_bytes)?;
assert_eq!(pk_bytes, pk.to_bytes().as_slice());

Display

Display prints the wire-format bytes as lowercase hex:

let hex_str = format!("{pk}");
assert!(hex_str.starts_with("07ccd214"));

Implementations

impl<L: FpBackend> PublicKey<L>

pub fn curve(&self) -> &EcCurve<L>

pub fn hint_pk(&self) -> u8

impl<L: FpBackend> PublicKey<L>

pub fn to_bytes(&self) -> Array<u8, L::PkLen>

Encode a public key to bytes (wire format).

pub fn from_bytes(bytes: &[u8]) -> Result<Self, Error>

where L: LevelPrecomp,

Decode a public key from bytes (wire format).

Rejects non-canonical hint_pk values to ensure each logical public key has exactly one valid wire encoding.

Trait Implementations

impl<L: Clone + SecurityLevel> Clone for PublicKey<L>

fn clone(&self) -> PublicKey<L>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<L: FpBackend> Debug for PublicKey<L>

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

Formats the value using the given formatter.

impl<L: FpBackend> Default for PublicKey<L>

fn default() -> Self

Returns the “default value” for a type.

impl<L: FpBackend> Display for PublicKey<L>

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

Formats the value using the given formatter.

impl<L: FpBackend + LevelPrecomp> TryFrom<&[u8]> for PublicKey<L>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(bytes: &[u8]) -> Result<Self, Self::Error>

Performs the conversion.

impl<L: FpBackend + LevelPrecomp> Verifier<AnySignature<L>> for PublicKey<L>

fn verify(&self, msg: &[u8], sig: &AnySignature<L>) -> Result<(), Error>

Use Self to verify that the provided signature for a given message bytestring is authentic.

impl<L: FpBackend + LevelPrecomp> Verifier<CompressedSignature<L>> for PublicKey<L>

fn verify(&self, msg: &[u8], sig: &CompressedSignature<L>) -> Result<(), Error>

Use Self to verify that the provided signature for a given message bytestring is authentic.

impl<L: FpBackend + LevelPrecomp> Verifier<ExpandedSignature<L>> for PublicKey<L>

fn verify(&self, msg: &[u8], sig: &ExpandedSignature<L>) -> Result<(), Error>

Use Self to verify that the provided signature for a given message bytestring is authentic.

impl<L: FpBackend + LevelPrecomp> Verifier<Signature<L>> for PublicKey<L>

fn verify(&self, msg: &[u8], sig: &Signature<L>) -> Result<(), Error>

Use Self to verify that the provided signature for a given message bytestring is authentic.