Struct ReplayLog

pub(crate) struct ReplayLog<T> {
    seen: Filter,
    file: Option<PersistFile>,
    replay_log_type: PhantomData<T>,
}

A probabilistic data structure to record fingerprints of observed Introduce2 messages.

We need to record these fingerprints to prevent replay attacks; see the module documentation for an explanation of why that would be bad.

A ReplayLog should correspond to a KP_hss_ntor key, and should have the same lifespan: dropping it sooner will enable replays, but dropping it later will waste disk and memory.

False positives are allowed, to conserve on space.

Fields

seen: Filter

The inner probabilistic data structure.

file: Option<PersistFile>

Persistent state file etc., if we’re persistent

If is is None, this RelayLog is ephemeral.

replay_log_type: PhantomData<T>

PhantomData so rustc doesn’t complain about the unused type param.

This type represents the type of data that we’re storing, as well as the type of the key/name for that data.

Implementations

impl<T: ReplayLogType> ReplayLog<T>

pub(crate) fn new_ephemeral() -> Self

Create a new ReplayLog not backed by any data storage.

pub(crate) fn new_logged( dir: &InstanceRawSubdir, name: &T::Name, ) -> Result<Self, CreateIptError>

Create a ReplayLog backed by the file at a given path.

If the file already exists, load its contents and append any new contents to it; otherwise, create the file.

lock must already have been locked and this cannot be assured by the type system.

Limitations

It is the caller’s responsibility to make sure that there are never two ReplayLogs open at once for the same path, or for two paths that resolve to the same file.

fn new_logged_inner( path: impl AsRef<Path>, lock: Arc<LockFileGuard>, ) -> Result<Self>

Inner function for new_logged, with reified arguments and raw error type

fn truncate_to_multiple(file: &mut File, current_len: u64) -> Result<()>

Truncate file to contain a whole number of records

current_len should have come from file.metadata().

pub(crate) fn check_for_replay( &mut self, message: &T::Message, ) -> Result<(), ReplayError>

Test whether we have already seen message.

If we have seen it, return Err(ReplayError::AlreadySeen). (Since this is a probabilistic data structure, there is a chance of returning this error even if we have we have not seen this particular message)

Otherwise, return Ok(()).

pub(crate) fn flush(&mut self) -> Result<(), Error>

Flush any buffered data to disk.

pub(crate) fn parse_log_leafname( leaf: &OsStr, ) -> Result<T::Name, Cow<'static, str>>

Tries to parse a filename in the replay logs directory

If the leafname refers to a file that would be created by ReplayLog::new_logged, returns the name as a Rust type.

Otherwise returns an error explaining why it isn’t, as a plain string (for logging).