Method derive

src/dnscrypt_certs.rs:49–112

Derive the PQ parameters from the classical resolver key seed and the provider signing key, reusing the classical window's serial and dates.

(
        provider_kp: &SignKeyPair,
        resolver_sk_seed: &[u8; 32],
        serial: u32,
        ts_start: u32,
        ts_end: u32,
    )

    /// Derive the PQ parameters from the classical resolver key seed and the
    /// provider signing key, reusing the classical window's serial and dates.
    fn derive(
        provider_kp: &SignKeyPair,
        resolver_sk_seed: &[u8; 32],
        serial: u32,
        ts_start: u32,
        ts_end: u32,
    ) -> Self {
        let mut seed_input = Vec::with_capacity(19 + 32);
        seed_input.extend_from_slice(b"DNSCrypt-PQ-seed-v1");
        seed_input.extend_from_slice(resolver_sk_seed);
        let xwing_seed = pq::sha256(&seed_input);
        let keypair = pq::XWingKeyPair::from_seed(xwing_seed);
        let resolver_pk = keypair.public_key_bytes();

        let mut client_magic = [0u8; 8];
        client_magic.copy_from_slice(&pq::sha256(&resolver_pk)[..8]);
        if client_magic[..7] == [0u8; 7] || client_magic == pq::PQ_RESUME_MAGIC {
            client_magic[0] ^= 0xff;
        }

        let extensions = pq::profile_extension();
        let serial_be = serial.to_be_bytes();
        let ts_start_be = ts_start.to_be_bytes();
        let ts_end_be = ts_end.to_be_bytes();

        let mut signed = Vec::with_capacity(pq::XWING_PK_SIZE + 8 + 4 + 4 + 4 + extensions.len());
        signed.extend_from_slice(&resolver_pk);
        signed.extend_from_slice(&client_magic);
        signed.extend_from_slice(&serial_be);
        signed.extend_from_slice(&ts_start_be);
        signed.extend_from_slice(&ts_end_be);
        signed.extend_from_slice(&extensions);
        let signature = provider_kp.sk.sign(&signed);

        let mut cert_bytes = Vec::with_capacity(PQ_CERT_LEN);
        cert_bytes.extend_from_slice(&[0x44, 0x4e, 0x53, 0x43]);
        cert_bytes.extend_from_slice(&pq::PQ_ES_VERSION);
        cert_bytes.extend_from_slice(&[0x00, 0x00]);
        cert_bytes.extend_from_slice(signature.as_bytes());
        cert_bytes.extend_from_slice(&signed);
        debug_assert_eq!(cert_bytes.len(), PQ_CERT_LEN);

        // The HKDF context and the extension hash are fixed for the lifetime of
        // a certificate window, so derive them once here rather than on every
        // query.
        let cert_context = pq::cert_context(
            &pq::PQ_ES_VERSION,
            &[0x00, 0x00],
            &resolver_pk,
            &client_magic,
            &serial_be,
            &ts_start_be,
            &ts_end_be,
            &extensions,
        );
        let profile_extension_hash = pq::sha256(&extensions);

        PqParams {