Enum SealedHost

pub enum SealedHost {
    Plain(IpOrHost),
    Sealed(Box<[u8]>),
}

Contains optionally encrypted IpOrHost.

This is useful for hiding the IpOrHost instance from the Entry node. The client first encrypts the IpOrHost instance via SealedHost::seal using the Exit node’s public key. Upon receiving the SealedHost instance by the Exit node, it can call SealedHost::unseal using its private key to get the original IpOrHost instance.

Sealing is fully randomized and therefore does not leak information about equal IpOrHost instances.

The length of the encrypted host is also obscured by the use of random padding before encryption.

Example

use libp2p_identity::PeerId;
use hopr_crypto_types::prelude::{Keypair, OffchainKeypair};
use hopr_network_types::prelude::{IpOrHost, SealedHost};

let keypair = OffchainKeypair::random();

let exit_node_peer_id: PeerId = keypair.public().into();
let host: IpOrHost = "127.0.0.1:1000".parse()?;

// On the Client
let encrypted = SealedHost::seal(host.clone(), keypair.public().into())?;

// On the Exit node
let decrypted = encrypted.unseal(&keypair)?;
assert_eq!(host, decrypted);

// Plain SealedHost unseals trivially
let plain_sealed: SealedHost = host.clone().into();
assert_eq!(host, plain_sealed.try_into()?);

// The same host sealing is randomized
let encrypted_1 = SealedHost::seal(host.clone(), keypair.public().into())?;
let encrypted_2 = SealedHost::seal(host.clone(), keypair.public().into())?;
assert_ne!(encrypted_1, encrypted_2);

Variants

Plain(IpOrHost)

Plain (not sealed) IpOrHost

Sealed(Box<[u8]>)

Encrypted IpOrHost

Implementations

impl SealedHost

pub fn try_as_plain(self) -> Option<IpOrHost>

pub const fn try_as_plain_ref(&self) -> Option<&IpOrHost>

pub fn try_as_plain_mut(&mut self) -> Option<&mut IpOrHost>

pub fn try_as_sealed(self) -> Option<Box<[u8]>>

pub const fn try_as_sealed_ref(&self) -> Option<&Box<[u8]>>

pub fn try_as_sealed_mut(&mut self) -> Option<&mut Box<[u8]>>

impl SealedHost

pub const PADDING_CHAR: char = '@'

Character that can be appended to the host to obscure its length.

User can add as many of this character to the host, and it will be removed during unsealing.

pub fn seal(host: IpOrHost, peer_id: PeerId) -> Result<Self>

Seals the given IpOrHost using the Exit node’s peer ID.

pub fn unseal(self, key: &OffchainKeypair) -> Result<IpOrHost>

Tries to unseal the sealed IpOrHost using the private key as Exit node. No-op, if the data is already unsealed.

Trait Implementations

impl Clone for SealedHost

fn clone(&self) -> SealedHost

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SealedHost

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SealedHost

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for SealedHost

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

Formats the value using the given formatter.

impl From<IpOrHost> for SealedHost

fn from(value: IpOrHost) -> Self

Converts to this type from the input type.

impl Hash for SealedHost

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SealedHost

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<SealedHost> for IpOrHost

type Error = NetworkTypeError

The type returned in the event of a conversion error.

fn try_from(value: SealedHost) -> Result<Self, Self::Error>

Performs the conversion.

impl Eq for SealedHost

impl StructuralPartialEq for SealedHost