pub(super) fn blinded_id(&self) -> HsBlindId {

        let ident = self

            .desc_signing_key_cert

            .signing_key()

            .expect("signing key was absent!?");

        (*ident).into()

    }

    pub(super) fn desc_sign_key_id(&self) -> &Ed25519Identity {

        self.desc_signing_key_cert

            .subject_key()

            .as_ed25519()

            .expect(

                "Somehow constructed an HsDescOuter with a non-Ed25519 signing key in its cert.",

            )

    }

    pub(super) fn revision_counter(&self) -> RevisionCounter {

        self.revision_counter

    }

    pub(super) fn decrypt_body(

        &self,

        subcredential: &Subcredential,

    ) -> std::result::Result<Vec<u8>, desc_enc::DecryptionError> {

        let decrypt = desc_enc::HsDescEncryption {

            blinded_id: &self.blinded_id(),

            desc_enc_nonce: None,

            subcredential,

            revision: self.revision_counter,

            string_const: b"hsdir-superencrypted-data",

        };

        let mut body = decrypt.decrypt(&self.superencrypted[..])?;

        let n_padding = body.iter().rev().take_while(|n| **n == 0).count();

        body.truncate(body.len() - n_padding);

        // Work around a bug in the C tor implementation: it doesn't

        // NL-terminate the final line of the middle document.

        if !body.ends_with(b"\n") {

            body.push(b'\n');

        }

        Ok(body)

    }

static HS_OUTER_RULES: Lazy<SectionRules<HsOuterKwd>> = Lazy::new(|| {

    let mut rules = SectionRules::builder();

    rules.add(HS_DESCRIPTOR.rule().required().args(1..));

    rules.add(DESCRIPTOR_LIFETIME.rule().required().args(1..));

    rules.add(DESCRIPTOR_SIGNING_KEY_CERT.rule().required().obj_required());

    rules.add(REVISION_COUNTER.rule().required().args(1..));

    rules.add(SUPERENCRYPTED.rule().required().obj_required());

    rules.add(SIGNATURE.rule().required().args(1..));

    rules.add(UNRECOGNIZED.rule().may_repeat().obj_optional());

    rules.build()

});

    #[cfg_attr(feature = "hsdesc-inner-docs", visibility::make(pub))]

    pub(super) fn parse(s: &str) -> Result<UncheckedHsDescOuter> {

        // TOSO HS needs to be unchecked.

        let mut reader = NetDocReader::new(s);

        let result = HsDescOuter::take_from_reader(&mut reader).map_err(|e| e.within(s))?;

        Ok(result)

    }

    fn take_from_reader(reader: &mut NetDocReader<'_, HsOuterKwd>) -> Result<UncheckedHsDescOuter> {

        let s = reader.str();

        let body = HS_OUTER_RULES.parse(reader)?;

        let signed_text = {

            let first_item = body

                .first_item()

                .expect("Somehow parsing worked though no keywords were present‽");

            let last_item = body

                .last_item()

                .expect("Somehow parsing worked though no keywords were present‽");

            if first_item.kwd() != HS_DESCRIPTOR {

            }

            if last_item.kwd() != SIGNATURE {

            }

            let start_idx = first_item

                .pos()

                .offset_within(s)

                .expect("Token came from nowhere within the string‽");

            let end_idx = last_item

                .pos()

                .offset_within(s)

                .expect("Token came from nowhere within the string‽");

            // TODO: This way of handling prefixes does a needless

            // allocation. Someday we could make our signature-checking

            // logic even smarter.

            let mut signed_text = HS_DESC_SIGNATURE_PREFIX.to_vec();

            signed_text.extend_from_slice(

                s.get(start_idx..end_idx)

                    .expect("Somehow the first item came after the last‽")

                    .as_bytes(),

            );

            signed_text

            let version = body.required(HS_DESCRIPTOR)?.required_arg(0)?;

            if version != HS_DESC_VERSION_CURRENT {

            }

        let lifetime: IntegerMinutes<u16> = {

            let tok = body.required(DESCRIPTOR_LIFETIME)?;

            let lifetime_minutes: u16 = tok.parse_arg(0)?;

            if !(30..=720).contains(&lifetime_minutes) {

            }

            lifetime_minutes.into()

        let (unchecked_cert, kp_desc_sign) = {

            let cert_tok = body.required(DESCRIPTOR_SIGNING_KEY_CERT)?;

            let cert = cert_tok

                .parse_obj::<UnvalidatedEdCert>("ED25519 CERT")?

                .check_cert_type(tor_cert::CertType::HS_BLINDED_ID_V_SIGNING)?

                .into_unchecked()

                .should_have_signing_key()

                .map_err(|err| {

                })?;

            let kp_desc_sign: ed25519::PublicKey = cert

                .peek_subject_key()

                .as_ed25519()

                .and_then(|id| id.try_into().ok())

                .ok_or_else(|| {

                })?;

            (cert, kp_desc_sign)

        let revision_counter = body.required(REVISION_COUNTER)?.parse_arg::<u64>(0)?.into();

        let encrypted_body: Vec<u8> = body.required(SUPERENCRYPTED)?.obj("MESSAGE")?;

        let signature = body

            .required(SIGNATURE)?

            .parse_arg::<B64>(0)?

            .into_array()

            .map_err(|_| EK::BadSignature.with_msg("Bad signature object length"))?;

        let signature = ed25519::Signature::from(signature);

        let (desc_signing_key_cert, cert_signature) = unchecked_cert

            .dangerously_split()

            // we already checked that there is a public key, so an error should be impossible.

            .map_err(|e| EK::Internal.err().with_source(e))?;

        let desc_signing_key_cert = desc_signing_key_cert.dangerously_assume_timely();

        // NOTE: the C tor implementation checks this expiration time, so we must too.

        let expiration = desc_signing_key_cert.expiry();

        // Build our return value.

        let desc = HsDescOuter {

            lifetime,

            desc_signing_key_cert,

            revision_counter,

            superencrypted: encrypted_body,

        };

        // You can't have that until you check that it's timely.

        let desc = TimerangeBound::new(desc, ..expiration);

        // And you can't have _that_ until you check the signatures.

        let signatures: Vec<Box<dyn tor_llcrypto::pk::ValidatableSignature>> = vec![

            Box::new(cert_signature),

            Box::new(ValidatableEd25519Signature::new(

                kp_desc_sign,

                signature,

                &signed_text[..],

            )),

        ];

        Ok(SignatureGated::new(desc, signatures))

    }