Add the standard uniffi-bindgen bin target

Expose uniffi bindings for building and verifying proofs

Bump crate version for new `Clone` impl

Derive `Clone` for `ProofBuilder`

Filter using `VerifiedRRStream::resolve_name` in wasm

When resolving a name in WASM we should let `resolve_name` handle
C/DNAMEs, which we do here.

Bump version to 0.5.2 for dropping ring dep

Iteratively hash rather than building a vec then hashing

... in signature checking.

Now that we control the signature checking API, we don't have to
pass a full buffer and can build our own hashes, avoiding the
allocation.

Make `write_u16_len_prefixed_data` generic over the type of output

In the next commit this will be used to write RRs directly into
hashers when validating signatures, rather than serializing them
into `Vec`s then hashing.

Add the wycheproof test cases for our crypto implementation

Swap `ring` for our own in-crate ECDSA validator

While `ring` is great, it struggles with platform support and has a
fairly involved dependency tree due to its reliance on C backends.

Further, while the `RustCrypto` org tries to stick to Rust, in
doing so it takes on more (unnecessary) dependencies and has a
particularly unusable MSRV policy. Finally, its contributor base
has historically not been particularly friendly.

Thus, sadly, there's not really a good option for doing ECDSA (non-
secp256k1) validation using a third-party crate.

Instead, we go our own way here, adding an in-crate ECDSA
validator over secp{256,384}r1.

This also adds a new bench, showing our secp256r1 validation is,
sadly, something like 50x slower than OpenSSL.

Add U256/U384 and mod-const-prime wrapper utilities of both.

In the next commit we'll add support for secp256r1 and secp384r1
validation, which require 256-bit and 384-bit integers. To make
their implementation simple, we also add wrapper structs around
the new integers which are modulo a const-prime, storing and
handling the values in montgommery representation.

Add a simple benchmark of 2048-bit RSA validation

This shows our RSA is only roughly 3.5x slower than OpenSSL.

Swap `ring` for our own in-crate RSA validator

While `ring` is great, it struggles with platform support and has a
fairly involved dependency tree due to its reliance on C backends.

Further, while the `RustCrypto` org tries to stick to Rust, in
doing so it takes on more (unnecessary) dependencies and has a
particularly unusable MSRV policy. Finally, its contributor base
has historically not been particularly friendly.

Thus, sadly, there's not really a good option for doing RSA
validation using a third-party crate.

Instead, we go our own way here, adding an in-crate RSA validator.

Add a relatively simple mostly-const-fn bigint math implementation

While `ring` is great, it struggles with platform support and has a
fairly involved dependency tree due to its reliance on C backends.

Further, while the `RustCrypto` org tries to stick to Rust, in
doing so it takes on more (unnecessary) dependencies and has a
particularly unusable MSRV policy. Finally, its contributor base
has historically not been particularly friendly.

Thus, sadly, there's not really a good option for doing RSA
validation using a third-party crate.

Instead, in the next commit we'll go our own way and add an
in-crate RSA validator. This takes the first step, adding a bigint
implementation that works up to 4096 bits (the longest allowed RSA
keys in the DNS).

Sadly, once we get to EC math we'll really want most of our math
operations to be const fns, which provides some additional limits.
Absent a better way to do subslicing on rustc 1.63, this commit
introduces a dependency on the `const_slice_from_raw_parts`
feature, which appears to work fine on 1.63 with
`RUSTC_BOOTSTRAP=1` set, and was stabilized in 1.64.

Enable (minimal) optimization in tests

As of the next commit, our tests now have to do in-crate crypto, so
even minimal optimization provide a huge speedup.

Test fuzzers build and release build in test.sh

Add support back for SHA-384 DS records

While these are relatively unused, support for SHA-384 was recently
added in `bitcoin_hashes`, which we use here for DS validation.

Move RRSig loop to after DS loop to be more mindful of KeyTrap

In general we were mostly fine regarding KeyTrap, as we largely
fail after any invalid signature and only loop if a signature or
key required an unknown algorithm. Thus, addressing KeyTrap is
mostly an exercise in adding comments.

However, we did verify all DS hashes every time we went to verify
a single DNSKey RRSig, which is potentially some work, which we
fix here, leading to a nice simplification in `verify_rr_stream`.

Bump version for NSEC/3 validation

Add new tests to test NSEC validation behavior

Drop NSEC/3 records from `VerifiedRRStream::verified_rrs`

`verified_rrs` is intended to include only the records a user may
want, not signatures and proof records. Thus, like we remove
RRSIG/DS records, here we also remove NSEC/3 records.

Validate NSec/3 records prove non-existence when handling C/DNAMEs

When handling C/DNAME RRs we're required to validate that NSEC/3
records exist proving non-existence of the sought record itself. We
do this here.

Refresh existing test data and add NSEC/3 records

This refreshes all our existing test vectors to use new timestamps,
as well as including the newly-required NSEC/3 records.

Add base32 parser which is needed for NSEC3 validation

Correct `NSecTypeMask::contains_type` and add `from_types` builder

The low-bit-masking in `NSecTypeMask::contains_type` was incorrect,
leading to spuriously looking at the wrong bit position within the
correct byte.

While we're at it, we also add a new constructor which allows for
bits to be set.

Use `bitcoin_hashes` rather than `ring` for hashing

While `ring` is great, it struggles with platform support and has a
fairly involved dependency tree due to its reliance on C backends.

Further, while the `RustCrypto` org tries to stick to Rust, in
doing so it takes on more (unnecessary) dependencies and has a
particularly unusable MSRV policy. Finally, its contributor base
has historically not been particularly friendly.

Thus, for the best platform support, we'd like to avoid both. Here
we take the first of several steps towards that goal, using
`bitcoin_hashes` for our SHA-1/SHA-2 operations instead.

Bump version for NSEC/3 record type additions and proof inclusion

Include any relevant NSec/NSec3 records in generated proofs

Add de/serialization and structs for NSec and NSec3 records

Define a util method to convert a type value to the type's name

Add debug checks that we don't leave data behind after an RR

Refuse to include \s in the JSON output of a TXT record

Force all names to lowercase ASCII as it is the canonical form

Add trivial helper method to get the label count in a `Name`

Bump version number for DNAME support

Swap test domain to something more sustainable

Add support for DNAME resolution

Add note about DoH proof building usage.

Bump version for bug fixes and new query APIs

Add WASM/JS support for doing full lookups using DoH

Expose `QueryBuf` constructors and utilities

Add a fuzzer of the proof building state machine

Avoid allocating for all message buffers, expose querying in no-std

Use (and expose) a `ProofBuilder` state machine for proving

This will allow us to expose the state machine we use for building
proofs in, eg, javascript, allowing the construction of proofs
using DoH.

Expose constants for various supported record wire types

Implement Display for Name

Add a parse + validate fuzzer

Add fuzzing of DNS server response parsing

Limit recursion when reading name labels from other packet data

This fixes an infinite recursion issue where a label can refer to
itself and recurse until the stack ie exhausted.

Fix overflowing subtract in vec preallocation

If a TXT record comes in with zero length data, we'll overflow in
the subtraction and try to allocate much too much data.

Note lack of proof verification in query method docs

Bump version for cross-zone CNAME proofs and new util method

Correct cross-zone CNAME handling in proof generation

Fix various test runs in `test.sh`

Add testing of doc links in test.sh

Add a utility function to resolve CNAMEs in verified RRs

Bump version for SHA-1 validation

Set a cache-control header on valid responses

Allow validating SHA1 DS records

While these really shouldn't be used, they sometimes are, and
importantly we don't allow them for RRSig signature validation,
ensuring that if we find a SHA1 DS record it really is what was
meant in the parent zone and wasn't forged.

Bump version mostly for docs.rs to display all methods

Enable all features for docs.rs builds

Reject names containing "s

Add JSON writing of records, primarily for the WASM verifier

Bump release version for various cleanups

Clean up some comments

Add WASM validation library

Return early if we get a response with no answers

Include an octet-stream header/CORS headers in proof responses

Accept query names by reference for downstream flexibility

Feature-gate validation and document crate features

Bump version to 0.3.2 for bug fixes

Make HTTP server large-req DoS safe rather than using a frontend

Correct TXT sort order on unlikely edge cases

Correct length calculation when writing TXT records

Bump version for bug fixes

Correct TXT record sort order

Correct proof validation for records at a zone root

Correct proof building for records at a zone root

Include the resolver-provided TTL in the response

impl Debug/Clone on VerifiedRRStream

Add test script

Bump version now that we're (relatively) feature-complete

Clean up documentation TODO

Add trivial HTTP server which serves proofs

Move validation into a validation module, rather than crate root

Marginally resolve time rollovers, giving us until 2133

Return the time bounds on validated RR sets

Bump version to 0.2 as we now have full proof building support

Enable querying async using tokio

Add support for building proofs using a local recursive resolver

Add support for parsing compressed names out of wire packets

Add support for A/AAAA/NS records

Split the library into three modules for maintainability

Add support for wildcard validation

Add support for CNAME resource records

Support returning verified RRs from multiple zones at once.

Fix repository link

Shuffle the ordering of RRs when validating an RR stream in tests

RFC 9102 explicitly states that RRs in an RR stream can appear in
any order, so we should test that.

Add license and Cargo metadata

Initial checkin