From fd715efaba6f7c4c8fd20310ba100e1f761be361 Mon Sep 17 00:00:00 2001
From: Martin Hoffmann <martin@nlnetlabs.nl>
Date: Mon, 13 Jul 2020 14:19:20 +0200
Subject: [PATCH 01/19] Parsing and building RTAs.

---
 src/cert/mod.rs        |   7 +
 src/crl.rs             |   7 +
 src/crypto/keys.rs     |  11 +
 src/lib.rs             |   1 +
 src/oid.rs             |   2 +
 src/resources/asres.rs |  24 +-
 src/resources/ipres.rs |  16 +-
 src/roa.rs             |   4 +-
 src/rta.rs             | 852 +++++++++++++++++++++++++++++++++++++++++
 src/sigobj.rs          |  19 +-
 10 files changed, 922 insertions(+), 21 deletions(-)
 create mode 100644 src/rta.rs

diff --git a/src/cert/mod.rs b/src/cert/mod.rs
index 530b7be0..3ca9688e 100644
--- a/src/cert/mod.rs
+++ b/src/cert/mod.rs
@@ -116,6 +116,13 @@ impl Cert {
         cons.take_sequence(Self::from_constructed)
     }
 
+    /// Takes an optional certificate from the beginning of a value.
+    pub fn take_opt_from<S: decode::Source>(
+        cons: &mut decode::Constructed<S>
+    ) -> Result<Option<Self>, S::Err> {
+        cons.take_opt_sequence(Self::from_constructed)
+    }
+
     /// Parses the content of a Certificate sequence.
     pub fn from_constructed<S: decode::Source>(
         cons: &mut decode::Constructed<S>
diff --git a/src/crl.rs b/src/crl.rs
index a38b4c48..f91d2969 100644
--- a/src/crl.rs
+++ b/src/crl.rs
@@ -102,6 +102,13 @@ impl Crl {
         cons.take_sequence(Self::from_constructed)
     }
 
+    /// Takes an encoded CRL from the beginning of a constructed value.
+    pub fn take_opt_from<S: decode::Source>(
+        cons: &mut decode::Constructed<S>
+    ) -> Result<Option<Self>, S::Err> {
+        cons.take_opt_sequence(Self::from_constructed)
+    }
+
     /// Parses the content of a certificate revocation list.
     pub fn from_constructed<S: decode::Source>(
         cons: &mut decode::Constructed<S>
diff --git a/src/crypto/keys.rs b/src/crypto/keys.rs
index 62992353..3ef0bb96 100644
--- a/src/crypto/keys.rs
+++ b/src/crypto/keys.rs
@@ -271,6 +271,17 @@ impl KeyIdentifier {
             Ok(res)
         }
     }
+
+    /// Skips over an encoded key indentifier.
+    pub fn skip_in<S: decode::Source>(
+        cons: &mut decode::Constructed<S>
+    ) -> Result<(), S::Err> {
+        while cons.take_opt_value_if(
+            Tag::OCTET_STRING, OctetString::from_content
+        )?.is_some() {
+        }
+        Ok(())
+    }
 }
 
 
diff --git a/src/lib.rs b/src/lib.rs
index fb9183a6..2c3291d3 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -24,6 +24,7 @@ pub mod oid;
 pub mod resources;
 pub mod roa;
 pub mod rrdp;
+pub mod rta;
 pub mod sigobj;
 pub mod tal;
 pub mod uri;
diff --git a/src/oid.rs b/src/oid.rs
index 20345659..fc5f974c 100644
--- a/src/oid.rs
+++ b/src/oid.rs
@@ -63,6 +63,8 @@ pub const CP_IPADDR_ASNUMBER_V2: Oid<&[u8]> = Oid(&[43, 6, 1, 5, 5, 7, 14, 3]);
 
 pub const CT_RPKI_MANIFEST: ConstOid
     = Oid(&[42, 134, 72, 134, 247, 13, 1, 9, 16, 1, 26]);
+pub const CT_RESOURCE_TAGGED_ATTESTATION: ConstOid
+    = Oid(&[42, 134, 72, 134, 247, 13, 1, 9, 16, 1, 36]);
 
 pub const PE_AUTHORITY_INFO_ACCESS: Oid<&[u8]>
     = Oid(&[43, 6, 1, 5, 5, 7, 1, 1]);
diff --git a/src/resources/asres.rs b/src/resources/asres.rs
index 8dc513f0..7cf16077 100644
--- a/src/resources/asres.rs
+++ b/src/resources/asres.rs
@@ -325,11 +325,23 @@ impl AsBlocks {
 /// # Decoding and Encoding
 ///
 impl AsBlocks {
+    pub fn take_from<S: decode::Source>(
+        cons: &mut decode::Constructed<S>
+    ) -> Result<Self, S::Err> {
+        cons.take_sequence(Self::parse_cons_content)
+    }
+
     /// Parses the content of a AS ID blocks sequence.
     fn parse_content<S: decode::Source>(
         content: &mut decode::Content<S>
     ) -> Result<Self, S::Err> {
         let cons = content.as_constructed()?;
+        Self::parse_cons_content(cons)
+    }
+
+    fn parse_cons_content<S: decode::Source>(
+        cons: &mut decode::Constructed<S>
+    ) -> Result<Self, S::Err> {
         let mut err = None;
 
         let res = SharedChain::from_iter(
@@ -529,7 +541,7 @@ impl AsBlock {
 
 impl AsBlock {
     /// Takes an optional AS bock from the beginning of an encoded value.
-    fn take_opt_from<S: decode::Source>(
+    pub fn take_opt_from<S: decode::Source>(
         cons: &mut decode::Constructed<S>
     ) -> Result<Option<Self>, S::Err> {
         cons.take_opt_value(|tag, content| {
@@ -545,9 +557,8 @@ impl AsBlock {
         })
     }
 
-    /*
     /// Skips over the AS block at the beginning of an encoded value.
-    fn skip_opt_in<S: decode::Source>(
+    pub fn skip_opt_in<S: decode::Source>(
         cons: &mut decode::Constructed<S>
     ) -> Result<Option<()>, S::Err> {
         cons.take_opt_value(|tag, content| {
@@ -562,7 +573,6 @@ impl AsBlock {
             }
         })
     }
-    */
 
     fn encode(self) -> impl encode::Values {
         match self {
@@ -710,7 +720,6 @@ impl AsRange {
         })
     }
 
-    /*
     /// Skips over the content of an AS range value.
     fn skip_content<S: decode::Source>(
         content: &mut decode::Content<S>
@@ -720,7 +729,6 @@ impl AsRange {
         AsId::skip_in(cons)?;
         Ok(())
     }
-    */
 
     fn encode(self) -> impl encode::Values {
         encode::sequence((
@@ -779,14 +787,12 @@ impl AsId {
         cons.take_u32().map(AsId)
     }
 
-    /*
     /// Skips over the AS number at the beginning of an encoded value.
     fn skip_in<S: decode::Source>(
         cons: &mut decode::Constructed<S>
     ) -> Result<(), S::Err> {
         cons.take_u32().map(|_| ())
     }
-    */
 
     /// Parses the content of an AS number value.
     fn parse_content<S: decode::Source>(
@@ -795,14 +801,12 @@ impl AsId {
         content.to_u32().map(AsId)
     }
 
-    /*
     /// Skips the content of an AS number value.
     fn skip_content<S: decode::Source>(
         content: &mut decode::Content<S>
     ) -> Result<(), S::Err> {
         content.to_u32().map(|_| ())
     }
-    */
 
     pub fn encode(self) -> impl encode::Values {
         self.0.encode()
diff --git a/src/resources/ipres.rs b/src/resources/ipres.rs
index 3d19b522..9ad608aa 100644
--- a/src/resources/ipres.rs
+++ b/src/resources/ipres.rs
@@ -348,11 +348,23 @@ impl IpBlocks {
 }
 
 impl IpBlocks {
-    /// Parses the content of an address block sequence.
+    pub fn take_from<S: decode::Source>(
+        cons: &mut decode::Constructed<S>
+    ) -> Result<Self, S::Err> {
+        cons.take_sequence(Self::parse_cons_content)
+    }
+
+    /// Parses the content of a AS ID blocks sequence.
     fn parse_content<S: decode::Source>(
         content: &mut decode::Content<S>
     ) -> Result<Self, S::Err> {
         let cons = content.as_constructed()?;
+        Self::parse_cons_content(cons)
+    }
+
+    fn parse_cons_content<S: decode::Source>(
+        cons: &mut decode::Constructed<S>
+    ) -> Result<Self, S::Err> {
         let mut err = None;
 
         let res = SharedChain::from_iter(
@@ -548,7 +560,7 @@ impl IpBlock {
 
 impl IpBlock {
     /// Takes an optional address block from the beginning of encoded value.
-    fn take_opt_from<S: decode::Source>(
+    pub fn take_opt_from<S: decode::Source>(
         cons: &mut decode::Constructed<S>
     ) -> Result<Option<Self>, S::Err> {
         cons.take_opt_value(|tag, content| {
diff --git a/src/roa.rs b/src/roa.rs
index d24e927e..6455f789 100644
--- a/src/roa.rs
+++ b/src/roa.rs
@@ -63,12 +63,12 @@ impl Roa {
         self.signed.encode_ref()
     }
 
-    /// Returns a DER encoded Captured for this.
+    /// Returns a DER encoded Captured for this ROA.
     pub fn to_captured(&self) -> Captured {
         self.encode_ref().to_captured(Mode::Der)
     }
 
-    /// Returns a reference to the EE certificate of this manifest.
+    /// Returns a reference to the EE certificate of this ROA.
     pub fn cert(&self) -> &Cert {
         self.signed.cert()
     }
diff --git a/src/rta.rs b/src/rta.rs
new file mode 100644
index 00000000..df633505
--- /dev/null
+++ b/src/rta.rs
@@ -0,0 +1,852 @@
+//! Resource Tagged Attestations.
+//!
+//! Resouce Tagged Attestations attaching signed attestations of ownership of 
+//! resources referred to by a docuement. This is currently an IETF draft,
+//! see [draft-michaelson-rpki-rta] for details.
+//!
+//! draft-michaelson-rpki-rta: https://tools.ietf.org/html/draft-michaelson-rpki-rta
+
+use bcder::{decode, encode};
+use bcder::{Captured, Mode, OctetString, Tag};
+use bcder::encode::{PrimitiveContent, Values};
+use bcder::string::OctetStringSource;
+use bcder::xerr;
+use bytes::Bytes;
+use crate::oid;
+use crate::cert::{Cert, ResourceCert};
+use crate::crl::Crl;
+use crate::crypto:: {
+    DigestAlgorithm, KeyIdentifier, Signature, SignatureAlgorithm,
+    Signer, SigningError
+};
+use crate::resources::{
+    AddressFamily, AsBlock, AsBlocksBuilder, IpBlock, IpBlocksBuilder
+};
+use crate::sigobj::{MessageDigest, SignedAttrs};
+use crate::x509::{Time, ValidationError};
+
+
+//------------ Rta -----------------------------------------------------------
+
+#[derive(Clone, Debug)]
+pub struct Rta {
+    signed: MultiSignedObject,
+    content: ResourceTaggedAttestation,
+}
+
+impl Rta {
+    pub fn decode<S: decode::Source>(
+        source: S,
+        strict: bool
+    ) -> Result<Self, S::Err> {
+        let signed = MultiSignedObject::decode(source, strict)?;
+        let content = signed.decode_content(|cons| {
+            ResourceTaggedAttestation::take_from(cons)
+        })?;
+        Ok(Rta { signed, content })
+    }
+
+    pub fn validate<F: FnMut(Cert) -> Result<ResourceCert, ValidationError>>(
+        self, _strict: bool, _validate_cert: F
+    ) -> Result<ResourceTaggedAttestation, ValidationError> {
+        unimplemented!()
+    }
+
+    /// Returns a value encoder for a reference to a ROA.
+    pub fn encode_ref<'a>(&'a self) -> impl encode::Values + 'a {
+        self.signed.encode_ref()
+    }
+
+    /// Returns a DER encoded Captured for this ROA.
+    pub fn to_captured(&self) -> Captured {
+        self.encode_ref().to_captured(Mode::Der)
+    }
+}
+
+
+//------------ ResourceTaggedAttestation -------------------------------------
+
+#[derive(Clone, Debug)]
+pub struct ResourceTaggedAttestation {
+    subject_keys: SubjectKeySet,
+
+    /// AS Resources
+    as_resources: RtaAsBlocks,
+
+    /// IP Resources for the IPv4 address family.
+    v4_resources: RtaIpBlocks,
+
+    /// IP Resources for the IPv6 address family.
+    v6_resources: RtaIpBlocks,
+
+    digest_algorithm: DigestAlgorithm,
+
+    message_digest: MessageDigest,
+}
+
+impl ResourceTaggedAttestation {
+    fn take_from<S: decode::Source>(
+        cons: &mut decode::Constructed<S>
+    ) -> Result<Self, S::Err> {
+        cons.take_sequence(|cons| {
+            cons.take_opt_constructed_if(Tag::CTX_0, |c| c.skip_u8_if(0))?;
+            let subject_keys = SubjectKeySet::take_from(cons)?;
+            let (v4res, v6res, asres) = Self::take_resources_from(cons)?;
+            let alg = DigestAlgorithm::take_from(cons)?;
+            let digest = OctetString::take_from(cons)?;
+            Ok(ResourceTaggedAttestation {
+                subject_keys,
+                v4_resources: v4res,
+                v6_resources: v6res,
+                as_resources: asres,
+                digest_algorithm: alg,
+                message_digest: digest.into(),
+            })
+        })
+    }
+
+    fn take_resources_from<S: decode::Source>(
+        cons: &mut decode::Constructed<S>
+    ) -> Result<(RtaIpBlocks, RtaIpBlocks, RtaAsBlocks), S::Err> {
+        cons.take_sequence(|cons| {
+            let asres = cons.take_opt_constructed_if(Tag::CTX_0, |cons| {
+                RtaAsBlocks::take_from(cons)
+            })?;
+
+            let mut v4 = None;
+            let mut v6 = None;
+            cons.take_opt_constructed_if(Tag::CTX_1, |cons| {
+                cons.take_sequence(|cons| {
+                    while let Some(()) = cons.take_opt_sequence(|cons| {
+                        match AddressFamily::take_from(cons)? {
+                            AddressFamily::Ipv4 => {
+                                if v4.is_some() {
+                                    xerr!(return Err(decode::Malformed.into()));
+                                }
+                                v4 = Some(RtaIpBlocks::take_from(cons)?);
+                            }
+                            AddressFamily::Ipv6 => {
+                                if v6.is_some() {
+                                    xerr!(return Err(decode::Malformed.into()));
+                                }
+                                v6 = Some(RtaIpBlocks::take_from(cons)?);
+                            }
+                        }
+                        Ok(())
+                    })? { }
+                    Ok(())
+                })
+            })?;
+
+            if asres.is_none() && v4.is_none() && v6.is_none() {
+                xerr!(return Err(decode::Malformed.into()));
+            }
+            Ok((
+                v4.unwrap_or_default(),
+                v6.unwrap_or_default(),
+                asres.unwrap_or_default(),
+            ))
+        })
+    }
+
+    pub fn encode_ref<'a>(&'a self) -> impl encode::Values + 'a {
+        encode::sequence((
+            // version is DEFAULT
+            self.subject_keys.encode_ref(),
+            encode::sequence((
+                self.encode_as_resources(),
+                self.encode_ip_resources(),
+            )),
+            self.digest_algorithm.encode(),
+            self.message_digest.encode_ref()
+        ))
+    }
+
+    fn encode_as_resources<'a>(&'a self) -> impl encode::Values + 'a {
+        if self.as_resources.is_empty() {
+            return None
+        }
+        Some(encode::sequence_as(Tag::CTX_0,
+            self.as_resources.encode_ref()
+        ))
+    }
+
+    fn encode_ip_resources<'a>(&'a self) -> impl encode::Values + 'a {
+        if self.v4_resources.is_empty() && self.v6_resources.is_empty() {
+            return None
+        }
+        Some(encode::sequence_as(Tag::CTX_1,
+            encode::sequence((
+                self.v4_resources.encode_ref_family([0x00, 0x01]),
+                self.v6_resources.encode_ref_family([0x00, 0x02]),
+            ))
+        ))
+    }
+
+    fn to_bytes(&self) -> Bytes {
+        self.encode_ref().to_captured(Mode::Der).into_bytes()
+    }
+}
+
+
+//------------ SubjectKeySet -------------------------------------------------
+
+// The captured content only contains the content of the set.
+#[derive(Clone, Debug)]
+pub struct SubjectKeySet(Captured);
+
+impl SubjectKeySet {
+    fn take_from<S: decode::Source>(
+        cons: &mut decode::Constructed<S>
+    ) -> Result<Self, S::Err> {
+        cons.take_set(|cons| {
+            cons.capture(|cons| {
+                KeyIdentifier::skip_in(cons)
+            }).map(SubjectKeySet)
+        })
+    }
+
+    fn encode_ref<'a>(&'a self) -> impl encode::Values + 'a {
+        encode::set(
+            &self.0
+        )
+    }
+}
+
+impl From<Vec<KeyIdentifier>> for SubjectKeySet {
+    fn from(src: Vec<KeyIdentifier>) -> Self {
+        SubjectKeySet(Captured::from_values(
+            Mode::Der,
+            encode::iter(src.iter().map(|item| item.encode_ref()))
+        ))
+    }
+}
+
+
+//------------ RtaAsBlocks ---------------------------------------------------
+
+#[derive(Clone, Debug)]
+pub struct RtaAsBlocks(Captured);
+
+impl RtaAsBlocks {
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+}
+
+impl RtaAsBlocks {
+    fn take_from<S: decode::Source>(
+        cons: &mut decode::Constructed<S>
+    ) -> Result<Self, S::Err> {
+        cons.take_sequence(|cons| {
+            cons.capture(|cons| {
+                while AsBlock::skip_opt_in(cons)?.is_some() { }
+                Ok(())
+            })
+        }).map(RtaAsBlocks)
+    }
+
+    fn encode_ref<'a>(&'a self) -> impl encode::Values + 'a {
+        encode::sequence(
+            &self.0
+        )
+    }
+}
+
+impl Default for RtaAsBlocks {
+    fn default() -> Self {
+        RtaAsBlocks(Captured::empty(Mode::Der))
+    }
+}
+
+impl From<AsBlocksBuilder> for RtaAsBlocks {
+    fn from(src: AsBlocksBuilder) -> RtaAsBlocks {
+        RtaAsBlocks(Captured::from_values(
+            Mode::Der,
+            src.finalize().encode()
+        ))
+    }
+}
+
+
+//------------ RtaIpBlocks ---------------------------------------------------
+
+#[derive(Clone, Debug)]
+pub struct RtaIpBlocks(Captured);
+
+impl RtaIpBlocks {
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+}
+
+impl RtaIpBlocks {
+    fn take_from<S: decode::Source>(
+        cons: &mut decode::Constructed<S>
+    ) -> Result<Self, S::Err> {
+        cons.take_sequence(|cons| {
+            cons.capture(|cons| {
+                while IpBlock::take_opt_from(cons)?.is_some() { }
+                Ok(())
+            })
+        }).map(RtaIpBlocks)
+    }
+
+    fn encode_ref_family<'a>(
+        &'a self,
+        family: [u8; 2]
+    ) -> impl encode::Values + 'a {
+        if self.0.is_empty() {
+            None
+        }
+        else {
+            Some(encode::sequence((
+                OctetString::encode_slice(family),
+                &self.0
+            )))
+        }
+    }
+}
+
+impl Default for RtaIpBlocks {
+    fn default() -> Self {
+        RtaIpBlocks(Captured::empty(Mode::Der))
+    }
+}
+
+impl From<IpBlocksBuilder> for RtaIpBlocks {
+    fn from(src: IpBlocksBuilder) -> RtaIpBlocks {
+        RtaIpBlocks(Captured::from_values(
+            Mode::Der,
+            src.finalize().encode()
+        ))
+    }
+}
+
+
+//------------ MultiSignedObject ---------------------------------------------
+
+/// The flavour of a signed object used for RTAs.
+#[derive(Clone, Debug)]
+pub struct MultiSignedObject {
+    digest_algorithm: DigestAlgorithm,
+    content: OctetString,
+    certificates: CertificateSet,
+    crls: CrlSet,
+    signer_infos: SignerInfoSet,
+}
+
+impl MultiSignedObject {
+    /// Returns a reference to the object’s content.
+    pub fn content(&self) -> &OctetString {
+        &self.content
+    }
+
+    /// Decodes the object’s content.
+    pub fn decode_content<F, T>(&self, op: F) -> Result<T, decode::Error>
+    where F: FnOnce(&mut decode::Constructed<OctetStringSource>)
+                    -> Result<T, decode::Error> {
+        Mode::Der.decode(self.content.to_source(), op)
+    }
+}
+
+impl MultiSignedObject {
+    pub fn decode<S: decode::Source>(
+        source: S,
+        _strict: bool
+    ) -> Result<Self, S::Err> {
+        Mode::Der.decode(source, Self::take_from)
+    }
+
+    pub fn take_from<S: decode::Source>(
+        cons: &mut decode::Constructed<S>
+    ) -> Result<Self, S::Err> {
+        cons.take_sequence(|cons| {
+            oid::SIGNED_DATA.skip_if(cons)?; // contentType
+            cons.take_constructed_if(Tag::CTX_0, |cons| { // content
+                cons.take_sequence(|cons| { // SignedData
+                    cons.skip_u8_if(3)?; // version -- must be 3
+                    let digest_algorithm =
+                        DigestAlgorithm::take_set_from(cons)?;
+                    let content = cons.take_sequence(|cons| {
+                        // encapContentInfo
+                        oid::CT_RESOURCE_TAGGED_ATTESTATION.skip_if(cons)?;
+                        cons.take_constructed_if(
+                            Tag::CTX_0,
+                            OctetString::take_from
+                        )
+                    })?;
+                    let certificates = CertificateSet::take_if(
+                        Tag::CTX_0, cons
+                    )?;
+                    let crls = CrlSet::take_opt_if(Tag::CTX_1, cons)?;
+                    let signer_infos = SignerInfoSet::take_from(cons)?;
+
+                    Ok(MultiSignedObject {
+                        digest_algorithm,
+                        content,
+                        certificates,
+                        crls,
+                        signer_infos,
+                    })
+                })
+            })
+        })
+    }
+
+    pub fn validate<F: FnMut(Cert) -> Result<ResourceCert, ValidationError>>(
+        self, _strict: bool, _validate_cert: F
+    ) -> Result<ResourceTaggedAttestation, ValidationError> {
+        unimplemented!()
+    }
+
+    /// Returns a value encoder for a reference to a signed object.
+    pub fn encode_ref<'a>(&'a self) -> impl encode::Values + 'a {
+        encode::sequence((
+            oid::SIGNED_DATA.encode(), // contentType
+            encode::sequence_as(Tag::CTX_0, // content
+                encode::sequence((
+                    3u8.encode(), // version
+                    self.digest_algorithm.encode_set(), // digestAlgorithms
+                    encode::sequence(( // encapContentInfo
+                        oid::CT_RESOURCE_TAGGED_ATTESTATION.encode(),
+                        encode::sequence_as(Tag::CTX_0,
+                            self.content.encode_ref()
+                        ),
+                    )),
+                    encode::sequence_as(Tag::CTX_0, // certificates
+                        self.certificates.encode_ref(),
+                    ),
+                    self.crls.encode_ref_as(Tag::CTX_1),
+                    encode::sequence(self.signer_infos.encode_ref()),
+                )),
+            )
+        ))
+    }
+}
+
+
+//------------ CertificateSet ------------------------------------------------
+
+// The captured content is the content of the set. We only support a
+// certificate choice of a certificate.
+#[derive(Clone, Debug)]
+pub struct CertificateSet(Captured);
+
+impl From<Vec<Cert>> for CertificateSet {
+    fn from(src: Vec<Cert>) -> CertificateSet {
+        CertificateSet(Captured::from_values(
+            Mode::Der,
+            encode::iter(src.iter().map(|item| item.encode_ref()))
+        ))
+    }
+}
+
+impl CertificateSet {
+    pub fn collect_certs(self) -> Vec<Cert> {
+        self.0.decode(|cons| {
+            let mut res = Vec::new();
+            while let Some(cert) = Cert::take_opt_from(cons)? {
+                res.push(cert)
+            }
+            Ok(res)
+        }).unwrap()
+    }
+}
+
+impl CertificateSet {
+    pub fn take_if<S: decode::Source>(
+        tag: Tag, cons: &mut decode::Constructed<S>
+    ) -> Result<Self, S::Err> {
+        cons.take_constructed_if(tag, |cons| {
+            cons.capture(|cons| {
+                while Cert::take_opt_from(cons)?.is_some() { }
+                Ok(())
+            })
+        }).map(CertificateSet)
+    }
+
+    /// Returns a value encoder for a reference to a signed object.
+    pub fn encode_ref<'a>(&'a self) -> impl encode::Values + 'a {
+        &self.0
+    }
+}
+
+
+//------------ CrlSet --------------------------------------------------------
+
+// The captured content is the content of the set. We only support a
+// choice of a CRL.
+#[derive(Clone, Debug)]
+pub struct CrlSet(Captured);
+
+impl From<Vec<Crl>> for CrlSet {
+    fn from(src: Vec<Crl>) -> CrlSet {
+        CrlSet(Captured::from_values(
+            Mode::Der,
+            encode::iter(src.iter().map(|item| item.encode_ref()))
+        ))
+    }
+}
+
+impl CrlSet {
+    pub fn collect_crls(self) -> Vec<Crl> {
+        self.0.decode(|cons| {
+            let mut res = Vec::new();
+            while let Some(crl) = Crl::take_opt_from(cons)? {
+                res.push(crl)
+            }
+            Ok(res)
+        }).unwrap()
+    }
+}
+
+impl CrlSet {
+    pub fn take_opt_if<S: decode::Source>(
+        tag: Tag, cons: &mut decode::Constructed<S>
+    ) -> Result<Self, S::Err> {
+        let res = cons.take_opt_constructed_if(tag, |cons| {
+            cons.capture(|cons| {
+                while Crl::take_opt_from(cons)?.is_some() { }
+                Ok(())
+            })
+        })?;
+        Ok(CrlSet(res.unwrap_or_else(|| Captured::empty(Mode::Der))))
+    }
+
+
+    /// Returns a value encoder for a reference to a signed object.
+    pub fn encode_ref_as<'a>(&'a self, tag: Tag) -> impl encode::Values + 'a {
+        match self.0.is_empty() {
+            true => None,
+            false => {
+                Some(encode::sequence_as(tag, &self.0))
+            }
+        }
+    }
+}
+
+
+//------------ SignerInfoSet -------------------------------------------------
+
+#[derive(Clone, Debug)]
+pub struct SignerInfoSet(Captured);
+
+impl From<Vec<SignerInfo>> for SignerInfoSet {
+    fn from(src: Vec<SignerInfo>) -> SignerInfoSet {
+        SignerInfoSet(Captured::from_values(
+            Mode::Der,
+            encode::iter(src.iter().map(|item| item.encode_ref()))
+        ))
+    }
+}
+
+impl SignerInfoSet {
+    pub fn collect_signer_infos(
+        self,
+    ) -> Vec<SignerInfo> {
+        self.0.decode(|cons| {
+            let mut res = Vec::new();
+            while let Some(crl) = SignerInfo::take_opt_from(
+                cons
+            )? {
+                res.push(crl)
+            }
+            Ok(res)
+        }).unwrap()
+    }
+}
+
+impl SignerInfoSet {
+    pub fn take_from<S: decode::Source>(
+        cons: &mut decode::Constructed<S>
+    ) -> Result<Self, S::Err> {
+        cons.take_set(|cons| {
+            cons.capture(|cons| {
+                while SignerInfo::take_opt_from(cons)?.is_some() { }
+                Ok(())
+            })
+        }).map(SignerInfoSet)
+    }
+
+    /// Returns a value encoder for a reference to a signed object.
+    pub fn encode_ref<'a>( &'a self) -> impl encode::Values + 'a {
+        &self.0
+    } 
+}
+
+
+//------------ SignerInfo ----------------------------------------------------
+
+/// A single SignerInfo of a signed object.
+#[derive(Clone, Debug)]
+pub struct SignerInfo {
+    sid: KeyIdentifier,
+    digest_algorithm: DigestAlgorithm,
+    signed_attrs: SignedAttrs,
+    signature: Signature,
+
+    //--- SignedAttributes
+    //
+    message_digest: MessageDigest,
+    signing_time: Option<Time>,
+    binary_signing_time: Option<u64>,
+}
+
+impl SignerInfo {
+    pub fn take_opt_from<S: decode::Source>(
+        cons: &mut decode::Constructed<S>,
+    ) -> Result<Option<Self>, S::Err> {
+        cons.take_opt_sequence(|cons| {
+            cons.skip_u8_if(3)?;
+            let sid = cons.take_value_if(
+                Tag::CTX_0, |content| {
+                    KeyIdentifier::from_content(content)
+                }
+            )?;
+            let alg = DigestAlgorithm::take_from(cons)?;
+            let attrs = SignedAttrs::take_from(cons)?;
+            if attrs.2 != oid::CT_RESOURCE_TAGGED_ATTESTATION {
+                return Err(decode::Malformed.into())
+            }
+            let signature = Signature::new(
+                SignatureAlgorithm::cms_take_from(cons)?,
+                OctetString::take_from(cons)?.into_bytes()
+            );
+            // no unsignedAttributes
+            Ok(SignerInfo {
+                sid,
+                digest_algorithm: alg,
+                signed_attrs: attrs.0,
+                signature,
+                message_digest: attrs.1,
+                signing_time: attrs.3,
+                binary_signing_time: attrs.4
+            })
+        })
+    }
+
+    pub fn encode_ref<'a>( &'a self) -> impl encode::Values + 'a {
+        encode::sequence((
+            self.sid.encode_ref_as(Tag::CTX_0),
+            self.digest_algorithm.encode(), // digestAlgorithm
+            self.signed_attrs.encode_ref(), // signedAttrs
+            self.signature.algorithm().cms_encode(),
+                                        // signatureAlgorithm
+            OctetString::encode_slice( // signature
+                self.signature.value().as_ref()
+            ),
+            // unsignedAttrs omitted
+        ))
+    }
+}
+
+
+//------------ AttestationBuilder --------------------------------------------
+
+pub struct AttestationBuilder {
+    keys: Vec<KeyIdentifier>,
+    as_resources: AsBlocksBuilder,
+    v4_resources: IpBlocksBuilder,
+    v6_resources: IpBlocksBuilder,
+    digest_algorithm: DigestAlgorithm,
+    message_digest: MessageDigest,
+}
+
+impl AttestationBuilder {
+    pub fn new(
+        digest_algorithm: DigestAlgorithm,
+        message_digest: MessageDigest
+    ) -> Self {
+        AttestationBuilder {
+            keys: Vec::new(),
+            as_resources: AsBlocksBuilder::new(),
+            v4_resources: IpBlocksBuilder::new(),
+            v6_resources: IpBlocksBuilder::new(),
+            digest_algorithm, message_digest
+        }
+    }
+
+    pub fn keys(&self) -> &[KeyIdentifier] {
+        &self.keys
+    }
+
+    pub fn keys_mut(&mut self) -> &Vec<KeyIdentifier> {
+        &mut self.keys
+    }
+
+    pub fn push_as(&mut self, block: impl Into<AsBlock>) {
+        self.as_resources.push(block)
+    }
+
+    pub fn as_resources(&self) -> &AsBlocksBuilder {
+        &self.as_resources
+    }
+
+    pub fn as_resources_mut(&mut self) -> &mut AsBlocksBuilder {
+        &mut self.as_resources
+    }
+
+    pub fn push_v4(&mut self, block: impl Into<IpBlock>) {
+        self.v4_resources.push(block)
+    }
+
+    pub fn v4_resources(&self) -> &IpBlocksBuilder {
+        &self.v4_resources
+    }
+
+    pub fn v4_resources_mut(&mut self) ->&mut IpBlocksBuilder {
+        &mut self.v4_resources
+    }
+
+    pub fn push_v6(&mut self, block: impl Into<IpBlock>) {
+        self.v6_resources.push(block)
+    }
+
+    pub fn v6_resources(&self) -> &IpBlocksBuilder {
+        &self.v6_resources
+    }
+
+    pub fn v6_resources_mut(&mut self) -> &mut IpBlocksBuilder {
+        &mut self.v6_resources
+    }
+
+    pub fn into_attestation(self) -> ResourceTaggedAttestation {
+        ResourceTaggedAttestation {
+            subject_keys: self.keys.into(),
+            as_resources: self.as_resources.into(),
+            v4_resources: self.v4_resources.into(),
+            v6_resources: self.v6_resources.into(),
+            digest_algorithm: self.digest_algorithm,
+            message_digest: self.message_digest,
+        }
+    }
+
+    pub fn into_rta_builder(self) -> RtaBuilder {
+        RtaBuilder::from_attestation(self.into_attestation())
+    }
+}
+
+
+//------------ RtaBuilder ----------------------------------------------------
+
+pub struct RtaBuilder {
+    digest_algorithm: DigestAlgorithm,
+    encoded_content: Bytes,
+    content: ResourceTaggedAttestation,
+    certificates: Vec<Cert>,
+    crls: Vec<Crl>,
+    signer_infos: Vec<SignerInfo>,
+}
+
+impl RtaBuilder {
+    pub fn from_attestation(content: ResourceTaggedAttestation) -> Self {
+        RtaBuilder {
+            digest_algorithm: DigestAlgorithm::default(),
+            encoded_content: content.to_bytes(),
+            content,
+            certificates: Vec::new(),
+            crls: Vec::new(),
+            signer_infos: Vec::new()
+        }
+    }
+
+    pub fn from_rta(rta: Rta) -> Self {
+        RtaBuilder {
+            digest_algorithm: DigestAlgorithm::default(),
+            encoded_content: rta.signed.content.to_bytes(),
+            content: rta.content,
+            certificates: rta.signed.certificates.collect_certs(),
+            crls: rta.signed.crls.collect_crls(),
+            signer_infos: rta.signed.signer_infos.collect_signer_infos(),
+        }
+    }
+
+    pub fn content(&self) -> &ResourceTaggedAttestation {
+        &self.content
+    }
+
+    pub fn push_cert(&mut self, cert: Cert) {
+        self.certificates.push(cert)
+    }
+
+    pub fn certificates(&self) -> &[Cert] {
+        &self.certificates
+    }
+
+    pub fn certificates_mut(&mut self) -> &Vec<Cert> {
+        &mut self.certificates
+    }
+
+    pub fn push_crl(&mut self, crl: Crl) {
+        self.crls.push(crl)
+    }
+
+    pub fn crls(&self) -> &[Crl] {
+        &self.crls
+    }
+
+    pub fn crls_mut(&mut self) -> &mut Vec<Crl> {
+        &mut self.crls
+    }
+
+    pub fn sign<S: Signer>(
+        &mut self,
+        signer: &S,
+        key: &S::KeyId,
+        signing_time: Option<Time>,
+        binary_signing_time: Option<u64>,
+    ) -> Result<(), SigningError<S::Error>> {
+        // Produce the content digest
+        let message_digest = self.digest_algorithm.digest(
+            &self.encoded_content
+        ).into();
+
+        // Produce signed attributes.
+        let signed_attrs = SignedAttrs::new(
+            &oid::CT_RESOURCE_TAGGED_ATTESTATION,
+            &message_digest,
+            signing_time,
+            binary_signing_time
+        );
+
+        // Sign those attributes
+        let signature = signer.sign(
+            key, SignatureAlgorithm::default(),
+            &signed_attrs.encode_verify()
+        )?;
+
+        self.signer_infos.push(SignerInfo {
+            sid: KeyIdentifier::from_public_key(&signer.get_key_info(key)?),
+            digest_algorithm: self.digest_algorithm,
+            signed_attrs,
+            signature,
+            message_digest,
+            signing_time,
+            binary_signing_time
+        });
+        Ok(())
+    }
+
+    pub fn signer_infos(&self) -> &[SignerInfo] {
+        &self.signer_infos
+    }
+
+    pub fn signer_infos_mut(&mut self) -> &mut Vec<SignerInfo> {
+        &mut self.signer_infos
+    }
+
+    pub fn finalize(self) -> Rta {
+        Rta {
+            signed: MultiSignedObject {
+                digest_algorithm: self.digest_algorithm,
+                content: OctetString::new(self.encoded_content),
+                certificates: self.certificates.into(),
+                crls: self.crls.into(),
+                signer_infos: self.signer_infos.into(),
+            },
+            content: self.content,
+        }
+    }
+}
+
diff --git a/src/sigobj.rs b/src/sigobj.rs
index 66d67fdb..d2c94477 100644
--- a/src/sigobj.rs
+++ b/src/sigobj.rs
@@ -1,4 +1,6 @@
-// Signed objects.
+//! Signed objects.
+//
+// See RFC 6488 and RFC 5652.
 
 use std::{cmp, io};
 use bcder::{decode, encode};
@@ -279,8 +281,8 @@ impl SignedObject {
 pub struct SignedAttrs(Captured);
 
 impl SignedAttrs {
-    fn new(
-        content_type: &Oid<Bytes>,
+    pub(crate) fn new(
+        content_type: &Oid<impl AsRef<[u8]>>,
         digest: &MessageDigest,
         signing_time: Option<Time>,
         binary_signing_time: Option<u64>,
@@ -537,11 +539,17 @@ impl AsRef<[u8]> for SignedAttrs {
 pub struct MessageDigest(Bytes);
 
 impl MessageDigest {
-    fn encode_ref<'a>(&'a self) -> impl encode::Values + 'a {
+    pub fn encode_ref<'a>(&'a self) -> impl encode::Values + 'a {
         OctetString::encode_slice(self.0.as_ref())
     }
 }
 
+impl From<OctetString> for MessageDigest {
+    fn from(src: OctetString) -> Self {
+        MessageDigest(src.into_bytes())
+    }
+}
+
 impl From<Digest> for MessageDigest {
     fn from(digest: Digest) -> Self {
         MessageDigest(Bytes::copy_from_slice(digest.as_ref()))
@@ -866,14 +874,11 @@ impl SignedObjectBuilder {
             binary_signing_time: self.binary_signing_time,
         })
     }
-
-
 }
 
 
 //------------ StartOfValue --------------------------------------------------
 
-
 /// Helper type for ordering signed attributes.
 ///
 /// It keeps the first eight octets of a value which should be enough to

From f38a948dbe68323170bf06295e49396de0fd6217 Mon Sep 17 00:00:00 2001
From: Martin Hoffmann <martin@nlnetlabs.nl>
Date: Tue, 14 Jul 2020 16:12:44 +0200
Subject: [PATCH 02/19] Return mut keys in keys_mut.

---
 src/rta.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/rta.rs b/src/rta.rs
index df633505..19ae04f4 100644
--- a/src/rta.rs
+++ b/src/rta.rs
@@ -671,7 +671,7 @@ impl AttestationBuilder {
         &self.keys
     }
 
-    pub fn keys_mut(&mut self) -> &Vec<KeyIdentifier> {
+    pub fn keys_mut(&mut self) -> &mut Vec<KeyIdentifier> {
         &mut self.keys
     }
 

From f7970841de28e02ef501fbbcc23dd31d5d3a49bc Mon Sep 17 00:00:00 2001
From: Martin Hoffmann <martin@nlnetlabs.nl>
Date: Tue, 14 Jul 2020 16:16:16 +0200
Subject: [PATCH 03/19] More muts.

---
 src/rta.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/rta.rs b/src/rta.rs
index 19ae04f4..6fa28a57 100644
--- a/src/rta.rs
+++ b/src/rta.rs
@@ -517,11 +517,11 @@ impl CrlSet {
 
     /// Returns a value encoder for a reference to a signed object.
     pub fn encode_ref_as<'a>(&'a self, tag: Tag) -> impl encode::Values + 'a {
-        match self.0.is_empty() {
-            true => None,
-            false => {
-                Some(encode::sequence_as(tag, &self.0))
-            }
+        if self.0.is_empty() {
+            None
+        }
+        else {
+            Some(encode::sequence_as(tag, &self.0))
         }
     }
 }
@@ -774,7 +774,7 @@ impl RtaBuilder {
         &self.certificates
     }
 
-    pub fn certificates_mut(&mut self) -> &Vec<Cert> {
+    pub fn certificates_mut(&mut self) -> &mut Vec<Cert> {
         &mut self.certificates
     }
 

From 58f01df0123180659fa97e2dbfa2168b6b52168d Mon Sep 17 00:00:00 2001
From: Martin Hoffmann <martin@nlnetlabs.nl>
Date: Tue, 14 Jul 2020 16:19:30 +0200
Subject: [PATCH 04/19] Add AttestationBuilder::push_key.

---
 src/rta.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/rta.rs b/src/rta.rs
index 6fa28a57..2c6ae620 100644
--- a/src/rta.rs
+++ b/src/rta.rs
@@ -667,6 +667,10 @@ impl AttestationBuilder {
         }
     }
 
+    pub fn push_key(&mut self, key: KeyIdentifier) {
+        self.keys.push(key)
+    }
+
     pub fn keys(&self) -> &[KeyIdentifier] {
         &self.keys
     }

From b991d7de5ab8c541d4c63178d1f96d940b334a64 Mon Sep 17 00:00:00 2001
From: Martin Hoffmann <martin@nlnetlabs.nl>
Date: Tue, 21 Jul 2020 14:26:20 +0200
Subject: [PATCH 05/19] Allow digesting complete files.

---
 Changelog.md         |  4 ++++
 src/crypto/digest.rs | 20 ++++++++++++++++++++
 2 files changed, 24 insertions(+)

diff --git a/Changelog.md b/Changelog.md
index c929509f..c98f39d6 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -8,6 +8,10 @@ Bug Fixes
 
 New
 
+* Module `rta` for handling Resource Tagged Assertions.
+* `crypto::DigestAlgorithm::digest_file` allows calculating the digest
+  value of an entire file.
+
 Dependencies
 
 
diff --git a/src/crypto/digest.rs b/src/crypto/digest.rs
index d6077956..0c93b00f 100644
--- a/src/crypto/digest.rs
+++ b/src/crypto/digest.rs
@@ -1,6 +1,9 @@
 //! Digest algorithm and operations.
 
 use std::io;
+use std::io::Read;
+use std::fs::File;
+use std::path::Path;
 use ring::digest;
 use bcder::{decode, encode};
 use bcder::encode::PrimitiveContent;
@@ -33,6 +36,23 @@ impl DigestAlgorithm {
         digest::digest(&digest::SHA256, data)
     }
 
+    /// Calculates the digest for the content of a file.
+    pub fn digest_file(
+        self, path: impl AsRef<Path>
+    ) -> Result<Digest, io::Error> {
+        let mut file = File::open(path)?;
+        let mut buf = [0u8; 8 * 1024];
+        let mut ctx = self.start();
+        loop {
+            let read = file.read(&mut buf)?;
+            if read == 0 {
+                break;
+            }
+            ctx.update(&buf[..read]);
+        }
+        Ok(ctx.finish())
+    }
+
     /// Returns a digest context for multi-step calculation of the digest.
     pub fn start(self) -> Context {
         Context(digest::Context::new(&digest::SHA256))

From 0019de9482b1782c0b0269bceaa12410ea09d3a3 Mon Sep 17 00:00:00 2001
From: Martin Hoffmann <martin@nlnetlabs.nl>
Date: Tue, 21 Jul 2020 14:33:16 +0200
Subject: [PATCH 06/19] Clippy ho\!

---
 src/crypto/keys.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/crypto/keys.rs b/src/crypto/keys.rs
index 3ef0bb96..d8b1516a 100644
--- a/src/crypto/keys.rs
+++ b/src/crypto/keys.rs
@@ -303,12 +303,10 @@ impl FromStr for KeyIdentifier {
             return Err(RepresentationError)
         }
         let mut res = KeyIdentifier(Default::default());
-        let mut pos = 0;
-        for ch in value.as_bytes().chunks(2) {
+        for (pos, ch) in value.as_bytes().chunks(2).enumerate() {
             let ch = unsafe { str::from_utf8_unchecked(ch) };
             res.0[pos] = u8::from_str_radix(ch, 16)
                             .map_err(|_| RepresentationError)?;
-            pos += 1;
         }
         Ok(res)
     }

From 0d75cab8a1695de276f1dfa3ab33aa52439400a0 Mon Sep 17 00:00:00 2001
From: Martin Hoffmann <martin@nlnetlabs.nl>
Date: Tue, 21 Jul 2020 14:52:17 +0200
Subject: [PATCH 07/19] Provide access to RTA content.

---
 src/rta.rs | 54 ++++++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 48 insertions(+), 6 deletions(-)

diff --git a/src/rta.rs b/src/rta.rs
index 2c6ae620..663e9c48 100644
--- a/src/rta.rs
+++ b/src/rta.rs
@@ -6,6 +6,7 @@
 //!
 //! draft-michaelson-rpki-rta: https://tools.ietf.org/html/draft-michaelson-rpki-rta
 
+use std::ops;
 use bcder::{decode, encode};
 use bcder::{Captured, Mode, OctetString, Tag};
 use bcder::encode::{PrimitiveContent, Values};
@@ -35,6 +36,10 @@ pub struct Rta {
 }
 
 impl Rta {
+    pub fn content(&self) -> &ResourceTaggedAttestation {
+        &self.content
+    }
+
     pub fn decode<S: decode::Source>(
         source: S,
         strict: bool
@@ -46,12 +51,6 @@ impl Rta {
         Ok(Rta { signed, content })
     }
 
-    pub fn validate<F: FnMut(Cert) -> Result<ResourceCert, ValidationError>>(
-        self, _strict: bool, _validate_cert: F
-    ) -> Result<ResourceTaggedAttestation, ValidationError> {
-        unimplemented!()
-    }
-
     /// Returns a value encoder for a reference to a ROA.
     pub fn encode_ref<'a>(&'a self) -> impl encode::Values + 'a {
         self.signed.encode_ref()
@@ -64,6 +63,23 @@ impl Rta {
 }
 
 
+//--- Deref and AsRef
+
+impl ops::Deref for Rta {
+    type Target = ResourceTaggedAttestation;
+
+    fn deref(&self) -> &Self::Target {
+        self.content()
+    }
+}
+
+impl AsRef<ResourceTaggedAttestation> for Rta {
+    fn as_ref(&self) -> &ResourceTaggedAttestation {
+        self.content()
+    }
+}
+
+
 //------------ ResourceTaggedAttestation -------------------------------------
 
 #[derive(Clone, Debug)]
@@ -84,6 +100,32 @@ pub struct ResourceTaggedAttestation {
     message_digest: MessageDigest,
 }
 
+impl ResourceTaggedAttestation {
+    pub fn subject_keys(&self) -> &SubjectKeySet {
+        &self.subject_keys
+    }
+
+    pub fn as_resources(&self) -> &RtaAsBlocks {
+        &self.as_resources
+    }
+
+    pub fn v4_resources(&self) -> &RtaIpBlocks {
+        &self.v4_resources
+    }
+
+    pub fn v6_resources(&self) -> &RtaIpBlocks {
+        &self.v6_resources
+    }
+
+    pub fn digest_algorithm(&self) -> DigestAlgorithm {
+        self.digest_algorithm
+    }
+
+    pub fn message_digest(&self) -> &MessageDigest {
+        &self.message_digest
+    }
+}
+
 impl ResourceTaggedAttestation {
     fn take_from<S: decode::Source>(
         cons: &mut decode::Constructed<S>

From 3c6db4522536483e11a72948e356e27e2f1e06bb Mon Sep 17 00:00:00 2001
From: Martin Hoffmann <martin@nlnetlabs.nl>
Date: Wed, 12 Aug 2020 15:33:38 +0200
Subject: [PATCH 08/19] Infrastructure for validating RTAs.

---
 src/cert/builder.rs     |   35 +-
 src/cert/mod.rs         |  393 +++++++++------
 src/crypto/keys.rs      |   19 +-
 src/resources/asres.rs  |  179 +++++--
 src/resources/choice.rs |   68 +--
 src/resources/ipres.rs  |  202 ++++++--
 src/resources/mod.rs    |    1 +
 src/roa.rs              |   14 +-
 src/rta.rs              | 1064 ++++++++++++++++++++++++++-------------
 src/sigobj.rs           |   38 +-
 10 files changed, 1331 insertions(+), 682 deletions(-)

diff --git a/src/cert/builder.rs b/src/cert/builder.rs
index 86f23d18..9c2dda8a 100644
--- a/src/cert/builder.rs
+++ b/src/cert/builder.rs
@@ -10,7 +10,7 @@ use crate::resources::{
 };
 use crate::uri;
 use crate::x509::Name;
-use super::Validity;
+use super::{Overclaim, Validity};
 
 
 #[derive(Clone, Debug)]
@@ -138,10 +138,10 @@ pub struct CertBuilder {
     /// Subject Information Access of type `id-ad-rpkiNotify`
     rpki_notify: Option<uri::Https>,
 
-    //  Certificate Policies
-    //
-    //  This contains a single policy, id-cp-ipAddr-asNumber, without any
-    //  qualifiers.
+    /// Certificate Policies
+    ///
+    /// This is chosen via the value of the overclaim mode,
+    overclaim: Overclaim,
 
     /// IPv4 Resources
     ///
@@ -182,6 +182,7 @@ impl CertBuilder {
             rpki_manifest: None,
             signed_object: None,
             rpki_notify: None,
+            overclaim: Overclaim::Refuse,
             v4_resources: IpResourcesBuilder::new(),
             v6_resources: IpResourcesBuilder::new(),
             as_resources: AsResourcesBuilder::new(),
@@ -230,6 +231,11 @@ impl CertBuilder {
         self
     }
 
+    pub fn overclaim(&mut self, overclaim: Overclaim) -> &mut Self {
+        self.overclaim = overclaim;
+        self
+    }
+
     pub fn inherit_v4(&mut self) -> &mut Self {
         self.v4_resources.inherit();
         self
@@ -241,7 +247,7 @@ impl CertBuilder {
     }
 
     pub fn inherit_as(&mut self) -> &mut Self {
-        self.as_resources.inhert();
+        self.as_resources.inherit();
         self
     }
 
@@ -418,17 +424,16 @@ impl CertBuilder {
                 ),
 
                 // IP Resources
-                IpResources::encode_families(
-                    self.v4_resources.finalize(),
-                    self.v6_resources.finalize()
-                ).map(|res| {
-                    extension(&oid::PE_IP_ADDR_BLOCK, true, res)
-                }),
+                IpResources::encode_extension(
+                    self.overclaim,
+                    &self.v4_resources.finalize(),
+                    &self.v6_resources.finalize()
+                ),
 
                 // AS Resources
-                self.as_resources.finalize().map(|res| {
-                    extension(&oid::PE_AUTONOMOUS_SYS_IDS, true, res.encode())
-                })
+                self.as_resources.finalize().encode_extension(
+                    self.overclaim
+                ),
             )))
         )))
     }
diff --git a/src/cert/mod.rs b/src/cert/mod.rs
index 3ca9688e..18e5d658 100644
--- a/src/cert/mod.rs
+++ b/src/cert/mod.rs
@@ -46,7 +46,7 @@ use crate::crypto::{
     KeyIdentifier, PublicKey, SignatureAlgorithm, Signer, SigningError
 };
 use crate::resources::{
-    AddressFamily, AsBlock, AsBlocksBuilder, AsResources, AsResourcesBuilder,
+    AsBlock, AsBlocksBuilder, AsResources, AsResourcesBuilder,
     IpBlock, IpBlocksBuilder, IpResources, IpResourcesBuilder
 };
 
@@ -148,7 +148,31 @@ impl Cert {
 
 /// # Validation
 ///
+/// When validating a certificate, two properties are checked: whether the
+/// certificate’s structure and content comply with the specification for
+/// resource certificates laid out in [RFC 6487] and whether the certificate
+/// has been correctly issued by its CA.
+///
+/// In some cases it is useful to perform these two steps separatedly.
+/// Therefore, methods are available both for each step and for doing both
+/// steps at once. Since we need to name these consistently, we devised the
+/// following convention:
+///
+/// The first step that validates compliance with the specification is called
+/// _inspection._ Methods are available to inspect different kinds of
+/// certificates. They all have the verb _inspect_ in their name. Only the
+/// certificate itself is necessary to perform inspection.
+///
+/// The second step checking whether the certificate was correctly issued is
+/// called _verification._ Methods are available to verify different kinds of
+/// certificates. They all have the verb _verify_ in their name and, in
+/// most cases, require access to the issuer certificate.
+/// 
+/// In addition, methods are available to perform both steps at once for
+/// different kinds of certificates. These all have _validate_ in their name.
 impl Cert {
+    //--- Validation
+
     /// Validates the certificate as a trust anchor.
     ///
     /// This validates that the certificate “is a current, self-signed RPKI
@@ -168,53 +192,8 @@ impl Cert {
         strict: bool,
         now: Time,
     ) -> Result<ResourceCert, ValidationError> {
-        self.validate_basics(strict, now)?;
-        self.validate_ca_basics(strict)?;
-
-        // 4.8.3. Authority Key Identifier. May be present, if so, must be
-        // equal to the subject key indentifier.
-        if let Some(ref aki) = self.authority_key_identifier {
-            if *aki != self.subject_key_identifier {
-                return Err(ValidationError);
-            }
-        }
-
-        // 4.8.6. CRL Distribution Points. There musn’t be one.
-        if self.crl_uri.is_some() {
-            return Err(ValidationError)
-        }
-
-        // 4.8.7. Authority Information Access. Must not be present.
-        if self.ca_issuer.is_some() {
-            return Err(ValidationError)
-        }
-
-        // 4.8.10. IP Resources. If present, musn’t be "inherit".
-        let v4_resources = IpBlocks::from_resources(
-            self.v4_resources.as_ref()
-        )?;
-        let v6_resources = IpBlocks::from_resources(
-            self.v6_resources.as_ref()
-        )?;
- 
-        // 4.8.11.  AS Resources. If present, musn’t be "inherit". That
-        // IP resources (logical) or AS resources are present has already
-        // been checked during parsing.
-        let as_resources = AsBlocks::from_resources(
-            self.as_resources.as_ref()
-        )?;
-
-        self.signed_data.verify_signature(
-            &self.subject_public_key_info
-        )?;
-
-        Ok(ResourceCert {
-            cert: self,
-            v4_resources,
-            v6_resources,
-            as_resources,
-            tal
-        })
+        self.inspect_ta_at(strict, now)?;
+        self.verify_ta(tal, strict)
     }
 
     /// Validates the certificate as a CA certificate.
@@ -237,11 +216,8 @@ impl Cert {
         strict: bool,
         now: Time,
     ) -> Result<ResourceCert, ValidationError> {
-        self.validate_basics(strict, now)?;
-        self.validate_ca_basics(strict)?;
-        self.validate_issued(issuer, strict)?;
-        self.validate_signature(issuer, strict)?;
-        self.validate_resources(issuer, strict)
+        self.inspect_ca_at(strict, now)?;
+        self.verify_ca(issuer, strict)
     }
 
     /// Validates the certificate as an EE certificate.
@@ -264,8 +240,72 @@ impl Cert {
         strict: bool,
         now: Time,
     ) -> Result<ResourceCert, ValidationError>  {
-        self.validate_basics(strict, now)?;
-        self.validate_issued(issuer, strict)?;
+        self.inspect_ee_at(strict, now)?;
+        self.verify_ee(issuer, strict)
+    }
+
+
+    //--- Inspection
+
+    pub fn inspect_ta(&self, strict: bool) -> Result<(), ValidationError> {
+        self.inspect_ta_at(strict, Time::now())
+    }
+
+    pub fn inspect_ta_at(
+        &self,
+        strict: bool,
+        now: Time
+    ) -> Result<(), ValidationError> {
+        self.inspect_basics(strict, now)?;
+        self.inspect_ca_basics(strict)?;
+
+        // 4.8.3. Authority Key Identifier. May be present, if so, must be
+        // equal to the subject key indentifier.
+        if let Some(ref aki) = self.authority_key_identifier {
+            if *aki != self.subject_key_identifier {
+                return Err(ValidationError);
+            }
+        }
+
+        // 4.8.6. CRL Distribution Points. There musn’t be one.
+        if self.crl_uri.is_some() {
+            return Err(ValidationError)
+        }
+
+        // 4.8.7. Authority Information Access. Must not be present.
+        if self.ca_issuer.is_some() {
+            return Err(ValidationError)
+        }
+
+        // 4.8.10. IP Resources.
+        // 4.8.11. AS Resources.
+        //
+        // Are checked as part of verification.
+        
+        Ok(())
+    }
+
+    pub fn inspect_ca(&self, strict: bool) -> Result<(), ValidationError> {
+        self.inspect_ca_at(strict, Time::now())
+    }
+
+    pub fn inspect_ca_at(
+        &self, strict: bool, now: Time
+    ) -> Result<(), ValidationError> {
+        self.inspect_basics(strict, now)?;
+        self.inspect_ca_basics(strict)?;
+        self.inspect_issued(strict)
+    }
+
+    pub fn inspect_ee(&self, strict: bool) -> Result<(), ValidationError> {
+        self.inspect_ee_at(strict, Time::now())
+    }
+
+    pub fn inspect_ee_at(
+        &self, strict: bool, now: Time
+    ) -> Result<(), ValidationError> {
+        self.inspect_basics(strict, now)?;
+        self.inspect_issued(strict)?;
 
         // 4.8.1. Basic Constraints: Must not be present.
         if self.basic_ca.is_some(){
@@ -285,19 +325,94 @@ impl Cert {
         {
             return Err(ValidationError)
         }
+
+        // XXX This is probably not correct?
         if self.rpki_notify.is_some() && strict {
             return Err(ValidationError)
         }
 
-        self.validate_signature(issuer, strict)?;
-        self.validate_resources(issuer, strict)
+        Ok(())
+    }
+
+
+    //--- Verification
+
+    pub fn verify_ta(
+        self, tal: Arc<TalInfo>, _strict: bool
+    ) -> Result<ResourceCert, ValidationError> {
+        // 4.8.10. IP Resources. If present, musn’t be "inherit".
+        let v4_resources = IpBlocks::from_resources(
+            self.v4_resources.clone()
+        )?;
+        let v6_resources = IpBlocks::from_resources(
+            self.v6_resources.clone()
+        )?;
+ 
+        // 4.8.11.  AS Resources. If present, musn’t be "inherit". That
+        // IP resources (logical) or AS resources are present has already
+        // been checked during parsing.
+        let as_resources = AsBlocks::from_resources(
+            self.as_resources.clone()
+        )?;
+
+        self.signed_data.verify_signature(
+            &self.subject_public_key_info
+        )?;
+
+        Ok(ResourceCert {
+            cert: self,
+            v4_resources,
+            v6_resources,
+            as_resources,
+            tal
+        })
+    }
+
+    pub fn verify_ta_ref(
+        &self, _strict: bool
+    ) -> Result<(), ValidationError> {
+        // 4.8.10. IP Resources. If present, musn’t be "inherit".
+        if self.v4_resources.is_inherited() {
+            return Err(ValidationError)
+        }
+        if self.v6_resources.is_inherited() {
+            return Err(ValidationError)
+        }
+
+        // 4.8.11.  AS Resources. If present, musn’t be "inherit".
+        if self.as_resources.is_inherited() {
+            return Err(ValidationError)
+        }
+
+        self.signed_data.verify_signature(
+            &self.subject_public_key_info
+        )?;
+
+        Ok(())
+    }
+
+
+    pub fn verify_ca(
+        self, issuer: &ResourceCert, strict: bool
+    ) -> Result<ResourceCert, ValidationError> {
+        self.verify_issuer_claim(issuer, strict)?;
+        self.verify_signature(issuer, strict)?;
+        self.verify_resources(issuer, strict)
+    }
+
+    pub fn verify_ee(
+        self, issuer: &ResourceCert, strict: bool
+    ) -> Result<ResourceCert, ValidationError> {
+        self.verify_issuer_claim(issuer, strict)?;
+        self.verify_signature(issuer, strict)?;
+        self.verify_resources(issuer, strict)
     }
 
 
     //--- Validation Components
 
-    /// Validates basic compliance with section 4 of RFC 6487.
-    fn validate_basics(
+    /// Inspects basic compliance with section 4 of RFC 6487.
+    fn inspect_basics(
         &self,
         strict: bool,
         now: Time
@@ -371,33 +486,12 @@ impl Cert {
         Ok(())
     }
 
-    /// Validates that the certificate is a correctly issued certificate.
-    fn validate_issued(
-        &self,
-        issuer: &ResourceCert,
-        _strict: bool,
-    ) -> Result<(), ValidationError> {
-        // 4.8.3. Authority Key Identifier. Must be present and match the
-        // subject key ID of `issuer`.
-        if self.authority_key_identifier()
-            != Some(issuer.cert.subject_key_identifier())
-        {
-            return Err(ValidationError)
-        }
-
+    fn inspect_issued(&self, _strict: bool) -> Result<(), ValidationError> {
         // 4.8.6. CRL Distribution Points. There must be one.
         if self.crl_uri().is_none() {
             return Err(ValidationError)
         }
 
-        // 4.8.7. Authority Information Access. Must be present and contain
-        // the URI of the issuer certificate. Since we do top-down validation,
-        // we don’t really need that URI so – XXX – leave it unchecked for
-        // now.
-        if self.ca_issuer().is_none() {
-            return Err(ValidationError);
-        }
-
         Ok(())
     }
 
@@ -405,7 +499,7 @@ impl Cert {
     ///
     /// Checks the parts that are common in normal and trust anchor CA
     /// certificates.
-    fn validate_ca_basics(
+    fn inspect_ca_basics(
         &self,
         _strict: bool
     ) -> Result<(), ValidationError> {
@@ -431,21 +525,49 @@ impl Cert {
         Ok(())
     }
 
-    /// Validates the certificate’s signature.
-    fn validate_signature(
+    /// Verifies that the certificate claims to have been issued by `issuer`.
+    ///
+    /// This is only the first part of verification. You _must_ call
+    /// `verified_signature`, too.
+    pub fn verify_issuer_claim(
         &self,
         issuer: &ResourceCert,
+        _strict: bool,
+    ) -> Result<(), ValidationError> {
+        // 4.8.3. Authority Key Identifier. Must be present and match the
+        // subject key ID of `issuer`.
+        if self.authority_key_identifier()
+            != Some(issuer.cert.subject_key_identifier())
+        {
+            return Err(ValidationError)
+        }
+
+        // 4.8.7. Authority Information Access. Must be present and contain
+        // the URI of the issuer certificate. Since we do top-down validation,
+        // we don’t really need that URI so – XXX – leave it unchecked for
+        // now.
+        if self.ca_issuer().is_none() {
+            return Err(ValidationError);
+        }
+
+        Ok(())
+    }
+
+    /// Validates the certificate’s signature.
+    pub fn verify_signature(
+        &self,
+        issuer: &Cert,
         _strict: bool
     ) -> Result<(), ValidationError> {
         self.signed_data.verify_signature(
-            issuer.cert.subject_public_key_info()
+            issuer.subject_public_key_info()
         )
     }
 
     /// Validates and extracts the IP and AS resources.
     ///
     /// Upon success, this converts the certificate into a `ResourceCert`.
-    fn validate_resources(
+    fn verify_resources(
         self,
         issuer: &ResourceCert,
         _strict: bool
@@ -604,13 +726,13 @@ pub struct TbsCert {
     overclaim: Overclaim,
 
     /// IP Resources for the IPv4 address family.
-    v4_resources: Option<IpResources>,
+    v4_resources: IpResources,
 
     /// IP Resources for the IPv6 address family.
-    v6_resources: Option<IpResources>,
+    v6_resources: IpResources,
 
     /// AS Resources
-    as_resources: Option<AsResources>,
+    as_resources: AsResources,
 }
 
 
@@ -653,9 +775,9 @@ impl TbsCert {
             signed_object: None,
             rpki_notify: None,
             overclaim,
-            v4_resources: None,
-            v6_resources: None,
-            as_resources: None,
+            v4_resources: IpResources::missing(),
+            v6_resources: IpResources::missing(),
+            as_resources: AsResources::missing(),
         }
     }
 
@@ -858,18 +980,18 @@ impl TbsCert {
     }
 
     /// Returns a reference to the IPv4 address resources if present.
-    pub fn v4_resources(&self) -> Option<&IpResources> {
-        self.v4_resources.as_ref()
+    pub fn v4_resources(&self) -> &IpResources {
+        &self.v4_resources
     }
 
     /// Set the IPv4 address resources.
-    pub fn set_v4_resources(&mut self, resources: Option<IpResources>) {
+    pub fn set_v4_resources(&mut self, resources: IpResources) {
         self.v4_resources = resources
     }
 
     /// Sets the IPv4 address resources to inherit.
     pub fn set_v4_resources_inherit(&mut self) {
-        self.set_v4_resources(Some(IpResources::inherit()))
+        self.set_v4_resources(IpResources::inherit())
     }
 
     /// Builds the blocks IPv4 address resources.
@@ -883,24 +1005,22 @@ impl TbsCert {
     /// Builds the IPv4 address resources from an iterator over blocks.
     pub fn v4_resources_from_iter<I>(&mut self, iter: I)
     where I: IntoIterator<Item=IpBlock> {
-        self.v4_resources = Some(
-            IpResources::blocks(IpBlocks::from_iter(iter))
-        )
+        self.v4_resources = IpResources::blocks(IpBlocks::from_iter(iter))
     }
 
     /// Returns a reference to the IPv6 address resources if present.
-    pub fn v6_resources(&self) -> Option<&IpResources> {
-        self.v6_resources.as_ref()
+    pub fn v6_resources(&self) -> &IpResources {
+        &self.v6_resources
     }
 
     /// Set the IPv6 address resources.
-    pub fn set_v6_resources(&mut self, resources: Option<IpResources>) {
+    pub fn set_v6_resources(&mut self, resources: IpResources) {
         self.v6_resources = resources
     }
 
     /// Sets the IPv6 address resources to inherit.
     pub fn set_v6_resources_inherit(&mut self) {
-        self.set_v6_resources(Some(IpResources::inherit()))
+        self.set_v6_resources(IpResources::inherit())
     }
 
     /// Builds the blocks IPv6 address resources.
@@ -914,29 +1034,27 @@ impl TbsCert {
     /// Builds the IPv6 address resources from an iterator over blocks
     pub fn v6_resources_from_iter<I>(&mut self, iter: I)
     where I: IntoIterator<Item=IpBlock> {
-        self.v6_resources = Some(
-            IpResources::blocks(IpBlocks::from_iter(iter))
-        )
+        self.v6_resources = IpResources::blocks(IpBlocks::from_iter(iter))
     }
 
     /// Returns whether the certificate has any IP resources at all.
     pub fn has_ip_resources(&self) -> bool {
-        self.v4_resources.is_some() || self.v6_resources().is_some()
+        self.v4_resources.is_present() || self.v6_resources().is_present()
     }
 
-    /// Returns a reference to the AS resources if present.
-    pub fn as_resources(&self) -> Option<&AsResources> {
-        self.as_resources.as_ref()
+    /// Returns a reference to the AS resources.
+    pub fn as_resources(&self) -> &AsResources {
+        &self.as_resources
     }
 
     /// Set the AS resources.
-    pub fn set_as_resources(&mut self, resources: Option<AsResources>) {
+    pub fn set_as_resources(&mut self, resources: AsResources) {
         self.as_resources = resources
     }
 
     /// Sets the AS resources to inherit.
     pub fn set_as_resources_inherit(&mut self) {
-        self.set_as_resources(Some(AsResources::inherit()))
+        self.set_as_resources(AsResources::inherit())
     }
 
     /// Builds the blocks AS resources.
@@ -950,9 +1068,7 @@ impl TbsCert {
     /// Builds the AS resources from an iterator over blocks.
     pub fn as_resources_from_iter<I>(&mut self, iter: I)
     where I: IntoIterator<Item = AsBlock> {
-        self.as_resources = Some(
-            AsResources::blocks(AsBlocks::from_iter(iter))
-        )
+        self.as_resources = AsResources::blocks(AsBlocks::from_iter(iter))
     }
 }
 
@@ -1099,9 +1215,15 @@ impl TbsCert {
                 signed_object,
                 rpki_notify,
                 overclaim: overclaim.ok_or(decode::Malformed)?,
-                v4_resources,
-                v6_resources,
-                as_resources,
+                v4_resources: v4_resources.unwrap_or_else(
+                    IpResources::missing
+                ),
+                v6_resources: v6_resources.unwrap_or_else(
+                    IpResources::missing
+                ),
+                as_resources: as_resources.unwrap_or_else(
+                    AsResources::missing
+                ),
             })
         })
     }
@@ -1566,37 +1688,14 @@ impl TbsCert {
                 ),
 
                 // IP Resources
-                if self.has_ip_resources() {
-                    Some(encode_extension(
-                        self.overclaim.ip_res_id(), true,
-                        encode::sequence((
-                            self.v4_resources.as_ref().map(|v4| {
-                                encode::sequence((
-                                    AddressFamily::Ipv4.encode(),
-                                    v4.encode_ref()
-                                ))
-                            }),
-                            self.v6_resources.as_ref().map(|v6| {
-                                encode::sequence((
-                                    AddressFamily::Ipv6.encode(),
-                                    v6.encode_ref()
-                                ))
-                            }),
-                        ))
-                    ))
-                }
-                else {
-                    None
-                },
+                IpResources::encode_extension(
+                    self.overclaim(),
+                    &self.v4_resources(),
+                    &self.v6_resources()
+                ),
 
                 // AS Resources
-                self.as_resources.as_ref().map(|res| {
-                    encode_extension(
-                        self.overclaim.as_res_id(), true,
-                        res.encode_ref()
-                    )
-                })
-
+                self.as_resources.encode_extension(self.overclaim)
             )))
         ))
     }
diff --git a/src/crypto/keys.rs b/src/crypto/keys.rs
index d8b1516a..9199781e 100644
--- a/src/crypto/keys.rs
+++ b/src/crypto/keys.rs
@@ -249,6 +249,12 @@ impl KeyIdentifier {
         cons.take_value_if(Tag::OCTET_STRING, Self::from_content)
     }
 
+    pub fn take_opt_from<S: decode::Source>(
+        cons: &mut decode::Constructed<S>
+    ) -> Result<Option<Self>, S::Err> {
+        cons.take_opt_value_if(Tag::OCTET_STRING, Self::from_content)
+    }
+
     /// Parses an encoded key identifer from a encoded content.
     pub fn from_content<S: decode::Source>(
         content: &mut decode::Content<S>
@@ -273,14 +279,13 @@ impl KeyIdentifier {
     }
 
     /// Skips over an encoded key indentifier.
-    pub fn skip_in<S: decode::Source>(
+    pub fn skip_opt_in<S: decode::Source>(
         cons: &mut decode::Constructed<S>
-    ) -> Result<(), S::Err> {
-        while cons.take_opt_value_if(
-            Tag::OCTET_STRING, OctetString::from_content
-        )?.is_some() {
-        }
-        Ok(())
+    ) -> Result<Option<()>, S::Err> {
+        cons.take_opt_value_if(Tag::OCTET_STRING, |cons| {
+            Self::from_content(cons)?;
+            Ok(())
+        })
     }
 }
 
diff --git a/src/resources/asres.rs b/src/resources/asres.rs
index 7cf16077..6fa99be2 100644
--- a/src/resources/asres.rs
+++ b/src/resources/asres.rs
@@ -19,11 +19,11 @@ use std::iter::FromIterator;
 use std::str::FromStr;
 use bcder::{decode, encode};
 use bcder::{Tag, xerr};
-use bcder::encode::PrimitiveContent;
+use bcder::encode::{PrimitiveContent, Nothing};
 use serde::de;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use crate::cert::Overclaim;
-use crate::x509::ValidationError;
+use crate::x509::{encode_extension, ValidationError};
 use super::chain::{Block, SharedChain};
 use super::choice::ResourcesChoice;
 
@@ -49,9 +49,22 @@ impl AsResources {
         AsResources(ResourcesChoice::Inherit)
     }
 
+    /// Creates a new AsResources with a ResourceChoice::Missing
+    pub fn missing() -> Self {
+        AsResources(ResourcesChoice::Missing)
+    }
+
     /// Creates a new AsResources for the given blocks.
+    ///
+    /// If the blocks are empty, creates a missing variant in accordance with
+    /// the specification.
     pub fn blocks(blocks: AsBlocks) -> Self {
-        AsResources(ResourcesChoice::Blocks(blocks))
+        if blocks.is_empty() {
+            AsResources::missing()
+        }
+        else {
+            AsResources(ResourcesChoice::Blocks(blocks))
+        }
     }
 
     /// Returns whether the resources are of the inherited variant.
@@ -59,9 +72,11 @@ impl AsResources {
         self.0.is_inherited()
     }
 
-    /// Returns a reference to the blocks if there are any.
-    pub fn as_blocks(&self) -> Option<&AsBlocks> {
-        self.0.as_blocks()
+    /// Returns whether the resources are empty.
+    ///
+    /// Inherited resources are not empty.
+    pub fn is_present(&self) -> bool {
+        self.0.is_present()
     }
 
     /// Converts the resources into blocks or returns an error.
@@ -133,13 +148,18 @@ impl AsResources {
             encode::sequence_as(Tag::CTX_0,
                 match self.0 {
                     ResourcesChoice::Inherit => {
-                        encode::Choice2::One(().encode())
+                        encode::Choice3::One(().encode())
                     }
                     ResourcesChoice::Blocks(blocks) => {
-                        encode::Choice2::Two(
+                        encode::Choice3::Two(
                             encode::sequence(blocks.encode())
                         )
                     }
+                    ResourcesChoice::Missing => {
+                        encode::Choice3::Three(
+                            encode::sequence(Nothing)
+                        )
+                    }
                 }
             )
         )
@@ -150,17 +170,36 @@ impl AsResources {
             encode::sequence_as(Tag::CTX_0,
                 match self.0 {
                     ResourcesChoice::Inherit => {
-                        encode::Choice2::One(().encode())
+                        encode::Choice3::One(().encode())
                     }
                     ResourcesChoice::Blocks(ref blocks) => {
-                        encode::Choice2::Two(
+                        encode::Choice3::Two(
                             encode::sequence(blocks.encode_ref())
                         )
                     }
+                    ResourcesChoice::Missing => {
+                        encode::Choice3::Three(
+                            encode::sequence(Nothing)
+                        )
+                    }
                 }
             )
         )
     }
+
+    pub fn encode_extension<'a>(
+        &'a self, overclaim: Overclaim
+    ) -> impl encode::Values + 'a {
+        if self.0.is_present() {
+            Some(encode_extension(
+                overclaim.as_res_id(), true, self.encode_ref()
+            ))
+        }
+        else {
+            None
+        }
+    }
+
 }
 
 //--- Display
@@ -177,8 +216,11 @@ impl FromStr for AsResources {
     type Err = FromStrError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let choice = ResourcesChoice::from_str(s).map_err(|_| FromStrError::BadBlocks)?;
-        Ok(AsResources(choice))
+        if s == "inherit" {
+            Ok(AsResources::inherit())
+        } else {
+            AsBlocks::from_str(s).map(AsResources::blocks)
+        }
     }
 }
 
@@ -187,32 +229,41 @@ impl FromStr for AsResources {
 
 #[derive(Clone, Debug)]
 pub struct AsResourcesBuilder {
-    res: Option<ResourcesChoice<AsBlocksBuilder>>
+    /// The resources.
+    ///
+    /// A value of `None` means inherited resources, an empty builder will be
+    /// transformed into missing resources.
+    res: Option<AsBlocksBuilder>
 }
 
 impl AsResourcesBuilder {
     pub fn new() -> Self {
         AsResourcesBuilder {
-            res: None
+            res: Some(AsBlocksBuilder::new())
         }
     }
 
-    pub fn inhert(&mut self) {
-        self.res = Some(ResourcesChoice::Inherit)
+    pub fn inherit(&mut self) {
+        self.res = None
     }
 
     pub fn blocks<F>(&mut self, build: F)
     where F: FnOnce(&mut AsBlocksBuilder) {
-        if self.res.as_ref().map(|res| res.is_inherited()).unwrap_or(true) {
-            self.res = Some(ResourcesChoice::Blocks(AsBlocksBuilder::new()))
+        if let Some(ref mut builder) = self.res {
+            build(builder)
+        }
+        else {
+            let mut builder = AsBlocksBuilder::new();
+            build(&mut builder);
+            self.res = Some(builder)
         }
-        build(self.res.as_mut().unwrap().as_blocks_mut().unwrap())
     }
 
-    pub fn finalize(self) -> Option<AsResources> {
-        self.res.map(|choice| {
-            AsResources(choice.map_blocks(AsBlocksBuilder::finalize))
-        })
+    pub fn finalize(self) -> AsResources {
+        match self.res {
+            Some(blocks) => AsResources::blocks(blocks.finalize()),
+            None => AsResources::inherit(),
+        }
     }
 }
 
@@ -240,12 +291,12 @@ impl AsBlocks {
     /// If the AS resources are of the inherited variant, a validation error
     /// is returned.
     pub fn from_resources(
-        res: Option<&AsResources>
+        res: AsResources
     ) -> Result<Self, ValidationError> {
-        match res.map(|res| &res.0) {
-            Some(ResourcesChoice::Inherit) => Err(ValidationError),
-            Some(ResourcesChoice::Blocks(ref some)) => Ok(some.clone()),
-            None => Ok(AsBlocks::empty())
+        match res.0 {
+            ResourcesChoice::Missing => Ok(AsBlocks::empty()),
+            ResourcesChoice::Inherit => Err(ValidationError),
+            ResourcesChoice::Blocks(some) => Ok(some),
         }
     }
 
@@ -255,19 +306,20 @@ impl AsBlocks {
     }
 
     /// Returns an iterator over the individual AS number blocks.
-    pub fn iter(&self) -> impl Iterator<Item=&AsBlock> {
-        self.0.iter()
+    pub fn iter<'a>(&'a self) -> impl Iterator<Item=AsBlock> + 'a {
+        self.0.iter().copied()
     }
 
     /// Validates AS resources issued under these blocks.
     pub fn validate_issued(
         &self,
-        res: Option<&AsResources>,
+        res: &AsResources,
         mode: Overclaim,
     ) -> Result<AsBlocks, ValidationError> {
-        match res.map(|res| &res.0) {
-            Some(ResourcesChoice::Inherit) => Ok(self.clone()),
-            Some(ResourcesChoice::Blocks(ref blocks)) => {
+        match res.0 {
+            ResourcesChoice::Missing => Ok(Self::empty()),
+            ResourcesChoice::Inherit => Ok(self.clone()),
+            ResourcesChoice::Blocks(ref blocks) => {
                 match mode {
                     Overclaim::Refuse => {
                         if blocks.0.is_encompassed(&self.0) {
@@ -284,8 +336,36 @@ impl AsBlocks {
                         }
                     }
                 }
-            },
-            None => Ok(Self::empty()),
+            }
+        }
+    }
+
+    /// Verifies that these resources are covered by an issuer’s resources.
+    ///
+    /// This is used by bottom-up validation, therefore, issuer resources 
+    /// of the inherited kind are considered covering.
+    pub fn verify_covered(
+        &self,
+        issuer: &AsResources
+    ) -> Result<(), ValidationError> {
+        match issuer.0 {
+            ResourcesChoice::Missing => {
+                if self.0.is_empty() {
+                    Ok(())
+                }
+                else {
+                    Err(ValidationError)
+                }
+            }
+            ResourcesChoice::Inherit => Ok(()),
+            ResourcesChoice::Blocks(ref blocks) => {
+                if blocks.0.is_encompassed(&self.0) {
+                    Ok(())
+                }
+                else {
+                    Err(ValidationError)
+                }
+            }
         }
     }
 }
@@ -307,6 +387,12 @@ impl AsBlocks {
         }
     }
 
+    pub fn intersection_assign(&mut self, other: &Self) {
+        if let Err(owned) = self.0.trim(&other.0) {
+            self.0 = SharedChain::from_owned(owned)
+        }
+    }
+
     /// Returns a new AsBlocks with the union of this and the other AsBlocks.
     ///
     /// i.e. all resources found in one or both AsBlocks.
@@ -317,9 +403,6 @@ impl AsBlocks {
             )
         )
     }
-
-
-
 }
 
 /// # Decoding and Encoding
@@ -375,6 +458,15 @@ impl AsBlocks {
 }
 
 
+//--- Default
+
+impl Default for AsBlocks {
+    fn default() -> Self {
+        AsBlocks::empty()
+    }
+}
+
+
 //--- FromStr and FromIterator
 
 impl FromStr for AsBlocks {
@@ -453,7 +545,7 @@ impl AsBlocksBuilder {
         AsBlocksBuilder(Vec::new())
     }
 
-    pub fn push<T: Into<AsBlock>>(&mut self, block: T) {
+    pub fn push(&mut self, block: impl Into<AsBlock>) {
         self.0.push(block.into())
     }
 
@@ -468,6 +560,13 @@ impl Default for AsBlocksBuilder {
     }
 }
 
+impl Extend<AsBlock> for AsBlocksBuilder {
+    fn extend<T>(&mut self, iter: T)
+    where T: IntoIterator<Item = AsBlock> {
+        self.0.extend(iter)
+    }
+}
+
 
 //------------ AsBlock -------------------------------------------------------
 
diff --git a/src/resources/choice.rs b/src/resources/choice.rs
index 34026a5d..7ab7ec83 100644
--- a/src/resources/choice.rs
+++ b/src/resources/choice.rs
@@ -2,8 +2,7 @@
 ///
 /// This is a private module used only internally.
 
-use std::{error, fmt};
-use std::str::FromStr;
+use std::fmt;
 use serde::{Deserialize, Serialize};
 use crate::x509::ValidationError;
 
@@ -15,6 +14,11 @@ use crate::x509::ValidationError;
 /// This is generic over the type of included resources.
 #[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
 pub enum ResourcesChoice<T> {
+    /// There are no resources of this type.
+    ///
+    /// This is a special case since creating an empty `T` may still be pricy.
+    Missing,
+
     /// Resources are to be inherited from the issuer.
     Inherit,
 
@@ -31,26 +35,21 @@ impl<T> ResourcesChoice<T> {
         }
     }
 
-    /// Returns a reference to the blocks if there are any.
-    pub fn as_blocks(&self) -> Option<&T> {
-        match self {
-            ResourcesChoice::Inherit => None,
-            ResourcesChoice::Blocks(ref some) => Some(some)
-        }
-    }
-
-    /// Returns a mutable reference to the blocks if there are any.
-    pub fn as_blocks_mut(&mut self) -> Option<&mut T> {
+    /// Returns whether the resources are present.
+    pub fn is_present(&self) -> bool {
         match self {
-            ResourcesChoice::Inherit => None,
-            ResourcesChoice::Blocks(ref mut some) => Some(some)
+            ResourcesChoice::Missing => false,
+            _ => true
         }
     }
 
     /// Converts the resources into blocks or returns an error.
+    ///
+    /// In case the resources are missing, returns a default `T`.
     pub fn to_blocks(&self) -> Result<T, ValidationError>
-    where T: Clone {
+    where T: Clone + Default {
         match self {
+            ResourcesChoice::Missing => Ok(Default::default()),
             ResourcesChoice::Inherit => Err(ValidationError),
             ResourcesChoice::Blocks(ref some) => Ok(some.clone()),
         }
@@ -60,11 +59,12 @@ impl<T> ResourcesChoice<T> {
     ///
     /// If this value is of the included variant, runs the blocks through
     /// the provided closure and returns a new choice with the result. If
-    /// this value is of the inherit variant, does nothing and simply
-    /// returns the choice.
+    /// this value is of the inherit or missing variant, does nothing and
+    /// simply returns the choice.
     pub fn map_blocks<U, F>(self, f: F) -> ResourcesChoice<U>
     where F: FnOnce(T) -> U {
         match self {
+            ResourcesChoice::Missing => ResourcesChoice::Missing,
             ResourcesChoice::Inherit => ResourcesChoice::Inherit,
             ResourcesChoice::Blocks(t) => ResourcesChoice::Blocks(f(t))
         }
@@ -77,42 +77,10 @@ impl<T> ResourcesChoice<T> {
 impl<T: fmt::Display> fmt::Display for ResourcesChoice<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
+            ResourcesChoice::Missing => Ok(()),
             ResourcesChoice::Inherit => write!(f, "inherit"),
             ResourcesChoice::Blocks(ref inner) => inner.fmt(f)
         }
     }
 }
 
-//--- FromStr
-
-impl<T: FromStr> FromStr for ResourcesChoice<T> {
-    type Err = FromStrErr;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        if s == "inherit" {
-            Ok(ResourcesChoice::Inherit)
-        } else {
-            let blocks = T::from_str(s).map_err(|_| FromStrErr::BlocksFromStr)?;
-            Ok(ResourcesChoice::Blocks(blocks))
-        }
-    }
-}
-
-//------------ FromStrError --------------------------------------------------
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub enum FromStrErr {
-    BlocksFromStr,
-}
-
-impl fmt::Display for FromStrErr {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(match *self {
-            FromStrErr::BlocksFromStr
-                => "Cannot parse blocks"
-        })
-    }
-}
-
-impl error::Error for FromStrErr { }
-
diff --git a/src/resources/ipres.rs b/src/resources/ipres.rs
index 9ad608aa..c0414998 100644
--- a/src/resources/ipres.rs
+++ b/src/resources/ipres.rs
@@ -15,10 +15,10 @@ use std::num::ParseIntError;
 use std::str::FromStr;
 use bcder::{decode, encode};
 use bcder::{BitString, Mode, OctetString, Tag, xerr};
-use bcder::encode::PrimitiveContent;
+use bcder::encode::{Nothing, PrimitiveContent};
 use crate::cert::Overclaim;
 use crate::roa::RoaIpAddress;
-use crate::x509::ValidationError;
+use crate::x509::{encode_extension, ValidationError};
 use super::chain::{Block, SharedChain};
 use super::choice::ResourcesChoice;
 
@@ -38,9 +38,22 @@ impl IpResources {
         IpResources(ResourcesChoice::Inherit)
     }
 
+    /// Creates a new AsResources with a ResourceChoice::Missing
+    pub fn missing() -> Self {
+        IpResources(ResourcesChoice::Missing)
+    }
+
     /// Creates a new IpResources for the given blocks.
+    ///
+    /// If the blocks are empty, creates a missing variant in accordance with
+    /// the specification.
     pub fn blocks(blocks: IpBlocks) -> Self {
-        IpResources(ResourcesChoice::Blocks(blocks))
+        if blocks.is_empty() {
+            IpResources::missing()
+        }
+        else {
+            IpResources(ResourcesChoice::Blocks(blocks))
+        }
     }
 
     /// Returns whether the resources are of the inherited variant.
@@ -48,9 +61,11 @@ impl IpResources {
         self.0.is_inherited()
     }
 
-    /// Returns a reference to the blocks if there are any.
-    pub fn as_blocks(&self) -> Option<&IpBlocks> {
-        self.0.as_blocks()
+    /// Returns whether the resources are empty.
+    ///
+    /// Inherited resources are not empty.
+    pub fn is_present(&self) -> bool {
+        self.0.is_present()
     }
 
     /// Converts the resources into blocks or returns an error.
@@ -114,45 +129,62 @@ impl IpResources {
         }).map(IpResources)
     }
 
-    pub fn encode_families(
-        v4: Option<Self>,
-        v6: Option<Self>
-    ) -> Option<impl encode::Values> {
-        if v4.is_none() && v6.is_none() {
-            return None
-        }
-        Some(encode::sequence((
-            v4.map(|v4| {
-                encode::sequence((
-                    AddressFamily::Ipv4.encode(),
-                    v4.encode()
-                ))
-            }),
-            v6.map(|v6| {
-                encode::sequence((
-                    AddressFamily::Ipv6.encode(),
-                    v6.encode()
-                ))
-            }),
-        )))
-    }
-
     pub fn encode(self) -> impl encode::Values {
         match self.0 {
-            ResourcesChoice::Inherit => encode::Choice2::One(().encode()),
+            ResourcesChoice::Inherit => {
+                encode::Choice3::One(().encode())
+            }
             ResourcesChoice::Blocks(blocks) => {
-                encode::Choice2::Two(blocks.encode())
+                encode::Choice3::Two(blocks.encode())
+            }
+            ResourcesChoice::Missing => {
+                encode::Choice3::Three(encode::sequence(Nothing))
             }
         }
     }
 
     pub fn encode_ref<'a>(&'a self) -> impl encode::Values + 'a {
         match self.0 {
-            ResourcesChoice::Inherit => encode::Choice2::One(().encode()),
+            ResourcesChoice::Inherit => {
+                encode::Choice3::One(().encode())
+            }
             ResourcesChoice::Blocks(ref blocks) => {
-                encode::Choice2::Two(blocks.encode_ref())
+                encode::Choice3::Two(blocks.encode_ref())
             }
+            ResourcesChoice::Missing => {
+                encode::Choice3::Three(encode::sequence(Nothing))
+            }
+        }
+    }
+
+    pub fn encode_family<'a>(
+        &'a self, family: AddressFamily
+    ) -> impl encode::Values + 'a {
+        if self.is_present() {
+            Some(encode::sequence((
+                family.encode(), self.encode_ref()
+            )))
+        }
+        else {
+            None
+        }
+    }
+
+    pub fn encode_extension<'a>(
+        overclaim: Overclaim,
+        v4: &'a Self,
+        v6: &'a Self,
+    ) -> Option<impl encode::Values + 'a> {
+        if !v4.is_present() && !v6.is_present() {
+            return None
         }
+        Some(encode_extension(
+            overclaim.ip_res_id(), true,
+            encode::sequence((
+                v4.encode_family(AddressFamily::Ipv4),
+                v6.encode_family(AddressFamily::Ipv6)
+            ))
+        ))
     }
 }
 
@@ -161,32 +193,37 @@ impl IpResources {
 
 #[derive(Clone, Debug)]
 pub struct IpResourcesBuilder {
-    res: Option<ResourcesChoice<IpBlocksBuilder>>
+    res: Option<IpBlocksBuilder>
 }
 
 impl IpResourcesBuilder {
     pub fn new() -> Self {
         IpResourcesBuilder {
-            res: None
+            res: Some(IpBlocksBuilder::new())
         }
     }
 
     pub fn inherit(&mut self) {
-        self.res = Some(ResourcesChoice::Inherit)
+        self.res = None
     }
 
     pub fn blocks<F>(&mut self, build: F)
     where F: FnOnce(&mut IpBlocksBuilder) {
-        if self.res.as_ref().map(|res| res.is_inherited()).unwrap_or(true) {
-            self.res = Some(ResourcesChoice::Blocks(IpBlocksBuilder::new()))
+        if let Some(ref mut builder) = self.res {
+            build(builder)
+        }
+        else {
+            let mut builder = IpBlocksBuilder::new();
+            build(&mut builder);
+            self.res = Some(builder)
         }
-        build(self.res.as_mut().unwrap().as_blocks_mut().unwrap())
     }
     
-    pub fn finalize(self) -> Option<IpResources> {
-        self.res.map(|choice| {
-            IpResources(choice.map_blocks(IpBlocksBuilder::finalize))
-        })
+    pub fn finalize(self) -> IpResources {
+        match self.res {
+            Some(blocks) => IpResources::blocks(blocks.finalize()),
+            None => IpResources::inherit()
+        }
     }
 }
 
@@ -259,12 +296,12 @@ impl IpBlocks {
     ///
     /// If the resources are of the inherited variant, returns an error.
     pub fn from_resources(
-        res: Option<&IpResources>
+        res: IpResources
     ) -> Result<Self, ValidationError> {
-        match res.map(|res| &res.0) {
-            Some(ResourcesChoice::Inherit) => Err(ValidationError),
-            Some(ResourcesChoice::Blocks(ref some)) => Ok(some.clone()),
-            None => Ok(IpBlocks::empty())
+        match res.0 {
+            ResourcesChoice::Missing => Ok(IpBlocks::empty()),
+            ResourcesChoice::Inherit => Err(ValidationError),
+            ResourcesChoice::Blocks(some) => Ok(some),
         }
     }
 
@@ -274,19 +311,20 @@ impl IpBlocks {
     }
 
     /// Returns an iterator over the address ranges in the block.
-    pub fn iter(&self) -> impl Iterator<Item=&IpBlock> {
-        self.0.iter()
+    pub fn iter<'a>(&'a self) -> impl Iterator<Item=IpBlock> + 'a {
+        self.0.iter().copied()
     }
 
     /// Validates IP resources issued under these blocks.
     pub fn validate_issued(
         &self,
-        res: Option<&IpResources>,
+        res: &IpResources,
         mode: Overclaim,
     ) -> Result<IpBlocks, ValidationError> {
-        match res.map(|res| &res.0) {
-            Some(ResourcesChoice::Inherit) => Ok(self.clone()),
-            Some(ResourcesChoice::Blocks(ref blocks)) => {
+        match res.0 {
+            ResourcesChoice::Missing => Ok(Self::empty()),
+            ResourcesChoice::Inherit => Ok(self.clone()),
+            ResourcesChoice::Blocks(ref blocks) => {
                 match mode {
                     Overclaim::Refuse => {
                         if self.contains(blocks) {
@@ -301,10 +339,37 @@ impl IpBlocks {
                     }
                 }
             },
-            None => Ok(Self::empty()),
         }
     }
 
+    /// Verifies that these resources are covered by an issuer’s resources.
+    ///
+    /// This is used by bottom-up validation, therefore, issuer resources 
+    /// of the inherited kind are considered covering.
+    pub fn verify_covered(
+        &self,
+        issuer: &IpResources
+    ) -> Result<(), ValidationError> {
+        match issuer.0 {
+            ResourcesChoice::Missing => {
+                if self.0.is_empty() {
+                    Ok(())
+                }
+                else {
+                    Err(ValidationError)
+                }
+            }
+            ResourcesChoice::Inherit => Ok(()),
+            ResourcesChoice::Blocks(ref blocks) => {
+                if blocks.0.is_encompassed(&self.0) {
+                    Ok(())
+                }
+                else {
+                    Err(ValidationError)
+                }
+            }
+        }
+    }
 
     /// Returns whether the address blocks cover the given ROA address prefix.
     pub fn contains_roa(&self, addr: &RoaIpAddress) -> bool {
@@ -335,6 +400,12 @@ impl IpBlocks {
         }
     }
 
+    pub fn intersection_assign(&mut self, other: &Self) {
+        if let Err(owned) = self.0.trim(&other.0) {
+            self.0 = SharedChain::from_owned(owned)
+        }
+    }
+
     /// Returns a new IpBlocks with the union of this and the other IpBlocks.
     ///
     /// i.e. all resources found in one or both IpBlocks.
@@ -396,6 +467,14 @@ impl IpBlocks {
         encode::sequence(encode::slice(&self.0, |block| block.encode()))
     }
 
+    pub fn encode_family<'a>(
+        &'a self, family: AddressFamily
+    ) -> impl encode::Values + 'a {
+        encode::sequence((
+            family.encode(), self.encode_ref()
+        ))
+    }
+
     /// Returns an IpBlocksForFamily for IPv4 for this,
     /// to help formatting.
     pub fn as_v4(&self) -> IpBlocksForFamily {
@@ -409,6 +488,12 @@ impl IpBlocks {
     }
 }
 
+impl Default for IpBlocks {
+    fn default() -> Self {
+        IpBlocks::empty()
+    }
+}
+
 impl FromStr for IpBlocks {
     type Err = FromStrError;
 
@@ -484,6 +569,13 @@ impl Default for IpBlocksBuilder {
     }
 }
 
+impl Extend<IpBlock> for IpBlocksBuilder {
+    fn extend<T>(&mut self, iter: T)
+    where T: IntoIterator<Item = IpBlock> {
+        self.0.extend(iter)
+    }
+}
+
 //------------ IpBlock -------------------------------------------------------
 
 /// A consecutive sequence of IP addresses.
diff --git a/src/resources/mod.rs b/src/resources/mod.rs
index 07ad7e7d..490b32bb 100644
--- a/src/resources/mod.rs
+++ b/src/resources/mod.rs
@@ -27,3 +27,4 @@ mod asres;
 mod chain;
 mod choice;
 mod ipres;
+
diff --git a/src/roa.rs b/src/roa.rs
index 6455f789..50a7085c 100644
--- a/src/roa.rs
+++ b/src/roa.rs
@@ -539,7 +539,7 @@ impl RoaBuilder {
         let v4 = self.v4.to_resources();
         let v6 = self.v6.to_resources();
         // There must be some resources in order to make a valid ROA.
-        assert!(v4.is_some() || v6.is_some());
+        assert!(v4.is_present() || v6.is_present());
         sigobj.set_v4_resources(v4);
         sigobj.set_v6_resources(v6);
         let signed = sigobj.finalize(
@@ -590,16 +590,10 @@ impl RoaIpAddressesBuilder {
        )
     }
 
-    pub fn to_resources(&self) -> Option<IpResources> {
-        let blocks = IpBlocks::from_iter(
+    pub fn to_resources(&self) -> IpResources {
+        IpResources::blocks(IpBlocks::from_iter(
             self.addrs.iter().map(|addr| addr.prefix.into())
-        );
-        if blocks.is_empty() {
-            None
-        }
-        else {
-            Some(IpResources::blocks(blocks))
-        }
+        ))
     }
 
     pub fn encode_ref<'a>(&'a self) -> impl encode::Values + 'a {
diff --git a/src/rta.rs b/src/rta.rs
index 663e9c48..a90c8126 100644
--- a/src/rta.rs
+++ b/src/rta.rs
@@ -4,6 +4,11 @@
 //! resources referred to by a docuement. This is currently an IETF draft,
 //! see [draft-michaelson-rpki-rta] for details.
 //!
+//! Current limitations:
+//!
+//! * Resources are read in a rather relaxed way: they can be unordered and
+//!   overlapping. This happens even if the strict flag is set.
+//!
 //! draft-michaelson-rpki-rta: https://tools.ietf.org/html/draft-michaelson-rpki-rta
 
 use std::ops;
@@ -14,16 +19,18 @@ use bcder::string::OctetStringSource;
 use bcder::xerr;
 use bytes::Bytes;
 use crate::oid;
-use crate::cert::{Cert, ResourceCert};
+use crate::cert::{Cert, Overclaim, ResourceCert};
 use crate::crl::Crl;
 use crate::crypto:: {
-    DigestAlgorithm, KeyIdentifier, Signature, SignatureAlgorithm,
+    Digest, DigestAlgorithm, KeyIdentifier, Signature, SignatureAlgorithm,
     Signer, SigningError
 };
 use crate::resources::{
-    AddressFamily, AsBlock, AsBlocksBuilder, IpBlock, IpBlocksBuilder
+    AddressFamily, AsBlock, AsBlocks, AsBlocksBuilder, IpBlock, IpBlocks,
+    IpBlocksBuilder,
 };
 use crate::sigobj::{MessageDigest, SignedAttrs};
+use crate::tal::Tal;
 use crate::x509::{Time, ValidationError};
 
 
@@ -41,8 +48,7 @@ impl Rta {
     }
 
     pub fn decode<S: decode::Source>(
-        source: S,
-        strict: bool
+        source: S, strict: bool
     ) -> Result<Self, S::Err> {
         let signed = MultiSignedObject::decode(source, strict)?;
         let content = signed.decode_content(|cons| {
@@ -84,16 +90,16 @@ impl AsRef<ResourceTaggedAttestation> for Rta {
 
 #[derive(Clone, Debug)]
 pub struct ResourceTaggedAttestation {
-    subject_keys: SubjectKeySet,
+    subject_keys: Vec<KeyIdentifier>,
 
     /// AS Resources
-    as_resources: RtaAsBlocks,
+    as_resources: AsBlocks,
 
     /// IP Resources for the IPv4 address family.
-    v4_resources: RtaIpBlocks,
+    v4_resources: IpBlocks,
 
     /// IP Resources for the IPv6 address family.
-    v6_resources: RtaIpBlocks,
+    v6_resources: IpBlocks,
 
     digest_algorithm: DigestAlgorithm,
 
@@ -101,19 +107,19 @@ pub struct ResourceTaggedAttestation {
 }
 
 impl ResourceTaggedAttestation {
-    pub fn subject_keys(&self) -> &SubjectKeySet {
+    pub fn subject_keys(&self) -> &[KeyIdentifier] {
         &self.subject_keys
     }
 
-    pub fn as_resources(&self) -> &RtaAsBlocks {
+    pub fn as_resources(&self) -> &AsBlocks {
         &self.as_resources
     }
 
-    pub fn v4_resources(&self) -> &RtaIpBlocks {
+    pub fn v4_resources(&self) -> &IpBlocks {
         &self.v4_resources
     }
 
-    pub fn v6_resources(&self) -> &RtaIpBlocks {
+    pub fn v6_resources(&self) -> &IpBlocks {
         &self.v6_resources
     }
 
@@ -132,7 +138,7 @@ impl ResourceTaggedAttestation {
     ) -> Result<Self, S::Err> {
         cons.take_sequence(|cons| {
             cons.take_opt_constructed_if(Tag::CTX_0, |c| c.skip_u8_if(0))?;
-            let subject_keys = SubjectKeySet::take_from(cons)?;
+            let subject_keys = Self::take_subject_keys_from(cons)?;
             let (v4res, v6res, asres) = Self::take_resources_from(cons)?;
             let alg = DigestAlgorithm::take_from(cons)?;
             let digest = OctetString::take_from(cons)?;
@@ -147,12 +153,24 @@ impl ResourceTaggedAttestation {
         })
     }
 
+    fn take_subject_keys_from<S: decode::Source>(
+        cons: &mut decode::Constructed<S>
+    ) -> Result<Vec<KeyIdentifier>, S::Err> {
+        cons.take_set(|cons| {
+            let mut res = Vec::new();
+            while let Some(id) = KeyIdentifier::take_opt_from(cons)? {
+                res.push(id)
+            }
+            Ok(res)
+        })
+    }
+
     fn take_resources_from<S: decode::Source>(
         cons: &mut decode::Constructed<S>
-    ) -> Result<(RtaIpBlocks, RtaIpBlocks, RtaAsBlocks), S::Err> {
+    ) -> Result<(IpBlocks, IpBlocks, AsBlocks), S::Err> {
         cons.take_sequence(|cons| {
             let asres = cons.take_opt_constructed_if(Tag::CTX_0, |cons| {
-                RtaAsBlocks::take_from(cons)
+                AsBlocks::take_from(cons)
             })?;
 
             let mut v4 = None;
@@ -165,13 +183,13 @@ impl ResourceTaggedAttestation {
                                 if v4.is_some() {
                                     xerr!(return Err(decode::Malformed.into()));
                                 }
-                                v4 = Some(RtaIpBlocks::take_from(cons)?);
+                                v4 = Some(IpBlocks::take_from(cons)?);
                             }
                             AddressFamily::Ipv6 => {
                                 if v6.is_some() {
                                     xerr!(return Err(decode::Malformed.into()));
                                 }
-                                v6 = Some(RtaIpBlocks::take_from(cons)?);
+                                v6 = Some(IpBlocks::take_from(cons)?);
                             }
                         }
                         Ok(())
@@ -194,7 +212,11 @@ impl ResourceTaggedAttestation {
     pub fn encode_ref<'a>(&'a self) -> impl encode::Values + 'a {
         encode::sequence((
             // version is DEFAULT
-            self.subject_keys.encode_ref(),
+            encode::set(
+                encode::iter(self.subject_keys.iter().map(|item| {
+                    item.encode_ref()
+                }))
+            ),
             encode::sequence((
                 self.encode_as_resources(),
                 self.encode_ip_resources(),
@@ -206,11 +228,15 @@ impl ResourceTaggedAttestation {
 
     fn encode_as_resources<'a>(&'a self) -> impl encode::Values + 'a {
         if self.as_resources.is_empty() {
-            return None
+            None
+        }
+        else {
+            Some(encode::sequence_as(Tag::CTX_0,
+                encode::sequence(
+                    self.as_resources.encode_ref()
+                )
+            ))
         }
-        Some(encode::sequence_as(Tag::CTX_0,
-            self.as_resources.encode_ref()
-        ))
     }
 
     fn encode_ip_resources<'a>(&'a self) -> impl encode::Values + 'a {
@@ -219,8 +245,8 @@ impl ResourceTaggedAttestation {
         }
         Some(encode::sequence_as(Tag::CTX_1,
             encode::sequence((
-                self.v4_resources.encode_ref_family([0x00, 0x01]),
-                self.v6_resources.encode_ref_family([0x00, 0x02]),
+                self.v4_resources.encode_family(AddressFamily::Ipv4),
+                self.v6_resources.encode_family(AddressFamily::Ipv6),
             ))
         ))
     }
@@ -231,141 +257,6 @@ impl ResourceTaggedAttestation {
 }
 
 
-//------------ SubjectKeySet -------------------------------------------------
-
-// The captured content only contains the content of the set.
-#[derive(Clone, Debug)]
-pub struct SubjectKeySet(Captured);
-
-impl SubjectKeySet {
-    fn take_from<S: decode::Source>(
-        cons: &mut decode::Constructed<S>
-    ) -> Result<Self, S::Err> {
-        cons.take_set(|cons| {
-            cons.capture(|cons| {
-                KeyIdentifier::skip_in(cons)
-            }).map(SubjectKeySet)
-        })
-    }
-
-    fn encode_ref<'a>(&'a self) -> impl encode::Values + 'a {
-        encode::set(
-            &self.0
-        )
-    }
-}
-
-impl From<Vec<KeyIdentifier>> for SubjectKeySet {
-    fn from(src: Vec<KeyIdentifier>) -> Self {
-        SubjectKeySet(Captured::from_values(
-            Mode::Der,
-            encode::iter(src.iter().map(|item| item.encode_ref()))
-        ))
-    }
-}
-
-
-//------------ RtaAsBlocks ---------------------------------------------------
-
-#[derive(Clone, Debug)]
-pub struct RtaAsBlocks(Captured);
-
-impl RtaAsBlocks {
-    pub fn is_empty(&self) -> bool {
-        self.0.is_empty()
-    }
-}
-
-impl RtaAsBlocks {
-    fn take_from<S: decode::Source>(
-        cons: &mut decode::Constructed<S>
-    ) -> Result<Self, S::Err> {
-        cons.take_sequence(|cons| {
-            cons.capture(|cons| {
-                while AsBlock::skip_opt_in(cons)?.is_some() { }
-                Ok(())
-            })
-        }).map(RtaAsBlocks)
-    }
-
-    fn encode_ref<'a>(&'a self) -> impl encode::Values + 'a {
-        encode::sequence(
-            &self.0
-        )
-    }
-}
-
-impl Default for RtaAsBlocks {
-    fn default() -> Self {
-        RtaAsBlocks(Captured::empty(Mode::Der))
-    }
-}
-
-impl From<AsBlocksBuilder> for RtaAsBlocks {
-    fn from(src: AsBlocksBuilder) -> RtaAsBlocks {
-        RtaAsBlocks(Captured::from_values(
-            Mode::Der,
-            src.finalize().encode()
-        ))
-    }
-}
-
-
-//------------ RtaIpBlocks ---------------------------------------------------
-
-#[derive(Clone, Debug)]
-pub struct RtaIpBlocks(Captured);
-
-impl RtaIpBlocks {
-    pub fn is_empty(&self) -> bool {
-        self.0.is_empty()
-    }
-}
-
-impl RtaIpBlocks {
-    fn take_from<S: decode::Source>(
-        cons: &mut decode::Constructed<S>
-    ) -> Result<Self, S::Err> {
-        cons.take_sequence(|cons| {
-            cons.capture(|cons| {
-                while IpBlock::take_opt_from(cons)?.is_some() { }
-                Ok(())
-            })
-        }).map(RtaIpBlocks)
-    }
-
-    fn encode_ref_family<'a>(
-        &'a self,
-        family: [u8; 2]
-    ) -> impl encode::Values + 'a {
-        if self.0.is_empty() {
-            None
-        }
-        else {
-            Some(encode::sequence((
-                OctetString::encode_slice(family),
-                &self.0
-            )))
-        }
-    }
-}
-
-impl Default for RtaIpBlocks {
-    fn default() -> Self {
-        RtaIpBlocks(Captured::empty(Mode::Der))
-    }
-}
-
-impl From<IpBlocksBuilder> for RtaIpBlocks {
-    fn from(src: IpBlocksBuilder) -> RtaIpBlocks {
-        RtaIpBlocks(Captured::from_values(
-            Mode::Der,
-            src.finalize().encode()
-        ))
-    }
-}
-
-
 //------------ MultiSignedObject ---------------------------------------------
 
 /// The flavour of a signed object used for RTAs.
@@ -373,9 +264,9 @@ impl From<IpBlocksBuilder> for RtaIpBlocks {
 pub struct MultiSignedObject {
     digest_algorithm: DigestAlgorithm,
     content: OctetString,
-    certificates: CertificateSet,
-    crls: CrlSet,
-    signer_infos: SignerInfoSet,
+    certificates: Vec<Cert>,
+    crls: Vec<Crl>,
+    signer_infos: Vec<SignerInfo>,
 }
 
 impl MultiSignedObject {
@@ -394,14 +285,13 @@ impl MultiSignedObject {
 
 impl MultiSignedObject {
     pub fn decode<S: decode::Source>(
-        source: S,
-        _strict: bool
+        source: S, strict: bool
     ) -> Result<Self, S::Err> {
-        Mode::Der.decode(source, Self::take_from)
+        Mode::Der.decode(source, |cons| Self::take_from(cons, strict))
     }
 
     pub fn take_from<S: decode::Source>(
-        cons: &mut decode::Constructed<S>
+        cons: &mut decode::Constructed<S>, strict: bool
     ) -> Result<Self, S::Err> {
         cons.take_sequence(|cons| {
             oid::SIGNED_DATA.skip_if(cons)?; // contentType
@@ -418,11 +308,9 @@ impl MultiSignedObject {
                             OctetString::take_from
                         )
                     })?;
-                    let certificates = CertificateSet::take_if(
-                        Tag::CTX_0, cons
-                    )?;
-                    let crls = CrlSet::take_opt_if(Tag::CTX_1, cons)?;
-                    let signer_infos = SignerInfoSet::take_from(cons)?;
+                    let certificates = Self::take_certificates(cons, strict)?;
+                    let crls = Self::take_crls(cons, strict)?;
+                    let signer_infos = Self::take_signer_infos(cons, strict)?;
 
                     Ok(MultiSignedObject {
                         digest_algorithm,
@@ -436,10 +324,40 @@ impl MultiSignedObject {
         })
     }
 
-    pub fn validate<F: FnMut(Cert) -> Result<ResourceCert, ValidationError>>(
-        self, _strict: bool, _validate_cert: F
-    ) -> Result<ResourceTaggedAttestation, ValidationError> {
-        unimplemented!()
+    fn take_certificates<S: decode::Source>(
+        cons: &mut decode::Constructed<S>, _strict: bool
+    ) -> Result<Vec<Cert>, S::Err> {
+        cons.take_constructed_if(Tag::CTX_0, |cons| {
+            let mut certificates = Vec::new();
+            while let Some(cert) = Cert::take_opt_from(cons)? {
+                certificates.push(cert);
+            }
+            Ok(certificates)
+        })
+    }
+
+    fn take_crls<S: decode::Source>(
+        cons: &mut decode::Constructed<S>, _strict: bool
+    ) -> Result<Vec<Crl>, S::Err> {
+        cons.take_constructed_if(Tag::CTX_1, |cons| {
+            let mut crls = Vec::new();
+            while let Some(crl) = Crl::take_opt_from(cons)? {
+                crls.push(crl);
+            }
+            Ok(crls)
+        })
+    }
+
+    fn take_signer_infos<S: decode::Source>(
+        cons: &mut decode::Constructed<S>, _strict: bool
+    ) -> Result<Vec<SignerInfo>, S::Err> {
+        cons.take_set(|cons| {
+            let mut infos = Vec::new();
+            while let Some(info) = SignerInfo::take_opt_from(cons)? {
+                infos.push(info);
+            }
+            Ok(infos)
+        })
     }
 
     /// Returns a value encoder for a reference to a signed object.
@@ -457,10 +375,25 @@ impl MultiSignedObject {
                         ),
                     )),
                     encode::sequence_as(Tag::CTX_0, // certificates
-                        self.certificates.encode_ref(),
+                        encode::iter(self.certificates.iter().map(|item| {
+                            item.encode_ref()
+                        }))
                     ),
-                    self.crls.encode_ref_as(Tag::CTX_1),
-                    encode::sequence(self.signer_infos.encode_ref()),
+                    if self.crls.is_empty() {
+                        None
+                    }
+                    else {
+                        Some(encode::sequence_as(Tag::CTX_1, // crls
+                            encode::iter(self.crls.iter().map(|item| {
+                                item.encode_ref()
+                            }))
+                        ))
+                    },
+                    encode::set(
+                        encode::iter(self.signer_infos.iter().map(|item| {
+                            item.encode_ref()
+                        }))
+                    )
                 )),
             )
         ))
@@ -468,156 +401,6 @@ impl MultiSignedObject {
 }
 
 
-//------------ CertificateSet ------------------------------------------------
-
-// The captured content is the content of the set. We only support a
-// certificate choice of a certificate.
-#[derive(Clone, Debug)]
-pub struct CertificateSet(Captured);
-
-impl From<Vec<Cert>> for CertificateSet {
-    fn from(src: Vec<Cert>) -> CertificateSet {
-        CertificateSet(Captured::from_values(
-            Mode::Der,
-            encode::iter(src.iter().map(|item| item.encode_ref()))
-        ))
-    }
-}
-
-impl CertificateSet {
-    pub fn collect_certs(self) -> Vec<Cert> {
-        self.0.decode(|cons| {
-            let mut res = Vec::new();
-            while let Some(cert) = Cert::take_opt_from(cons)? {
-                res.push(cert)
-            }
-            Ok(res)
-        }).unwrap()
-    }
-}
-
-impl CertificateSet {
-    pub fn take_if<S: decode::Source>(
-        tag: Tag, cons: &mut decode::Constructed<S>
-    ) -> Result<Self, S::Err> {
-        cons.take_constructed_if(tag, |cons| {
-            cons.capture(|cons| {
-                while Cert::take_opt_from(cons)?.is_some() { }
-                Ok(())
-            })
-        }).map(CertificateSet)
-    }
-
-    /// Returns a value encoder for a reference to a signed object.
-    pub fn encode_ref<'a>(&'a self) -> impl encode::Values + 'a {
-        &self.0
-    }
-}
-
-
-//------------ CrlSet --------------------------------------------------------
-
-// The captured content is the content of the set. We only support a
-// choice of a CRL.
-#[derive(Clone, Debug)]
-pub struct CrlSet(Captured);
-
-impl From<Vec<Crl>> for CrlSet {
-    fn from(src: Vec<Crl>) -> CrlSet {
-        CrlSet(Captured::from_values(
-            Mode::Der,
-            encode::iter(src.iter().map(|item| item.encode_ref()))
-        ))
-    }
-}
-
-impl CrlSet {
-    pub fn collect_crls(self) -> Vec<Crl> {
-        self.0.decode(|cons| {
-            let mut res = Vec::new();
-            while let Some(crl) = Crl::take_opt_from(cons)? {
-                res.push(crl)
-            }
-            Ok(res)
-        }).unwrap()
-    }
-}
-
-impl CrlSet {
-    pub fn take_opt_if<S: decode::Source>(
-        tag: Tag, cons: &mut decode::Constructed<S>
-    ) -> Result<Self, S::Err> {
-        let res = cons.take_opt_constructed_if(tag, |cons| {
-            cons.capture(|cons| {
-                while Crl::take_opt_from(cons)?.is_some() { }
-                Ok(())
-            })
-        })?;
-        Ok(CrlSet(res.unwrap_or_else(|| Captured::empty(Mode::Der))))
-    }
-
-
-    /// Returns a value encoder for a reference to a signed object.
-    pub fn encode_ref_as<'a>(&'a self, tag: Tag) -> impl encode::Values + 'a {
-        if self.0.is_empty() {
-            None
-        }
-        else {
-            Some(encode::sequence_as(tag, &self.0))
-        }
-    }
-}
-
-
-//------------ SignerInfoSet -------------------------------------------------
-
-#[derive(Clone, Debug)]
-pub struct SignerInfoSet(Captured);
-
-impl From<Vec<SignerInfo>> for SignerInfoSet {
-    fn from(src: Vec<SignerInfo>) -> SignerInfoSet {
-        SignerInfoSet(Captured::from_values(
-            Mode::Der,
-            encode::iter(src.iter().map(|item| item.encode_ref()))
-        ))
-    }
-}
-
-impl SignerInfoSet {
-    pub fn collect_signer_infos(
-        self,
-    ) -> Vec<SignerInfo> {
-        self.0.decode(|cons| {
-            let mut res = Vec::new();
-            while let Some(crl) = SignerInfo::take_opt_from(
-                cons
-            )? {
-                res.push(crl)
-            }
-            Ok(res)
-        }).unwrap()
-    }
-}
-
-impl SignerInfoSet {
-    pub fn take_from<S: decode::Source>(
-        cons: &mut decode::Constructed<S>
-    ) -> Result<Self, S::Err> {
-        cons.take_set(|cons| {
-            cons.capture(|cons| {
-                while SignerInfo::take_opt_from(cons)?.is_some() { }
-                Ok(())
-            })
-        }).map(SignerInfoSet)
-    }
-
-    /// Returns a value encoder for a reference to a signed object.
-    pub fn encode_ref<'a>( &'a self) -> impl encode::Values + 'a {
-        &self.0
-    } 
-}
-
-
 //------------ SignerInfo ----------------------------------------------------
 
 /// A single SignerInfo of a signed object.
@@ -684,6 +467,609 @@ impl SignerInfo {
 }
 
 
+//------------ Validator -----------------------------------------------------
+
+#[derive(Clone, Debug)]
+pub struct Validation<'a> {
+    /// The RTA object we are validating.
+    rta: &'a Rta,
+
+    /// The validation chains we need to validate.
+    chains: Vec<Chain<'a>>,
+
+    /// Are we doing strict validation?
+    strict: bool,
+
+    /// What time is it, Geoff Peterson?
+    now: Time,
+}
+
+impl<'a> Validation<'a> {
+    pub fn new(
+        rta: &'a Rta, strict: bool, now: Time,
+    ) -> Result<Self, ValidationError> {
+        // Get a vec with options of refs to the CRLs. Whenever we used a CRL
+        // in a CA, we take it out. Thus, at the end we need to have all
+        // `None` in the vec.
+        let mut crls: Vec<_> = rta.signed.crls.iter().map(Some).collect();
+
+        // Ditto for the subject keys included with the content.
+        let mut keys: Vec<_> = rta.content.subject_keys.iter().map(|key| {
+            Some(*key)
+        }).collect();
+
+        // Calculate the digest of the content.
+        let digest = {
+            let mut context = rta.signed.digest_algorithm.start();
+            rta.signed.content.iter().for_each(|x| context.update(x));
+            context.finish()
+        };
+
+        // Process all certificates. CA certificates go into the CA vec and
+        // EE certificates go into a temporary option-vec which we use when
+        // creating chains from signer-infos later.
+        let mut cas = Vec::new();
+        let mut ees = Vec::new();
+        for cert in &rta.signed.certificates {
+            if cert.basic_ca().is_none() {
+                cert.inspect_ee_at(strict, now)?;
+                ees.push(Some(cert));
+            }
+            else {
+                cas.push(Ca::new(cert, &mut crls, strict, now)?);
+            }
+        }
+
+        let mut chains = Vec::new();
+        for info in &rta.signed.signer_infos {
+            chains.push(
+                Chain::new(info, &digest, &mut keys, &mut ees)?
+            )
+        }
+
+        // All subject keys need to have been used.
+        if keys.iter().any(|item| item.is_some()) {
+            return Err(ValidationError)
+        }
+
+        // All CRLs need to have been used.
+        if crls.iter().any(|item| item.is_some()) {
+            return Err(ValidationError)
+        }
+
+        // All EE certificates have to have been used.
+        if ees.iter().any(|item| item.is_some()) {
+            return Err(ValidationError)
+        }
+
+        // Create the object and advance the chains using the CA certificates
+        // we have.
+        let mut res = Validation { rta, chains, strict, now };
+        res.advance_chains(&mut cas)?;
+
+
+        // All the CA certificates have to have been used.
+        if cas.iter().any(|item| !item.used) {
+            return Err(ValidationError)
+        }
+
+        // Hurray!
+        Ok(res)
+    }
+
+    fn advance_chains(
+        &mut self, cas: &mut [Ca<'a>]
+    ) -> Result<(), ValidationError> {
+        for chain in &mut self.chains {
+            chain.advance(cas, self.strict)?;
+        }
+        Ok(())
+    }
+
+    pub fn supply_tal(&mut self, tal: &Tal) -> Result<bool, ValidationError> {
+        let mut done = true;
+        for chain in &mut self.chains {
+            if !chain.supply_tal(tal, self.strict, self.now)? {
+                done = false
+            }
+        }
+        Ok(done)
+    }
+
+    pub fn supply_ca(
+        &mut self, ca: &ResourceCert
+    ) -> Result<bool, ValidationError> {
+        let mut done = true;
+        for chain in &mut self.chains {
+            if !chain.supply_ca(ca, self.strict, self.now)? {
+                done = false
+            }
+        }
+        Ok(done)
+    }
+
+    pub fn finalize(
+        self
+    ) -> Result<&'a ResourceTaggedAttestation, ValidationError> {
+        let mut asn = AsBlocksBuilder::new();
+        let mut v4 = IpBlocksBuilder::new();
+        let mut v6 = IpBlocksBuilder::new();
+
+        for chain in &self.chains {
+            chain.finalize(&mut asn, &mut v4, &mut v6)?;
+        }
+
+        let asn = asn.finalize();
+        let v4 = v4.finalize();
+        let v6 = v6.finalize();
+
+        if asn != self.rta.content.as_resources
+            || v4 != self.rta.content.v4_resources
+            || v6 != self.rta.content.v6_resources
+        {
+            return Err(ValidationError)
+        }
+
+        Ok(self.rta)
+    }
+}
+
+
+//------------ Ca ------------------------------------------------------------
+
+#[derive(Clone, Debug)]
+struct Ca<'a> {
+    cert: &'a Cert,
+    crl: &'a Crl,
+    used: bool,
+}
+
+impl<'a> Ca<'a> {
+    fn new(
+        cert: &'a Cert,
+        crls: &mut [Option<&'a Crl>],
+        strict: bool, now: Time,
+    ) -> Result<Self, ValidationError> {
+        cert.inspect_ca_at(strict, now)?;
+        Ok(Ca {
+            cert,
+            crl: Self::find_crl(cert, crls)?,
+            used: false
+        })
+    }
+
+    fn find_crl<'c>(
+        cert: &Cert, crls: &mut [Option<&'c Crl>]
+    ) -> Result<&'c Crl, ValidationError> {
+        for crl in crls {
+            match crl.as_ref() {
+                Some(crl) => {
+                    if *crl.authority_key_identifier()
+                        != cert.subject_key_identifier()
+                    {
+                        continue
+                    }
+                    if crl.validate(cert.subject_public_key_info()).is_err() {
+                        continue
+                    }
+                }
+                None => continue
+            }
+            return Ok(crl.take().unwrap())
+        }
+        Err(ValidationError)
+    }
+}
+
+
+//------------ Chain ---------------------------------------------------------
+
+#[derive(Clone, Debug)]
+struct Chain<'a> {
+    /// The topmost certifcate of the path.
+    cert: &'a Cert,
+
+    /// The resources of the topmost cert.
+    cert_resources: CertResources,
+
+    /// The resources of the entire path.
+    chain_resources: CertResources,
+
+    /// Has the chain been validated?
+    validated: bool,
+}
+
+impl<'a> Chain<'a> {
+    //--- new and helpers
+
+    fn new(
+        info: &SignerInfo,
+        digest: &Digest,
+        keys: &mut [Option<KeyIdentifier>],
+        ees: &mut [Option<&'a Cert>],
+    ) -> Result<Self, ValidationError> {
+        // Find and removed sid in keys.
+        match keys.iter_mut().find(|item| **item == Some(info.sid)) {
+            Some(item) => *item = None,
+            None => return Err(ValidationError)
+        }
+
+        // Verify the message digest attribute
+        if digest.as_ref() != info.message_digest.as_ref() {
+            return Err(ValidationError)
+        }
+
+        // Find th EE cert that signed this signer info.
+        let ee = Self::find_cert(info, ees)?;
+
+        let resources = CertResources::new(ee);
+        Ok(Chain {
+            cert: ee,
+            cert_resources: resources.clone(),
+            chain_resources: resources,
+            validated: false
+        })
+    }
+
+    fn find_cert(
+        info: &SignerInfo,
+        ees: &mut [Option<&'a Cert>]
+    ) -> Result<&'a Cert, ValidationError> {
+        let msg = info.signed_attrs.encode_verify();
+        for cert in ees {
+            if let Some(cert) = *cert {
+                if cert.subject_key_identifier() != info.sid {
+                    continue
+                }
+                if cert.subject_public_key_info().verify(
+                    &msg,
+                    &info.signature
+                ).is_err() {
+                    continue
+                }
+
+            }
+        }
+        Err(ValidationError)
+    }
+
+    //--- advance and helpers
+
+    fn advance(
+        &mut self,
+        cas: &mut [Ca<'a>],
+        strict: bool,
+    ) -> Result<(), ValidationError> {
+        while let Some(ca) = self.find_ca(cas, strict)? {
+            self.apply_ca(ca)?;
+        }
+        Ok(())
+    }
+
+    fn find_ca<'c>(
+        &self,
+        cas: &'c mut [Ca<'a>],
+        strict: bool,
+    ) -> Result<Option<&'c Ca<'a>>, ValidationError> {
+        // If we don’t have an authority key identifier on the cert, it is
+        // self-signed and we are done.
+        let aki = match self.cert.authority_key_identifier() {
+            Some(aki) => aki,
+            None => return Ok(None)
+        };
+
+        let mut found = false;
+        for ca in cas {
+            if ca.cert.subject_key_identifier() != aki {
+                continue
+            }
+            found = true;
+            if self.cert.verify_signature(&ca.cert, strict).is_err() {
+                continue
+            }
+            return Ok(Some(ca))
+        }
+        if found {
+            Err(ValidationError)
+        }
+        else {
+            Ok(None)
+        }
+    }
+
+    fn apply_ca(&mut self, ca: &Ca<'a>) -> Result<(), ValidationError> {
+        // Check that our cert hasn’t been revoked.
+        if ca.crl.contains(self.cert.serial_number()) {
+            return Err(ValidationError)
+        }
+
+        // Check if the CA allows us to have our resources.
+        self.verify_resources(ca)?;
+
+        // Now update self to reflect the new head of chain cert.
+        self.update_head(ca);
+
+        Ok(())
+    }
+
+    fn verify_resources(&self, ca: &Ca) -> Result<(), ValidationError> {
+        // If our cert is of the resource trimming kind, we don’t actually
+        // need to check but rather have to trim resources later on.
+        if self.cert.overclaim() == Overclaim::Trim {
+            return Ok(())
+        }
+        
+        // If we have a certain resource, it needs to be covered by the CA.
+        // If the CA has that resource as inherited, that qualifies as valid,
+        // too.
+        if let Some(blocks) = self.cert_resources.as_resources.as_ref() {
+            blocks.verify_covered(ca.cert.as_resources())?
+        }
+        if let Some(blocks) = self.cert_resources.v4_resources.as_ref() {
+            blocks.verify_covered(ca.cert.v4_resources())?
+        }
+        if let Some(blocks) = self.cert_resources.v6_resources.as_ref() {
+            blocks.verify_covered(ca.cert.v6_resources())?
+        }
+
+        Ok(())
+    }
+
+    fn update_head(&mut self, ca: &Ca<'a>) {
+        // Let’s get the CA’s resources so we can play with them.
+        let ca_resources = CertResources::new(ca.cert);
+
+        // If our current head has a resource trimming certificate, we first
+        // need to trim back the chain resources to whatever the CA allows.
+        if self.cert.overclaim() == Overclaim::Trim {
+            self.chain_resources.trim_to(&ca_resources);
+        }
+
+        // Next we update remaining inherited chain resources to what the CA
+        // has (unless it is inherited, too).
+        self.chain_resources.replace_inherited(&ca_resources);
+
+        // Now we can update the head resources and certificate, leaving
+        // inherited resources in the CA untouched.
+        self.cert_resources.update_head(ca_resources);
+    }
+
+
+    //--- supply_tal and supply_ca
+
+    fn supply_tal(
+        &mut self, tal: &Tal, strict: bool, now: Time
+    ) -> Result<bool, ValidationError> {
+        if self.validated {
+            return Ok(true)
+        }
+
+        // If we have an AKI, this isn’t a TA certificate and we don’t need
+        // to bother checking.
+        if self.cert.authority_key_identifier().is_some() {
+            return Ok(false)
+        }
+
+        // Let’s see if the key matches.
+        if self.cert.subject_public_key_info() != tal.key_info() {
+            return Ok(false)
+        }
+
+        // Finally, let’s see if we have a proper TA certificate. We only do
+        // this now so we don’t check over and over again. We also will never
+        // check a certificate that doesn’t have a matching TAL which will
+        // safe a little extra time.
+        self.cert.inspect_ta_at(strict, now)?;
+        self.cert.verify_ta_ref(strict)?;
+
+        self.validated = true;
+        Ok(true)
+    }
+
+    fn supply_ca(
+        &mut self, ca: &ResourceCert, strict: bool, now: Time
+    ) -> Result<bool, ValidationError> {
+        if self.validated {
+            return Ok(true)
+        }
+
+        // Quick check first: If we don’t have an AKI, we are our own CA and
+        // don’t need to continue here.
+        if self.cert.authority_key_identifier().is_none() {
+            return Ok(false)
+        }
+
+        // Now check properly if `ca` should be our CA and return if it isn’t.
+        //
+        // If it isn’t not all is lost. There may just be a key identifier
+        // collission or something. Unlikely but hey.
+        if self.cert.verify_issuer_claim(ca, strict).is_err()
+            || self.cert.verify_signature(ca, strict).is_err()
+        {
+            return Ok(false)
+        }
+
+        // Now let’s see if our certificate is a proper CA or EE certificate.
+        //
+        // basic_ca must be present (and true) for CA certs and not present
+        // for EE certs, so we can use that. If it has the wrong value, the
+        // cert is broken, so the check will fail and all is good.
+        //
+        // We will error out here if the cert is broken because, well, the
+        // cert is broken.
+        if self.cert.basic_ca().is_some() {
+            self.cert.inspect_ca_at(strict, now)?;
+        }
+        else {
+            self.cert.inspect_ee_at(strict, now)?;
+        }
+
+        // Finally, resources. If they don’t check out, we can error out ...
+        // I think.
+        //
+        // Remember that our cert may be of the resource trimming kind,
+        // though.
+        if self.cert.overclaim() == Overclaim::Trim {
+            self.chain_resources.trim_to_issuer(ca);
+        }
+        else {
+            self.cert_resources.verify_issuer(ca)?;
+        }
+
+        // If we still have inherited resources left, replace them with the
+        // CA cert.
+        self.chain_resources.replace_inherited_from_issuer(ca);
+
+        self.validated = true;
+        Ok(true)
+    }
+
+    //--- finalize
+
+    fn finalize(
+        &self,
+        asn: &mut AsBlocksBuilder,
+        v4: &mut IpBlocksBuilder,
+        v6: &mut IpBlocksBuilder
+    ) -> Result<(), ValidationError> {
+        if !self.validated {
+            return Err(ValidationError)
+        }
+
+        // Add all our resources to the collection of resources.
+        //
+        // We can’t really have inherited resources left (if the top was a TA
+        // certificate, we should have rejected it already in this case and
+        // otherwise we checked it against a resource CA cert from outside
+        // which always has all resources) resources left, so let’s unwrap
+        // here to indicate a programming error.
+        asn.extend(self.chain_resources.as_resources.as_ref().unwrap().iter());
+        v4.extend(self.chain_resources.v4_resources.as_ref().unwrap().iter());
+        v6.extend(self.chain_resources.v6_resources.as_ref().unwrap().iter());
+
+        Ok(())
+    }
+}
+
+
+//------------ CertResources -------------------------------------------------
+
+#[derive(Clone, Debug)]
+struct CertResources {
+    /// The AS resources.
+    ///
+    /// A value of `None` means the resources are inherited from the CA.
+    as_resources: Option<AsBlocks>,
+
+    /// The IPv4 resources.
+    ///
+    /// A value of `None` means the resources are inherited from the CA.
+    v4_resources: Option<IpBlocks>,
+
+    /// The IPv6 resources.
+    ///
+    /// A value of `None` means the resources are inherited from the CA.
+    v6_resources: Option<IpBlocks>,
+}
+
+impl CertResources {
+    fn new(cert: &Cert) -> Self {
+        CertResources {
+            as_resources: cert.as_resources().to_blocks().ok(),
+            v4_resources: cert.v4_resources().to_blocks().ok(),
+            v6_resources: cert.v6_resources().to_blocks().ok(),
+        }
+    }
+
+    fn trim_to(&mut self, ca: &CertResources) {
+        if let (Some(my), Some(them)) = (
+            self.as_resources.as_mut(), ca.as_resources.as_ref()
+        ) {
+            my.intersection_assign(them)
+        }
+        if let (Some(my), Some(them)) = (
+            self.v4_resources.as_mut(), ca.v4_resources.as_ref()
+        ) {
+            my.intersection_assign(them)
+        }
+        if let (Some(my), Some(them)) = (
+            self.v6_resources.as_mut(), ca.v6_resources.as_ref()
+        ) {
+            my.intersection_assign(them)
+        }
+    }
+
+    fn trim_to_issuer(&mut self, issuer: &ResourceCert) {
+        if let Some(res) = self.as_resources.as_mut() {
+            res.intersection_assign(issuer.as_resources())
+        }
+        if let Some(res) = self.v4_resources.as_mut() {
+            res.intersection_assign(issuer.v4_resources())
+        }
+        if let Some(res) = self.v6_resources.as_mut() {
+            res.intersection_assign(issuer.v6_resources())
+        }
+    }
+
+    fn verify_issuer(
+        &self, issuer: &ResourceCert
+    ) -> Result<(), ValidationError> {
+        if let Some(res) = self.as_resources.as_ref() {
+            if !issuer.as_resources().contains(res) {
+                return Err(ValidationError)
+            }
+        }
+        if let Some(res) = self.v4_resources.as_ref() {
+            if !issuer.v4_resources().contains(res) {
+                return Err(ValidationError)
+            }
+        }
+        if let Some(res) = self.v6_resources.as_ref() {
+            if !issuer.v6_resources().contains(res) {
+                return Err(ValidationError)
+            }
+        }
+        Ok(())
+    }
+
+    fn replace_inherited(&mut self, ca: &CertResources) {
+        if self.as_resources.is_none() {
+            self.as_resources = ca.as_resources.clone()
+        }
+        if self.v4_resources.is_none() {
+            self.v4_resources = ca.v4_resources.clone()
+        }
+        if self.v6_resources.is_none() {
+            self.v6_resources = ca.v6_resources.clone()
+        }
+    }
+
+    fn replace_inherited_from_issuer(&mut self, ca: &ResourceCert) {
+        if self.as_resources.is_none() {
+            self.as_resources = Some(ca.as_resources().clone())
+        }
+        if self.v4_resources.is_none() {
+            self.v4_resources = Some(ca.v4_resources().clone())
+        }
+        if self.v6_resources.is_none() {
+            self.v6_resources = Some(ca.v6_resources().clone())
+        }
+    }
+
+    fn update_head(&mut self, ca: CertResources) {
+        if let Some(res) = ca.as_resources {
+            self.as_resources = Some(res)
+        }
+        if let Some(res) = ca.v4_resources {
+            self.v4_resources = Some(res)
+        }
+        if let Some(res) = ca.v6_resources {
+            self.v6_resources = Some(res)
+        }
+    }
+}
+
+
 //------------ AttestationBuilder --------------------------------------------
 
 pub struct AttestationBuilder {
@@ -759,10 +1145,10 @@ impl AttestationBuilder {
 
     pub fn into_attestation(self) -> ResourceTaggedAttestation {
         ResourceTaggedAttestation {
-            subject_keys: self.keys.into(),
-            as_resources: self.as_resources.into(),
-            v4_resources: self.v4_resources.into(),
-            v6_resources: self.v6_resources.into(),
+            subject_keys: self.keys,
+            as_resources: self.as_resources.finalize(),
+            v4_resources: self.v4_resources.finalize(),
+            v6_resources: self.v6_resources.finalize(),
             digest_algorithm: self.digest_algorithm,
             message_digest: self.message_digest,
         }
@@ -802,9 +1188,9 @@ impl RtaBuilder {
             digest_algorithm: DigestAlgorithm::default(),
             encoded_content: rta.signed.content.to_bytes(),
             content: rta.content,
-            certificates: rta.signed.certificates.collect_certs(),
-            crls: rta.signed.crls.collect_crls(),
-            signer_infos: rta.signed.signer_infos.collect_signer_infos(),
+            certificates: rta.signed.certificates,
+            crls: rta.signed.crls,
+            signer_infos: rta.signed.signer_infos,
         }
     }
 
@@ -887,9 +1273,9 @@ impl RtaBuilder {
             signed: MultiSignedObject {
                 digest_algorithm: self.digest_algorithm,
                 content: OctetString::new(self.encoded_content),
-                certificates: self.certificates.into(),
-                crls: self.crls.into(),
-                signer_infos: self.signer_infos.into(),
+                certificates: self.certificates,
+                crls: self.crls,
+                signer_infos: self.signer_infos,
             },
             content: self.content,
         }
diff --git a/src/sigobj.rs b/src/sigobj.rs
index d2c94477..f9c619f3 100644
--- a/src/sigobj.rs
+++ b/src/sigobj.rs
@@ -612,17 +612,17 @@ pub struct SignedObjectBuilder {
     /// The IPv4 resources of the EE certificate.
     ///
     /// Defaults to not having any.
-    v4_resources: Option<IpResources>,
+    v4_resources: IpResources,
 
     /// The IPv6 resources of the EE certificate.
     ///
     /// Defaults to not having any.
-    v6_resources: Option<IpResources>,
+    v6_resources: IpResources,
 
     /// The AS resources of the EE certificate.
     ///
     /// Defaults to not having any.
-    as_resources: Option<AsResources>,
+    as_resources: AsResources,
 
     /// The signing time attribute of the signed object.
     ///
@@ -652,9 +652,9 @@ impl SignedObjectBuilder {
             crl_uri,
             ca_issuer,
             signed_object,
-            v4_resources: None,
-            v6_resources: None,
-            as_resources: None,
+            v4_resources: IpResources::missing(),
+            v6_resources: IpResources::missing(),
+            as_resources: AsResources::missing(),
             signing_time: None,
             binary_signing_time: None,
         }
@@ -725,18 +725,18 @@ impl SignedObjectBuilder {
     }
 
     /// Returns a reference to the IPv4 address resources if present.
-    pub fn v4_resources(&self) -> Option<&IpResources> {
-        self.v4_resources.as_ref()
+    pub fn v4_resources(&self) -> &IpResources {
+        &self.v4_resources
     }
 
     /// Set the IPv4 address resources.
-    pub fn set_v4_resources(&mut self, resources: Option<IpResources>) {
+    pub fn set_v4_resources(&mut self, resources: IpResources) {
         self.v4_resources = resources
     }
 
     /// Sets the IPv4 address resources to inherit.
     pub fn set_v4_resources_inherit(&mut self) {
-        self.set_v4_resources(Some(IpResources::inherit()))
+        self.set_v4_resources(IpResources::inherit())
     }
 
     /// Builds the blocks IPv4 address resources.
@@ -748,18 +748,18 @@ impl SignedObjectBuilder {
     }
 
     /// Returns a reference to the IPv6 address resources if present.
-    pub fn v6_resources(&self) -> Option<&IpResources> {
-        self.v6_resources.as_ref()
+    pub fn v6_resources(&self) -> &IpResources {
+        &self.v6_resources
     }
 
     /// Set the IPv6 address resources.
-    pub fn set_v6_resources(&mut self, resources: Option<IpResources>) {
+    pub fn set_v6_resources(&mut self, resources: IpResources) {
         self.v6_resources = resources
     }
 
     /// Sets the IPv6 address resources to inherit.
     pub fn set_v6_resources_inherit(&mut self) {
-        self.set_v6_resources(Some(IpResources::inherit()))
+        self.set_v6_resources(IpResources::inherit())
     }
 
     /// Builds the blocks IPv6 address resources.
@@ -772,22 +772,22 @@ impl SignedObjectBuilder {
 
     /// Returns whether the certificate has any IP resources at all.
     pub fn has_ip_resources(&self) -> bool {
-        self.v4_resources.is_some() || self.v6_resources().is_some()
+        self.v4_resources.is_present() || self.v6_resources().is_present()
     }
 
     /// Returns a reference to the AS resources if present.
-    pub fn as_resources(&self) -> Option<&AsResources> {
-        self.as_resources.as_ref()
+    pub fn as_resources(&self) -> &AsResources {
+        &self.as_resources
     }
 
     /// Set the AS resources.
-    pub fn set_as_resources(&mut self, resources: Option<AsResources>) {
+    pub fn set_as_resources(&mut self, resources: AsResources) {
         self.as_resources = resources
     }
 
     /// Sets the AS resources to inherit.
     pub fn set_as_resources_inherit(&mut self) {
-        self.set_as_resources(Some(AsResources::inherit()))
+        self.set_as_resources(AsResources::inherit())
     }
 
     /// Builds the blocks AS resources.

From fc1dd8b6603bd5760ce8ca667e8753dfac778ba9 Mon Sep 17 00:00:00 2001
From: Martin Hoffmann <martin@nlnetlabs.nl>
Date: Thu, 13 Aug 2020 11:16:56 +0200
Subject: [PATCH 09/19] Add rta::Validation::new_at.

---
 src/rta.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/rta.rs b/src/rta.rs
index a90c8126..0a976526 100644
--- a/src/rta.rs
+++ b/src/rta.rs
@@ -467,7 +467,7 @@ impl SignerInfo {
 }
 
 
-//------------ Validator -----------------------------------------------------
+//------------ Validation ----------------------------------------------------
 
 #[derive(Clone, Debug)]
 pub struct Validation<'a> {
@@ -486,6 +486,12 @@ pub struct Validation<'a> {
 
 impl<'a> Validation<'a> {
     pub fn new(
+        rta: &'a Rta, strict: bool
+    ) -> Result<Self, ValidationError> {
+        Self::new_at(rta, strict, Time::now())
+    }
+
+    pub fn new_at(
         rta: &'a Rta, strict: bool, now: Time,
     ) -> Result<Self, ValidationError> {
         // Get a vec with options of refs to the CRLs. Whenever we used a CRL

From 06f8cbf319f2bbc166c24b9831d38c30ae3f1054 Mon Sep 17 00:00:00 2001
From: Martin Hoffmann <martin@nlnetlabs.nl>
Date: Tue, 18 Aug 2020 15:39:48 +0200
Subject: [PATCH 10/19] Add SignedObject::process.

---
 src/sigobj.rs | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/sigobj.rs b/src/sigobj.rs
index f9c619f3..d8d5cfd9 100644
--- a/src/sigobj.rs
+++ b/src/sigobj.rs
@@ -156,6 +156,19 @@ impl SignedObject {
         })
     }
 
+    pub fn process<F>(
+        self,
+        issuer: &ResourceCert,
+        strict: bool,
+        check_crl: F
+    ) -> Result<OctetString, ValidationError>
+    where F: FnOnce(&Cert) -> Result<(), ValidationError> {
+        let res = self.content.clone();
+        let cert = self.validate(issuer, strict)?;
+        check_crl(cert.as_ref())?;
+        Ok(res)
+    }
+
     /// Validates the signed object.
     ///
     /// Upon success, the method returns the validated EE certificate of the

From 5517a824271fba19f96d3d60b5fe14c7f664c8ba Mon Sep 17 00:00:00 2001
From: Martin Hoffmann <martin@nlnetlabs.nl>
Date: Tue, 18 Aug 2020 15:50:31 +0200
Subject: [PATCH 11/19] Change return type of SignedObject::process.

---
 src/sigobj.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/sigobj.rs b/src/sigobj.rs
index d8d5cfd9..4e755171 100644
--- a/src/sigobj.rs
+++ b/src/sigobj.rs
@@ -161,12 +161,12 @@ impl SignedObject {
         issuer: &ResourceCert,
         strict: bool,
         check_crl: F
-    ) -> Result<OctetString, ValidationError>
+    ) -> Result<Bytes, ValidationError>
     where F: FnOnce(&Cert) -> Result<(), ValidationError> {
         let res = self.content.clone();
         let cert = self.validate(issuer, strict)?;
         check_crl(cert.as_ref())?;
-        Ok(res)
+        Ok(res.into_bytes())
     }
 
     /// Validates the signed object.

From 567918b5e5a3adb3aadfccaccf340f91acdad4f3 Mon Sep 17 00:00:00 2001
From: Martin Hoffmann <martin@nlnetlabs.nl>
Date: Thu, 27 Aug 2020 12:57:45 +0200
Subject: [PATCH 12/19] Add helpers for displaying IP blocks.

---
 src/resources/ipres.rs | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/src/resources/ipres.rs b/src/resources/ipres.rs
index c0414998..0187ed2d 100644
--- a/src/resources/ipres.rs
+++ b/src/resources/ipres.rs
@@ -648,6 +648,16 @@ impl IpBlock {
             IpBlock::Range(range) => range.fmt_v6(f),
         }
     }
+
+    /// Returns an object that sisplays the block as an IPv4 block.
+    pub fn display_v4(self) -> DisplayV4Block {
+        DisplayV4Block(self)
+    }
+
+    /// Returns an object that sisplays the block as an IPv4 block.
+    pub fn display_v6(self) -> DisplayV6Block {
+        DisplayV6Block(self)
+    }
 }
 
 impl IpBlock {
@@ -768,6 +778,27 @@ impl Block for IpBlock {
 }
 
 
+//------------ DisplayV4Block ------------------------------------------------
+
+pub struct DisplayV4Block(IpBlock);
+
+impl fmt::Display for DisplayV4Block {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        self.0.fmt_v4(fmt)
+    }
+}
+
+
+//------------ DisplayV6Block ------------------------------------------------
+
+pub struct DisplayV6Block(IpBlock);
+
+impl fmt::Display for DisplayV6Block {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        self.0.fmt_v6(fmt)
+    }
+}
+
 
 //------------ AddressRange --------------------------------------------------
 

From 56798632c1c7842d9db63a3cb65e83b998292549 Mon Sep 17 00:00:00 2001
From: Martin Hoffmann <martin@nlnetlabs.nl>
Date: Thu, 27 Aug 2020 13:07:07 +0200
Subject: [PATCH 13/19] Introduce the matches macro.

---
 src/resources/choice.rs | 10 ++--------
 src/tal.rs              | 10 ++--------
 src/uri.rs              | 10 ++--------
 3 files changed, 6 insertions(+), 24 deletions(-)

diff --git a/src/resources/choice.rs b/src/resources/choice.rs
index 7ab7ec83..bb80b567 100644
--- a/src/resources/choice.rs
+++ b/src/resources/choice.rs
@@ -29,18 +29,12 @@ pub enum ResourcesChoice<T> {
 impl<T> ResourcesChoice<T> {
     /// Returns whether the resources are of the inherited variant.
     pub fn is_inherited(&self) -> bool {
-        match self {
-            ResourcesChoice::Inherit => true,
-            _ =>  false
-        }
+        matches!(self, ResourcesChoice::Inherit)
     }
 
     /// Returns whether the resources are present.
     pub fn is_present(&self) -> bool {
-        match self {
-            ResourcesChoice::Missing => false,
-            _ => true
-        }
+        !matches!(self, ResourcesChoice::Missing)
     }
 
     /// Converts the resources into blocks or returns an error.
diff --git a/src/tal.rs b/src/tal.rs
index c751b63b..3d9f9480 100644
--- a/src/tal.rs
+++ b/src/tal.rs
@@ -184,17 +184,11 @@ impl TalUri {
     }
 
     pub fn is_rsync(&self) -> bool {
-        match *self {
-            TalUri::Rsync(_) => true,
-            _ => false,
-        }
+        matches!(*self, TalUri::Rsync(_))
     }
 
     pub fn is_https(&self) -> bool {
-        match *self {
-            TalUri::Https(_) => true,
-            _ => false
-        }
+        matches!(*self, TalUri::Https(_))
     }
 }
 
diff --git a/src/uri.rs b/src/uri.rs
index 332b5602..bb08eecb 100644
--- a/src/uri.rs
+++ b/src/uri.rs
@@ -606,17 +606,11 @@ impl Scheme {
     }
 
     pub fn is_https(self) -> bool {
-        match self {
-            Scheme::Https => true,
-            _ => false
-        }
+        matches!(self, Scheme::Https)
     }
 
     pub fn is_rsync(self) -> bool {
-        match self {
-            Scheme::Rsync => true,
-            _ => false
-        }
+        matches!(self, Scheme::Rsync)
     }
 
     pub fn as_str(self) -> &'static str {

From 28437b2d3d5c75601a519e0fe7e7734d9325e036 Mon Sep 17 00:00:00 2001
From: Martin Hoffmann <martin@nlnetlabs.nl>
Date: Thu, 27 Aug 2020 13:12:29 +0200
Subject: [PATCH 14/19] Update minimal Rust version to 1.42.

---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 6de15939..56480744 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -7,7 +7,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest, macOS-latest]
-        rust: [1.40.0, stable, beta, nightly]
+        rust: [1.42.0, stable, beta, nightly]
     steps:
     - name: Checkout repository
       uses: actions/checkout@v1

From 4ed6adce5f2c42f704173280ec16337003e2c0c1 Mon Sep 17 00:00:00 2001
From: Martin Hoffmann <martin@nlnetlabs.nl>
Date: Thu, 27 Aug 2020 13:18:28 +0200
Subject: [PATCH 15/19] Update changelog.

---
 Changelog.md | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/Changelog.md b/Changelog.md
index c98f39d6..9e5ddbb5 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -4,16 +4,23 @@
 
 Breaking
 
+* The minimum required Rust version is now 1.42. ([#108])
+
 Bug Fixes
 
 New
 
-* Module `rta` for handling Resource Tagged Assertions.
+* Module `rta` for handling Resource Tagged Assertions.  ([#108])
 * `crypto::DigestAlgorithm::digest_file` allows calculating the digest
-  value of an entire file.
+  value of an entire file.  ([#108])
+* `IpBlock` can now be displayed via helper types to select IPv4 or IPv6.
+  ([#108])
+* `SignedObject::process` to validate generic signed objects and return
+  their content on success. ([#108])
 
 Dependencies
 
+[#108]: https://github.com/NLnetLabs/rpki-rs/pull/106
 
 # 0.9.2
 

From 1d2b8cea00fd3f94732108ed48a9094ee8642722 Mon Sep 17 00:00:00 2001
From: Martin Hoffmann <martin@nlnetlabs.nl>
Date: Wed, 2 Sep 2020 16:53:35 +0200
Subject: [PATCH 16/19] =?UTF-8?q?Add=20version=20to=20multi-signed=20objec?=
 =?UTF-8?q?t=E2=80=99s=20SignerInfo=20encoding.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/rta.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/rta.rs b/src/rta.rs
index 0a976526..15991220 100644
--- a/src/rta.rs
+++ b/src/rta.rs
@@ -339,13 +339,13 @@ impl MultiSignedObject {
     fn take_crls<S: decode::Source>(
         cons: &mut decode::Constructed<S>, _strict: bool
     ) -> Result<Vec<Crl>, S::Err> {
-        cons.take_constructed_if(Tag::CTX_1, |cons| {
+        cons.take_opt_constructed_if(Tag::CTX_1, |cons| {
             let mut crls = Vec::new();
             while let Some(crl) = Crl::take_opt_from(cons)? {
                 crls.push(crl);
             }
             Ok(crls)
-        })
+        }).map(|item| item.unwrap_or_default())
     }
 
     fn take_signer_infos<S: decode::Source>(
@@ -453,6 +453,7 @@ impl SignerInfo {
 
     pub fn encode_ref<'a>( &'a self) -> impl encode::Values + 'a {
         encode::sequence((
+            3u8.encode(), // version
             self.sid.encode_ref_as(Tag::CTX_0),
             self.digest_algorithm.encode(), // digestAlgorithm
             self.signed_attrs.encode_ref(), // signedAttrs

From 784226e08aeb65e5f358303744380382534aa479 Mon Sep 17 00:00:00 2001
From: Martin Hoffmann <martin@nlnetlabs.nl>
Date: Mon, 7 Sep 2020 14:18:21 +0200
Subject: [PATCH 17/19] Introduce new category of certificates: detached EE
 certs.

---
 src/cert/mod.rs | 56 ++++++++++++++++++++++++++++++++++++++++++++++---
 src/rta.rs      | 23 ++++++++++----------
 2 files changed, 64 insertions(+), 15 deletions(-)

diff --git a/src/cert/mod.rs b/src/cert/mod.rs
index 2115858c..6f562e38 100644
--- a/src/cert/mod.rs
+++ b/src/cert/mod.rs
@@ -244,6 +244,24 @@ impl Cert {
         self.verify_ee(issuer, strict)
     }
 
+    pub fn validate_detached_ee(
+        self,
+        issuer: &ResourceCert,
+        strict: bool
+    ) -> Result<ResourceCert, ValidationError>  {
+        self.validate_detached_ee_at(issuer, strict, Time::now())
+    }
+
+    pub fn validate_detached_ee_at(
+        self,
+        issuer: &ResourceCert,
+        strict: bool,
+        now: Time,
+    ) -> Result<ResourceCert, ValidationError>  {
+        self.inspect_detached_ee_at(strict, now)?;
+        self.verify_ee(issuer, strict)
+    }
+
 
     //--- Inspection
 
@@ -309,13 +327,13 @@ impl Cert {
 
         // 4.8.1. Basic Constraints: Must not be present.
         if self.basic_ca.is_some(){
-            return Err(ValidationError)
+            xerr!(return Err(ValidationError))
         }
 
         // 4.8.4. Key Usage. Bits for CA or not CA have been checked during
         // parsing already.
         if self.key_usage != KeyUsage::Ee {
-            return Err(ValidationError)
+            xerr!(return Err(ValidationError))
         }
 
         // 4.8.8.  Subject Information Access. We need the signed object
@@ -323,7 +341,39 @@ impl Cert {
         if self.ca_repository.is_some() || self.rpki_manifest.is_some()
             || self.signed_object.is_none()
         {
-            return Err(ValidationError)
+            xerr!(return Err(ValidationError))
+        }
+
+        Ok(())
+    }
+
+    pub fn inspect_detached_ee(
+        &self, strict: bool
+    ) -> Result<(), ValidationError> {
+        self.inspect_detached_ee_at(strict, Time::now())
+    }
+
+    pub fn inspect_detached_ee_at(
+        &self, strict: bool, now: Time
+    ) -> Result<(), ValidationError> {
+        self.inspect_basics(strict, now)?;
+        self.inspect_issued(strict)?;
+
+        // 4.8.1. Basic Constraints: Must not be present.
+        if self.basic_ca.is_some(){
+            xerr!(return Err(ValidationError))
+        }
+
+        // 4.8.4. Key Usage. Bits for CA or not CA have been checked during
+        // parsing already.
+        if self.key_usage != KeyUsage::Ee {
+            xerr!(return Err(ValidationError))
+        }
+
+        // 4.8.8.  Subject Information Access. We allow the signed object one
+        // but not the other ones.
+        if self.ca_repository.is_some() || self.rpki_manifest.is_some() {
+            xerr!(return Err(ValidationError))
         }
 
         Ok(())
diff --git a/src/rta.rs b/src/rta.rs
index 15991220..05e67344 100644
--- a/src/rta.rs
+++ b/src/rta.rs
@@ -519,7 +519,7 @@ impl<'a> Validation<'a> {
         let mut ees = Vec::new();
         for cert in &rta.signed.certificates {
             if cert.basic_ca().is_none() {
-                cert.inspect_ee_at(strict, now)?;
+                cert.inspect_detached_ee_at(strict, now)?;
                 ees.push(Some(cert));
             }
             else {
@@ -536,17 +536,17 @@ impl<'a> Validation<'a> {
 
         // All subject keys need to have been used.
         if keys.iter().any(|item| item.is_some()) {
-            return Err(ValidationError)
+            xerr!(return Err(ValidationError))
         }
 
         // All CRLs need to have been used.
         if crls.iter().any(|item| item.is_some()) {
-            return Err(ValidationError)
+            xerr!(return Err(ValidationError))
         }
 
         // All EE certificates have to have been used.
         if ees.iter().any(|item| item.is_some()) {
-            return Err(ValidationError)
+            xerr!(return Err(ValidationError))
         }
 
         // Create the object and advance the chains using the CA certificates
@@ -554,10 +554,9 @@ impl<'a> Validation<'a> {
         let mut res = Validation { rta, chains, strict, now };
         res.advance_chains(&mut cas)?;
 
-
         // All the CA certificates have to have been used.
         if cas.iter().any(|item| !item.used) {
-            return Err(ValidationError)
+            xerr!(return Err(ValidationError))
         }
 
         // Hurray!
@@ -698,12 +697,12 @@ impl<'a> Chain<'a> {
         // Find and removed sid in keys.
         match keys.iter_mut().find(|item| **item == Some(info.sid)) {
             Some(item) => *item = None,
-            None => return Err(ValidationError)
+            None => xerr!(return Err(ValidationError))
         }
 
         // Verify the message digest attribute
         if digest.as_ref() != info.message_digest.as_ref() {
-            return Err(ValidationError)
+            return xerr!(Err(ValidationError))
         }
 
         // Find th EE cert that signed this signer info.
@@ -737,7 +736,7 @@ impl<'a> Chain<'a> {
 
             }
         }
-        Err(ValidationError)
+        xerr!(Err(ValidationError))
     }
 
     //--- advance and helpers
@@ -777,7 +776,7 @@ impl<'a> Chain<'a> {
             return Ok(Some(ca))
         }
         if found {
-            Err(ValidationError)
+            xerr!(Err(ValidationError))
         }
         else {
             Ok(None)
@@ -787,7 +786,7 @@ impl<'a> Chain<'a> {
     fn apply_ca(&mut self, ca: &Ca<'a>) -> Result<(), ValidationError> {
         // Check that our cert hasn’t been revoked.
         if ca.crl.contains(self.cert.serial_number()) {
-            return Err(ValidationError)
+            xerr!(return Err(ValidationError))
         }
 
         // Check if the CA allows us to have our resources.
@@ -908,7 +907,7 @@ impl<'a> Chain<'a> {
             self.cert.inspect_ca_at(strict, now)?;
         }
         else {
-            self.cert.inspect_ee_at(strict, now)?;
+            self.cert.inspect_detached_ee_at(strict, now)?;
         }
 
         // Finally, resources. If they don’t check out, we can error out ...

From 4fb6a09e11987ae684454e343cecc442f7174ee5 Mon Sep 17 00:00:00 2001
From: Martin Hoffmann <martin@nlnetlabs.nl>
Date: Mon, 7 Sep 2020 14:35:48 +0200
Subject: [PATCH 18/19] Take used EE certs out of the RTA certificates list.

---
 src/rta.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/rta.rs b/src/rta.rs
index 05e67344..0dcfcf80 100644
--- a/src/rta.rs
+++ b/src/rta.rs
@@ -722,8 +722,8 @@ impl<'a> Chain<'a> {
         ees: &mut [Option<&'a Cert>]
     ) -> Result<&'a Cert, ValidationError> {
         let msg = info.signed_attrs.encode_verify();
-        for cert in ees {
-            if let Some(cert) = *cert {
+        for item in ees {
+            if let Some(cert) = *item {
                 if cert.subject_key_identifier() != info.sid {
                     continue
                 }
@@ -733,8 +733,10 @@ impl<'a> Chain<'a> {
                 ).is_err() {
                     continue
                 }
-
+                *item = None;
+                return Ok(cert)
             }
+
         }
         xerr!(Err(ValidationError))
     }

From d4fe1e9c4f6f67214578577a67a8100ddad35eeb Mon Sep 17 00:00:00 2001
From: Martin Hoffmann <martin@nlnetlabs.nl>
Date: Mon, 7 Sep 2020 16:39:18 +0200
Subject: [PATCH 19/19] Update changelog.

---
 Changelog.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Changelog.md b/Changelog.md
index 326843fb..421bb0ac 100644
--- a/Changelog.md
+++ b/Changelog.md
@@ -22,11 +22,13 @@ New
   ([#108])
 * `SignedObject::process` to validate generic signed objects and return
   their content on success. ([#108])
+* The various steps in certificate validation are now available as
+  separate methods. ([#108])
 
 Dependencies
 
 [#105]: https://github.com/NLnetLabs/rpki-rs/pull/105
-[#108]: https://github.com/NLnetLabs/rpki-rs/pull/106
+[#108]: https://github.com/NLnetLabs/rpki-rs/pull/108
 [#109]: https://github.com/NLnetLabs/rpki-rs/pull/109