Struct NodeState 

pub struct NodeState {
    pub disco_keys: DiscoKeyPair,
    pub machine_keys: MachineKeyPair,
    pub network_lock_keys: NetworkLockKeyPair,
    pub node_keys: NodeKeyPair,
    pub old_node_key: Option<NodePublicKey>,
    pub acme_account_key: Option<Zeroizing<Vec<u8>>>,
}

The complete runtime key state for a Tailscale node.

Fields

disco_keys: DiscoKeyPair

The DiscoKeyPair this Tailnet peer uses for the Disco protocol.

These should be randomly generated for each run of a Tailscale device.

machine_keys: MachineKeyPair

The MachineKeyPair for the hardware this Tailnet peer runs on.

network_lock_keys: NetworkLockKeyPair

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

node_keys: NodeKeyPair

The NodeKeyPair for this Tailnet peer.

old_node_key: Option<NodePublicKey>

The node’s previous node public key during a rotation (see PersistState::old_node_key). Threaded to registration as RegisterRequest.OldNodeKey.

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

The persisted ACME account key (PKCS#8 DER), threaded from PersistState::acme_account_key. The acme cert-issuance path reads this to reuse the same Let’s Encrypt account across renewals. None when no ACME account is provisioned.

Wrapped in Zeroizing so the DER private-key bytes are wiped from memory on drop; serializes transparently via the inner Vec (unchanged JSON shape).

Implementations

impl NodeState

pub fn generate() -> NodeState

Generate a new NodeState. All keys get random values.

pub fn rotate_node_key(&mut self)

Rotate the node key for re-registration, the runtime twin of PersistState::rotate_node_key: record the current node public key as old_node_key and replace the node_keys pair with a freshly-generated one. The next registration built from this state sends 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 (Go’s regen/doLogin flow).

Only the node key rotates. The disco and machine keys are deliberately left untouched: the data plane (magicsock/WireGuard sessions, disco) keys on those and on per-peer keys, never on the self node key, so a node-key rotation does not re-key or flap an established tunnel. The node key is a control-plane identity. (The disco ping packet does carry the self node key as a claimed-sender identity — a caller that rotates at runtime should refresh magicsock’s copy so outbound pings advertise the new key, but that is a magicsock concern, not a key-state one.)

old_node_key anchor lifecycle. This records the prior key as old_node_key only if no rotation anchor is already held (old_node_key is currently None). A second rotation before a successful re-register therefore preserves the original pre-expiry key as the anchor, rather than overwriting it with the intermediate rotated key — control links a rotation against the key it already knows, so the anchor must stay pinned to the last registered key, not a transient one. The anchor is released back to None by clear_old_node_key, which the re-register path calls on a successful register: once control has accepted the rotated key, that key is now the node’s known identity, so a subsequent genuine expiry cycle correctly captures it as the new anchor. (A runtime caller that drives repeated rotations is additionally expected not to rotate again while a re-register is unconfirmed; this guard is the belt-and-suspenders.)

pub fn clear_old_node_key(&mut self)

Release the rotation anchor: drop any old_node_key back to None.

Called by the re-register path on a successful register. After control accepts a rotated node key, that key is the node’s known identity, so the next genuine node-key rotation should anchor on it (capture it fresh as old_node_key) rather than re-sending a now-stale prior key. Paired with rotate_node_key’s preserve-if-Some guard: the anchor is captured once per rotation episode and cleared once the episode is confirmed. A no-op when no anchor is held (the steady-state case — every successful map-poll re-register calls this and it harmlessly does nothing while old_node_key is already None).

Trait Implementations

impl Clone for NodeState

fn clone(&self) -> NodeState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NodeState

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

Formats the value using the given formatter.

impl Default for NodeState

fn default() -> NodeState

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for NodeState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for NodeState

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

Formats the value using the given formatter.

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.