[][src]Struct sequoia_openpgp::types::Timestamp

pub struct Timestamp(_);

A timestamp representable by OpenPGP.

OpenPGP timestamps are represented as u32 containing the number of seconds elapsed since midnight, 1 January 1970 UTC (Section 3.5 of RFC 4880).

They cannot express dates further than 7th February of 2106 or earlier than the UNIX epoch. Unlike Unix's time_t, OpenPGP's timestamp is unsigned so it rollsover in 2106, not 2038.


Signature creation time is internally stored as a Timestamp:

Note that this example retrieves raw packet value. Use SubpacketArea::signature_creation_time to get the signature creation time.

use sequoia_openpgp as openpgp;
use std::convert::From;
use std::time::SystemTime;
use openpgp::cert::prelude::*;
use openpgp::policy::StandardPolicy;
use openpgp::packet::signature::subpacket::{SubpacketTag, SubpacketValue};

let (cert, _) =
    CertBuilder::general_purpose(None, Some("alice@example.org"))

let subkey = cert.keys().subkeys().next().unwrap();
let packets = subkey.bundle().self_signatures()[0].hashed_area();

match packets.lookup(SubpacketTag::SignatureCreationTime).unwrap().value() {
    SubpacketValue::SignatureCreationTime(ts) => assert!(u32::from(*ts) > 0),
    v => panic!("Unexpected subpacket: {:?}", v),

let p = &StandardPolicy::new();
let now = SystemTime::now();
assert!(subkey.binding_signature(p, now)?.signature_creation_time().is_some());


impl Timestamp[src]

pub fn now() -> Timestamp[src]

Returns the current time.

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

Adds a duration to this timestamp.

Returns None if the resulting timestamp is not representable.

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

Subtracts a duration from this timestamp.

Returns None if the resulting timestamp is not representable.

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

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.

The lower limit floor represents the earliest time the timestamp will be rounded down to.

See also 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. This can be achieved by using the floor parameter.

To ensure validity, use this function to round the time down, using the latest known relevant timestamp as a floor. Then, lookup all keys and other objects like userids using this timestamp, 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);

let cert_creation_alice = now.checked_sub(Duration::weeks(2)?).unwrap();
let cert_creation_bob = now.checked_sub(Duration::weeks(1)?).unwrap();

// Generate a Cert for Alice.
let (alice, _) = CertBuilder::new()

// Generate a Cert for Bob.
let (bob, _) = CertBuilder::new()

let sign_with_p = |p| -> Result<Signature> {
    // Round `now` down, then use `t` for all lookups.
    // Use the creation time of Bob's Cert as lower bound for rounding.
    let t: std::time::SystemTime = now.round_down(p, cert_creation_bob)?.into();

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

    // 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(|| anyhow::anyhow!("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(22).is_ok());  // Rounded to bob's cert's creation time.
assert!(sign_with_p(32).is_err()); // Invalid precision

Trait Implementations

impl From<Timestamp> for u32[src]

impl From<u32> for Timestamp[src]

impl From<Timestamp> for SystemTime[src]

impl From<Timestamp> for Option<SystemTime>[src]

impl Eq for Timestamp[src]

impl PartialOrd<Timestamp> for Timestamp[src]

impl Copy for Timestamp[src]

impl PartialEq<Timestamp> for Timestamp[src]

impl Clone for Timestamp[src]

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

Performs copy-assignment from source. Read more

impl Ord for Timestamp[src]

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

Compares and returns the maximum of two values. Read more

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

Compares and returns the minimum of two values. Read more

impl Display for Timestamp[src]

impl Hash for Timestamp[src]

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

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

impl Debug for Timestamp[src]

impl TryFrom<SystemTime> for Timestamp[src]

type Error = Error

The type returned in the event of a conversion error.

Auto Trait Implementations

impl Send for Timestamp

impl Sync for Timestamp

Blanket Implementations

impl<T> From for T[src]

impl<T, U> Into for T where
    U: From<T>, 

impl<T> ToOwned for T where
    T: Clone

type Owned = T

impl<T> ToString for T where
    T: Display + ?Sized

impl<T, U> TryFrom for T where
    U: Into<T>, 

type Error = Infallible

The type returned in the event of a conversion error.

impl<T> Borrow for T where
    T: ?Sized

impl<T> BorrowMut for T where
    T: ?Sized

impl<T> Any for T where
    T: 'static + ?Sized

impl<T, U> TryInto for T where
    U: TryFrom<T>, 

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> DynClone for T where
    T: Clone