Struct PersistState 

pub struct PersistState {
    pub machine_key: MachinePrivateKey,
    pub network_lock_key: NetworkLockPrivateKey,
    pub node_key: NodePrivateKey,
    pub old_node_key: Option<NodePublicKey>,
    pub acme_account_key: Option<Zeroizing<Vec<u8>>>,
}

The portion of the key state that should be retained between runs of the same device.

Disco keys are ephemeral and should be generated anew each time a device runs, so are excluded from this state.

At-rest protection is the embedder’s responsibility

The secret-bearing fields here are zeroized in memory on drop (the dedicated key types and the Zeroizing-wrapped ACME account key), but that is an in-process hygiene measure only. Protecting this state at rest — restrictive file permissions (e.g. 0o600), full-disk or filesystem encryption, secure-enclave/keyring storage — is entirely the responsibility of the embedding application that serializes and writes it to durable storage. This crate neither reads nor writes files and makes no at-rest guarantee (see SECURITY.md).

Fields

machine_key: MachinePrivateKey

The MachinePrivateKey for the hardware this Tailnet peer runs on.

network_lock_key: NetworkLockPrivateKey

The NetworkLockPrivateKey for this Tailnet peer, for use with Tailnet Lock.

node_key: NodePrivateKey

The NodePrivateKey for this Tailnet peer.

old_node_key: Option<NodePublicKey>

The node’s PREVIOUS node public key, recorded during a node-key rotation so the next registration sends it as RegisterRequest.OldNodeKey for key continuity (Go’s regen flow). None outside a rotation (the default). Reactive / embedder-driven — matching Go, this fork does NOT auto-rotate the node key before expiry (Go deliberately doesn’t either; key expiry is a human-re-auth control). See PersistState::rotate_node_key.

acme_account_key: Option<Zeroizing<Vec<u8>>>

The persisted ACME account key (PKCS#8 DER of an ECDSA P-256 key), or None if no ACME account has been provisioned for this node. The acme cert-issuance path loads this to keep the same Let’s Encrypt account identity across renewals; absent, the runtime generates an ephemeral per-call key (a new ACME account each issuance). #[serde(default)] so key files written before this field load as None (mirrors old_node_key).

Wrapped in Zeroizing so the DER private-key bytes are wiped from memory on drop. Zeroizing<Vec<u8>> serializes transparently via its inner Vec, so the persisted JSON shape is identical to a bare Vec<u8> (a byte array).

Implementations

impl PersistState

pub fn rotate_node_key(&mut self)

Rotate the node key for re-registration, mirroring Go’s regen flow: record the current node public key as old_node_key and replace the node key with a freshly-generated one. The next registration that uses this state will send the prior key as RegisterRequest.OldNodeKey, so control links the new node key to the node’s existing identity instead of treating it as a brand-new node.

This is the embedder-driven rotation primitive (re-create the device with the returned state). It is reactive, NOT a pre-expiry auto-rotator: Go has no such timer, because node-key expiry is a deliberate periodic human/IdP re-attestation control. Re-registration still requires a valid auth credential, exactly as a fresh registration does.

Trait Implementations

impl Clone for PersistState

fn clone(&self) -> PersistState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PersistState

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

Formats the value using the given formatter.

impl Default for PersistState

fn default() -> PersistState

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PersistState

fn deserialize<__D>( __deserializer: __D, ) -> Result<PersistState, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&NodeState> for PersistState

fn from(value: &NodeState) -> PersistState

Converts to this type from the input type.

impl From<&PersistState> for NodeState

fn from(value: &PersistState) -> NodeState

Converts to this type from the input type.

impl From<NodeState> for PersistState

fn from(value: NodeState) -> PersistState

Converts to this type from the input type.

impl From<PersistState> for NodeState

fn from(value: PersistState) -> NodeState

Converts to this type from the input type.

impl Serialize for PersistState

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.