Struct SignedPacket

Source

pub struct SignedPacket { /* private fields */ }

Expand description

Signed DNS packet

Implementations§

Source §

impl SignedPacket

Source

pub const MAX_BYTES: u64 = 1104

Maximum legal size of the binary representation of a SignedPacket.

Calculated from the maximum size of a value in Mainline DHT’s mutable values; 1000 bytes, plus the number of bytes in a Signature (64), and a Timestamp (8) and a public key (32).

Source

pub fn builder() -> SignedPacketBuilder

Create a SignedPacket using a builder.

 use pkarr::{SignedPacket, Keypair, dns::rdata::SVCB};
  
 let keypair = Keypair::random();

 let signed_packet = SignedPacket::builder()
    // A record
    .address(
        "_derp_region.iroh.".try_into().unwrap(),
        "1.1.1.1".parse().unwrap(),
        30,
    )
    // AAAA record
    .address(
        "_derp_region.iroh.".try_into().unwrap(),
        "3002:0bd6:0000:0000:0000:ee00:0033:6778".parse().unwrap(),
        30,
    )
    // CNAME record
    .cname(
        "subdomain.".try_into().unwrap(),
        "example.com".try_into().unwrap(),
        30
    )
    // TXT record
    .txt(
        "_proto".try_into().unwrap(),
        "foo=bar".try_into().unwrap(),
        30
    )
    // HTTPS record
    .https(
        // You can make a record at the Apex (at the same TLD as your public key)
        ".".try_into().unwrap(),
        SVCB::new(0, "https.example.com".try_into().unwrap()),
        3600,
    )
    // SVCB record
    .https(
        ".".try_into().unwrap(),
        SVCB::new(0, "https.example.com".try_into().unwrap()),
        3600,
    )
    .sign(&keypair)
    .unwrap();

Source

pub fn new( keypair: &Keypair, answers: &[ResourceRecord<'_>], timestamp: Timestamp, ) -> Result<SignedPacket, SignedPacketBuildError>

Creates a new SignedPacket from a Keypair and ResourceRecords as the answers section of a DNS Packet, and a Timestamp.

It will also normalize the names of the ResourceRecords to be relative to the origin, which would be the z-base32 encoded PublicKey of the Keypair used to sign the Packet.

If any name is empty or just a ., it will be normalized to the public key of the keypair.

Source

pub fn from_relay_payload( public_key: &PublicKey, payload: &Bytes, ) -> Result<SignedPacket, SignedPacketVerifyError>

Creates a SignedPacket from a PublicKey and the relays payload.

Source

pub fn as_bytes(&self) -> &Bytes

Returns the serialized signed packet: <32 bytes public_key><64 bytes signature><8 bytes big-endian timestamp in microseconds><encoded DNS packet>

Source

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

Returns a serialized representation of this SignedPacket including the SignedPacket::last_seen timestamp followed by the returned value from SignedPacket::as_bytes.

Source

pub fn deserialize(bytes: &[u8]) -> Result<Self, SimpleDnsError>

Deserialize SignedPacket from a serialized version for persistent storage using SignedPacket::serialize.

If deserializing the SignedPacket::last_seen failed, or is far in the future, it will be unwrapped to default, i.e the UNIX_EPOCH.

That is useful for backwards compatibility if you ever stored the SignedPacket::last_seen as Little Endian in previous versions.

Source

pub fn to_relay_payload(&self) -> Bytes

Returns a slice of the serialized SignedPacket omitting the leading public_key, to be sent as a request/response body to or from relays.

Source

pub fn public_key(&self) -> PublicKey

Returns the PublicKey of the signer of this SignedPacket

Source

pub fn signature(&self) -> Signature

Returns the Signature of the the bencoded sequence number concatenated with the encoded and compressed packet, as defined in BEP_0044

Source

pub fn timestamp(&self) -> Timestamp

Returns the timestamp in microseconds since the UNIX_EPOCH.

This timestamp is authored by the controller of the keypair, and it is trusted as a way to order which packets where authored after which, but it shouldn’t be used for caching for example, instead, use Self::last_seen which is set when you create a new packet.

Source

pub fn encoded_packet(&self) -> Bytes

Returns the DNS Packet compressed and encoded.

Source

pub fn last_seen(&self) -> &Timestamp

Unix last_seen time in microseconds

Source

pub fn set_last_seen(&mut self, last_seen: &Timestamp)

Set the Self::last_seen property

Source

pub fn refresh(&mut self)

Set the Self::last_seen to the current system time

Source

pub fn more_recent_than(&self, other: &SignedPacket) -> bool

Return whether this SignedPacket is more recent than the given one. If the timestamps are erqual, the one with the largest value is considered more recent. Usefel for determining which packet contains the latest information from the Dht. Assumes that both packets have the same PublicKey, you shouldn’t compare packets from different keys.

Source

pub fn is_same_as(&self, other: &SignedPacket) -> bool

Returns true if both packets have the same timestamp and packet, and only differ in Self::last_seen

Source

pub fn resource_records( &self, name: &str, ) -> impl Iterator<Item = &ResourceRecord<'_>>

Return and iterator over the ResourceRecords in the Answers section of the DNS Packet that matches the given name. The name will be normalized to the origin TLD of this packet.

You can use @ to filter the resource records at the Apex (the public key).

Wildcards are also supported, so *.foo.<key> will match bar.foo.<key>.

Source