Struct Hello 

pub struct Hello {
    pub proto_min: u32,
    pub proto_max: u32,
    pub card: RuntimeCard,
    pub nonce: String,
    pub ts: u64,
    pub to: Option<String>,
}

A dialer’s hello: everything the answerer needs to decide whether to link, in one signed message. The nonce makes the exchange unrepeatable — the welcome must echo it, and a nonce is never accepted twice — and the timestamp makes it unstorable, since a hello captured today cannot be presented tomorrow. The protocol range is stated rather than assumed, so two executables of different ages find their common version here and nowhere else.

use majordomus_cli::mesh::identity::NodeIdentity;
use majordomus_cli::mesh::link::{fresh_token, sign, verify_signed, Domain, Hello,
    RuntimeCard, LINK_PROTOCOL_MAX, LINK_PROTOCOL_MIN};

let node = NodeIdentity::ephemeral().unwrap();
let hello = Hello {
    proto_min: LINK_PROTOCOL_MIN,
    proto_max: LINK_PROTOCOL_MAX,
    card: RuntimeCard {
        pk: node.public.public_key.clone(),
        runtime: "00000000000000aa".into(),
        instance: node.public.instance_id.as_str().into(),
        repo: "r".repeat(32),
        name: String::new(),
        version: String::new(),
        features: vec![],
        endpoints: vec![],
    },
    nonce: fresh_token(),
    ts: 1_700_000_000,
    to: None,
};
assert_eq!(hello.nonce.len(), 32, "32 hex of fresh entropy, echoed by the welcome");

let signed = sign(&node, Domain::Hello, serde_json::to_value(&hello).unwrap());
assert!(verify_signed(&node.public.public_key, Domain::Hello, &signed));

Fields

proto_min: u32

The oldest link protocol the dialer speaks.

proto_max: u32

The newest link protocol the dialer speaks.

card: RuntimeCard

The dialer.

nonce: String

32 hex of fresh entropy: the welcome must echo it, and it is never accepted twice.

ts: u64

The dialer’s clock, seconds since the Unix epoch.

to: Option<String>

The runtime key of the runtime this hello is addressed to, when the dialer knows it: inside the signed bytes, so a hello captured on its way to one runtime is refused as misaddressed by every other. Absent from a dialer that does not know whom it dials (a seed, a first contact) and from releases before it existed; such a hello is still accepted, and only an addressed one carries the protection.

Trait Implementations

impl Clone for Hello

fn clone(&self) -> Hello

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Hello

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Hello

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Hello

impl JsonSchema for Hello

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for Hello

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Hello