Struct SigningKey 

pub struct SigningKey<CS: CipherSuite> { /* private fields */ }

The Device Signing Key.

Implementations

impl<CS: CipherSuite> SigningKey<CS>

pub fn new<R: Csprng>(rng: R) -> Self

Creates a random SigningKey

impl<CS: CipherSuite> SigningKey<CS>

pub fn id(&self) -> Result<SigningKeyId, IdError>

Uniquely identifies the SigningKey Two keys with the same ID are the same key.

pub fn public(&self) -> Result<VerifyingKey<CS>, PkError>

Returns the public half of the key.

impl<CS: CipherSuite> SigningKey<CS>

pub fn sign(&self, msg: &[u8], context: &[u8]) -> Result<Signature<CS>, Error>

Creates a signature over msg bound to some context.

msg must NOT be pre-hashed.

Example

use aranya_crypto::{
    Rng, SigningKey,
    default::{DefaultCipherSuite, DefaultEngine},
};

let sk = SigningKey::<DefaultCipherSuite>::new(Rng);

const MESSAGE: &[u8] = b"hello, world!";
const CONTEXT: &[u8] = b"doc test";
let sig = sk.sign(MESSAGE, CONTEXT).expect("should not fail");

sk.public()
    .expect("signing key should be valid")
    .verify(MESSAGE, CONTEXT, &sig)
    .expect("should not fail");

sk.public()
    .expect("signing key should be valid")
    .verify(MESSAGE, b"wrong context", &sig)
    .expect_err("should fail");

let wrong_sig = sk
    .sign(b"different", b"signature")
    .expect("should not fail");
sk.public()
    .expect("signing key should be valid")
    .verify(MESSAGE, CONTEXT, &wrong_sig)
    .expect_err("should fail");

pub fn sign_cmd(&self, cmd: Cmd<'_>) -> Result<(Signature<CS>, CmdId), Error>

Creates a signature over a named policy command.

Example

use aranya_crypto::{
    BaseId, Cmd, Rng, SigningKey,
    default::{DefaultCipherSuite, DefaultEngine},
    id::IdExt as _,
    policy::CmdId,
};

let sk = SigningKey::<DefaultCipherSuite>::new(Rng);

let data = b"... some command data ...";
let name = "AddDevice";
let parent_id = &CmdId::random(Rng);

let good_cmd = Cmd {
    data,
    name,
    parent_id,
};
let (sig, _) = sk.sign_cmd(good_cmd).expect("should not fail");
sk.public()
    .expect("signing key should be valid")
    .verify_cmd(good_cmd, &sig)
    .expect("should not fail");

let wrong_name_cmd = Cmd {
    data,
    name: "wrong name",
    parent_id,
};
sk.public()
    .expect("signing key should be valid")
    .verify_cmd(wrong_name_cmd, &sig)
    .expect_err("should fail");

let wrong_id_cmd = Cmd {
    data,
    name,
    parent_id: &CmdId::random(Rng),
};
sk.public()
    .expect("signing key should be valid")
    .verify_cmd(wrong_id_cmd, &sig)
    .expect_err("should fail");

let wrong_sig_cmd = Cmd {
    data: b"different",
    name: "signature",
    parent_id: &CmdId::random(Rng),
};
let (wrong_sig, _) = sk.sign_cmd(wrong_sig_cmd).expect("should not fail");
sk.public()
    .expect("signing key should be valid")
    .verify_cmd(good_cmd, &wrong_sig)
    .expect_err("should fail");

Trait Implementations

impl<CS: CipherSuite> Clone for SigningKey<CS>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<CS: CipherSuite> ConstantTimeEq for SigningKey<CS>

fn ct_eq(&self, other: &Self) -> Choice

Determine if two items are equal.

fn ct_ne(&self, other: &Self) -> Choice

Determine if two items are NOT equal.

impl<CS: CipherSuite> Debug for SigningKey<CS>

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

Formats the value using the given formatter.

impl<CS: CipherSuite> Display for SigningKey<CS>

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

Formats the value using the given formatter.

impl<CS: CipherSuite> Identified for SigningKey<CS>

type Id = Id<SigningKeyIdTag>

Uniquely identifies the object.

fn id(&self) -> Result<Self::Id, IdError>

Uniquely identifies the object.

impl<CS: CipherSuite> UnwrappedKey<CS> for SigningKey<CS>

const ID: AlgId

The key’s algorithm identifier.

fn into_secret(self) -> Secret<CS>

Converts itself into the underlying Secret.

fn try_from_secret(key: UnwrappedSecret<CS>) -> Result<Self, WrongKeyType>

Converts itself from a UnwrappedSecret.

impl<CS: CipherSuite> ZeroizeOnDrop for SigningKey<CS>