Struct sequoia_openpgp::types::Timestamp

pub struct Timestamp(_);

A timestamp representable by OpenPGP.

Methods

impl Timestamp

pub fn now() -> Timestamp

Returns the current time.

pub fn checked_add(&self, d: Duration) -> Option<Timestamp>

Adds a duration to this timestamp.

Returns None if the resulting timestamp is not representable.

pub fn checked_sub(&self, d: Duration) -> Option<Timestamp>

Subtracts a duration from this timestamp.

Returns None if the resulting timestamp is not representable.

pub fn round_down<P>(&self, precision: P) -> Result<Timestamp> where
    P: Into<Option<u8>>, 

Rounds down to the given level of precision.

This can be used to reduce the metadata leak resulting from time stamps. For example, a group of people attending a key signing event could be identified by comparing the time stamps of resulting certifications. By rounding the creation time of these signatures down, all of them, and others, fall into the same bucket.

The given level p determines the resulting resolution of 2^p seconds. The default is 21, which results in a resolution of 24 days, or roughly a month. p must be lower than 32.

See Duration::round_up.

Important note

If we create a signature, it is important that the signature's creation time does not predate the signing keys creation time, or otherwise violate the key's validity constraints. The correct way to use this interface is to round the time down, lookup all keys and other objects like userids using this time, and on success create the signature:

use sequoia_openpgp::policy::StandardPolicy;

let policy = &StandardPolicy::new();

// Let's fix a time.
let now = Timestamp::from(1583436160);

// Generate a Cert for Alice.
let (alice, _) = CertBuilder::new()
    .set_creation_time(now.checked_sub(Duration::weeks(2)?).unwrap())
    .set_primary_key_flags(KeyFlags::default().set_certification(true))
    .add_userid("alice@example.org")
    .generate()?;

// Generate a Cert for Bob.
let (bob, _) = CertBuilder::new()
    .set_creation_time(now.checked_sub(Duration::weeks(1)?).unwrap())
    .set_primary_key_flags(KeyFlags::default().set_certification(true))
    .add_userid("bob@example.org")
    .generate()?;

let sign_with_p = |p| -> Result<Signature> {
    // Round `now` down, then use `t` for all lookups.
    let t: std::time::SystemTime = now.round_down(p)?.into();

    /// First, get the certification key.
    let mut keypair =
        alice.keys().with_policy(policy, t).secret().for_certification()
        .nth(0).ok_or_else(|| failure::err_msg("no valid key at"))?
        .key().clone().into_keypair()?;

    // Then, lookup the binding between `bob@example.org` and
    // `bob` at `t`.
    let ca = bob.userids().with_policy(policy, t)
        .filter(|ca| ca.userid().value() == b"bob@example.org")
        .nth(0).ok_or_else(|| failure::err_msg("no valid userid"))?;

    // Finally, Alice certifies the binding between
    // `bob@example.org` and `bob` at `t`.
    ca.userid().certify(&mut keypair, &bob,
                        SignatureType::PositiveCertification, None, t)
};

assert!(sign_with_p(21).is_ok());
assert!(sign_with_p(22).is_err()); // Rounded-down t predates key, uid.

There are two possible policies that can be implemented using this mechanism. If protecting the timestamp is more important than the signature, the process must fail. Otherwise, increasing the precision until all constraints are satisfied will find a timestamp approximating now, assuming that the constraints are satisfied at now.

Trait Implementations

impl Arbitrary for Timestamp

fn arbitrary<G: Gen>(g: &mut G) -> Self

fn shrink(&self) -> Box<dyn Iterator<Item = Self> + 'static>

impl Clone for Timestamp

fn clone(&self) -> Timestamp

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Timestamp

impl Debug for Timestamp

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

Formats the value using the given formatter.

impl Eq for Timestamp

impl From<Timestamp> for u32

fn from(t: Timestamp) -> Self

Performs the conversion.

impl From<Timestamp> for SystemTime

fn from(t: Timestamp) -> Self

Performs the conversion.

impl From<u32> for Timestamp

fn from(t: u32) -> Self

Performs the conversion.

impl Hash for Timestamp

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, 

Feeds a slice of this type into the given [Hasher].

impl Ord for Timestamp

fn cmp(&self, other: &Timestamp) -> Ordering

This method returns an [Ordering] between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl PartialEq<Timestamp> for Timestamp

fn eq(&self, other: &Timestamp) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Timestamp) -> bool

This method tests for !=.

impl PartialOrd<Timestamp> for Timestamp

fn partial_cmp(&self, other: &Timestamp) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Timestamp) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Timestamp) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Timestamp) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Timestamp) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralEq for Timestamp

impl StructuralPartialEq for Timestamp

impl TryFrom<SystemTime> for Timestamp

type Error = Error

The type returned in the event of a conversion error.

fn try_from(t: SystemTime) -> Result<Self>

Performs the conversion.