Struct NodeKeySignature 

pub struct NodeKeySignature {
    pub sig_kind: SigKind,
    pub pubkey: Vec<u8>,
    pub key_id: Vec<u8>,
    pub signature: Vec<u8>,
    pub nested: Option<Box<NodeKeySignature>>,
    pub wrapping_pubkey: Vec<u8>,
}

A node-key signature (Go tka.NodeKeySignature): proof that a node’s key is authorized under the tailnet-lock authority. Decoded from the CBOR blob a peer presents.

Fields

sig_kind: SigKind

Signature kind.

pubkey: Vec<u8>

The node public key this signature authorizes (Go Pubkey).

key_id: Vec<u8>

The id of the trusted Key that signed this (Go KeyID).

signature: Vec<u8>

The Ed25519 signature bytes.

nested: Option<Box<NodeKeySignature>>

For SigKind::Rotation, the nested (prior) signature.

wrapping_pubkey: Vec<u8>

For rotation, the wrapping public key the nested signature authorized.

Implementations

impl NodeKeySignature

pub fn serialize(&self) -> Vec<u8>

The canonical CBOR serialization of this signature including its signature field (Go NodeKeySignature.Serialize / tkatype.MarshaledSignature). This is the raw byte form a node submits to control (base64’d on the wire by the /machine/tka/sign RPC) and the form Authority::node_key_authorized decodes. The inverse of the crate’s NKS decoder.

pub fn sign_direct( node_key: &[u8], signing_key: &SigningKey, ) -> NodeKeySignature

Build a Direct NodeKeySignature that authorizes node_key, signed by the trusted network-lock key signing_key (Go tka.signNodeKey for the direct case / NLPrivate.SignNKS over a NodeKeySignature{SigKind: SigKindDirect}).

The signature is over NodeKeySignature::sig_hash (the CBOR with the Signature field nil’d), and key_id is recorded as the signer’s 32-byte ed25519 public key verbatim (Go’s Key25519/NLKey id is its public key). The signature is plain RFC 8032 ed25519 (ed25519.Sign); a Direct leaf is verified cofactored under ZIP-215 (ed25519consensus / our [verify_ed25519_zip215]), which accepts a standard dalek signature — the same valid sign-dalek / verify-zip215 relationship Authority::node_key_authorized’s tests rely on. Takes a raw ed25519_dalek::SigningKey so this crate stays free of a key-wrapper dependency; the caller holds the NetworkLockPrivateKey and passes its inner signing key.

The resulting signature authorizes exactly node_key: Authority::node_key_authorized accepts it for that node key (when the signer is trusted) and rejects it for any other (TkaError::NodeKeyMismatch). nested/wrapping_pubkey are empty — those are for SigKind::Rotation, not a direct signature.

pub fn sign_rotation( node_key: &[u8], inner_signer: &SigningKey, pivot_key: &SigningKey, ) -> NodeKeySignature

Build a single-level Rotation chain authorizing node_key, rooted in a trusted key (Go tka.signNodeKey for the rotation case). Constructs the inner Direct itself — the trusted inner_signer signs over the rotation pivot (pivot_key’s public key), with the pivot recorded as the inner’s wrapping_pubkey (set before signing, as Go’s rotation-pivot inner does) — then the pivot key signs the outer rotation wrap over node_key. The outer wrap verifies as standard ed25519 (not ZIP-215); the inner Direct as ZIP-215. The resulting chain’s prev_node_keys names the pivot pubkey (the key being rotated away).

Symmetric companion to sign_direct for the rotation case, so a caller (and the crate’s tests) can construct a genuinely-verifiable rotation chain without hand-encoding CBOR. For deeper chains, feed the result back in as a further pivot.

Trait Implementations

impl Clone for NodeKeySignature

fn clone(&self) -> NodeKeySignature

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NodeKeySignature

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

Formats the value using the given formatter.

impl Eq for NodeKeySignature

impl PartialEq for NodeKeySignature

fn eq(&self, other: &NodeKeySignature) -> 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 NodeKeySignature