diff --git a/.github/workflows/interop.yml b/.github/workflows/interop.yml index e1474920..7be1d87c 100644 --- a/.github/workflows/interop.yml +++ b/.github/workflows/interop.yml @@ -95,7 +95,13 @@ jobs: matrix: alice: [rage, age] bob: [rage, age] - recipient: [x25519, ssh-rsa, ssh-ed25519] + recipient: [x25519, tag, tagpq, ssh-rsa, ssh-ed25519] + include: + - identity: true + - recipient: tag + identity: false + - recipient: tagpq + identity: false fail-fast: false steps: @@ -131,6 +137,18 @@ jobs: - name: Set the corresponding age x25519 recipient if: matrix.recipient == 'x25519' run: echo "AGE_PUBKEY=-r age1y8m84r6pwd4da5d45zzk03rlgv2xr7fn9px80suw3psrahul44ashl0usm" >> $GITHUB_ENV + - name: Save the age tag recipient + if: matrix.recipient == 'tag' + run: echo "age1tag1qt8lw0ual6avlwmwatk888yqnmdamm7xfd0wak53ut6elz5c4swx2yqdj4e" >key.txt.pub + - name: Set the age tag recipient + if: matrix.recipient == 'tag' + run: echo "AGE_PUBKEY=-r age1tag1qt8lw0ual6avlwmwatk888yqnmdamm7xfd0wak53ut6elz5c4swx2yqdj4e" >> $GITHUB_ENV + - name: Save the age tagpq recipient + if: matrix.recipient == 'tagpq' + run: echo "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" >key.txt.pub + - name: Set the age tagpq recipient + if: matrix.recipient == 'tagpq' + run: echo "AGE_PUBKEY=-r age1tagpq1m3e4wvp6hzcrn9exhy0ae3xfx2sjymp594k3tg7j4dpmj922we65vtnmrt2pyallax8669zqkr2pmfchptr4n38kug2xmcmp3adk2lnjqu00x5kxz5pvhmrltvfh9wuq973pcx35cnq8syn9qd3tzpehgztl4xpzr3tpd67g8af9trnjpc05gh7wu536aq4qt2y8zhsm4tvrfpsfl36qs5fpzysnk3sp9w77qzeg49357xex40v4s2lvt620swyys7u8yxdcnu4rkkwxdmt55gsuc3h5c5swahnegjgqwc60hn085ec3sjztwm45l44y3j2at9t6v9zra4ek3kek6waecqm98yaxl37w0d2zra626nz63jdm5sg59w7lyptw83zm6fntd8d0x03a9z6h9prfgpygzar6zrxjcrt4cdctk2mhf95s4a6v4zklfd49xhpsaeujm57thx2x3e3hwzc86ftfhmq5mkxxz3d6r8ws24xj4qfn73eyezg2wy094e3why592pghz27ruq3vkyegrv80eftnw9wqzwgvnwyseaus0yt84fylzrpzp6x2fguxuqjmgudr8xd33qm30evdpxd3jvjg8qh4q60kyq80jgff369k7nrepdc38grd2dava520excqp0ey0x39khx8ry03yffcatgv84fsx5j49djpapedsy693zute5xv5g2ewzrlj5se7akvkc4g4vmzhputpq8eyj9wz5dz6qtn7g3cfpd95nahw4ytspan0feyye04dcylv24ege7zkaj004gjwcxqxfqu2quawa83sx452jqjn8t48czp0xspwgnmvjyhttzzy6nhq8xzkdwnvsfefkwva6asrqc93zjn4rly5gnlv93xy3uzmr39szvjnf63426qzyeyvguc4vdcquwgsxgq236afcpqz866ny4tn7ckc0umefj242rt5vtvwqzzrvfev2mpvqcufp9pqvefyv4ftyuhgausfzuaadsczeykmft5wv3frzgrcp9ztr93h478ke4t86spp2uhyjkj73mp9g92ddk2fpv7v3njzsqgwhq3789sqrgkskehn0zjscckhwftyq4vet7vrlx2hs5kd9cwnq6t0djffhh3zquh4j3p0yaj9z2rc9wykg0usqw7983rrgur9jg8rnnqypwcz2lyclnnc705fc5g3an93ps60q6mxqp85u0ewtxdjlqcks84yduft0a0g6e7naew3v9u2d08knarvajn8q3gq9pgxde3s7nx94lus48wwvw2xjm7k82tvylec2393jdsuvch2xpe77w8hpv9nvsxfsrs270njpmfvpmgyk2cffl9tjp3qqcc4dfkf5rme2dg0x7ew8g39www5smm705q5da4eqvnqwrkavtq6xje9ss38hnkglz4eddz8f5qruvqmq2ff9l22gwkv8h432rdkysy0grkul8e2fedvkyyapfxt760udcgu92m54wl9yavmj4ga3ph9r5n99cjrq6wj5v33x33fe5vkjvfwnnt40wuv2hyexc9f4ylyqv9ldqq9epd4yuv8vrsfx2qy2kqz08kqhnzspy6s0x8fa5c2xkg5y2q0rvz4vnk7rp0acg6eksc3t7cxnn8y7glkjsqja3p56uz6vvhcw55d3ysad0hvsqxpjnc7svenf2gc5xn5kyr0et2vvyruxlnpqcdpqh9pzplumy5yzjxftyzh9ujfw0jq7ee60zx2x23p0jzyh9dvmly8p9h9ysptlqu7kwnejd65dnr75a0np2fvke8xen38r57w6z3wz3mycjmmn267wwxndfh9jdps7uxtct2wwfgamkpa5ap8s96lhfjztpwcm6fguhphu38yunu2v4vz3syzrvgwtqpemkewzp766nyu6texxvjlaemnhyyqutkcy6a42vqfsz49rw5wr4gt70r4vdaasehqjg46fnyts4sthrxadfllha3avu49wsj2c4jx" >> $GITHUB_ENV - name: Generate an ssh-rsa key if: matrix.recipient == 'ssh-rsa' run: ssh-keygen -t rsa -N "" -f key.txt @@ -151,6 +169,7 @@ jobs: run: echo "Test string" | ./${{ matrix.alice }} -o test.age $AGE_PUBKEY - name: Decrypt from file run: ./${{ matrix.bob }} -d -i key.txt test.age | grep -q "^Test string$" + if: matrix.identity - name: Store test.age uses: actions/upload-artifact@v4 if: failure() @@ -163,6 +182,7 @@ jobs: - name: Encrypt to ASCII-armored file run: ./${{ matrix.alice }} -a -o test2.age $AGE_PUBKEY test2.txt - name: Decrypt from ASCII-armored file + if: matrix.identity run: ./${{ matrix.bob }} -d -i key.txt test2.age | grep -q "^2 test 2 string$" - name: Store test2.age uses: actions/upload-artifact@v4 @@ -174,6 +194,7 @@ jobs: - name: Convert file to CRLF run: unix2dos test2.age - name: Decrypt from ASCII-armored CRLF file + if: matrix.identity run: ./${{ matrix.bob }} -d -i key.txt test2.age | grep -q "^2 test 2 string$" - name: Store CRLF-ed test2.age uses: actions/upload-artifact@v4 @@ -183,6 +204,7 @@ jobs: path: test2.age - name: Pipes! + if: matrix.identity run: echo "Test string 3 - ASCII Drift" | ./${{ matrix.alice }} $AGE_PUBKEY | tee --output-error=warn test3.age | ./${{ matrix.bob }} -d -i key.txt | grep -q "^Test string 3 - ASCII Drift$" - name: Store test3.age uses: actions/upload-artifact@v4 @@ -194,6 +216,7 @@ jobs: - name: Explicit stdout during encryption run: ./${{ matrix.alice }} -a -o - $AGE_PUBKEY test2.txt >test4.age - name: Explicit stdin during decryption + if: matrix.identity run: cat test4.age | ./${{ matrix.bob }} -d -i key.txt - | grep -q "^2 test 2 string$" - name: Store test4.age uses: actions/upload-artifact@v4 @@ -205,8 +228,10 @@ jobs: - name: Generate a file to encrypt run: echo "Test 5" > test5.txt - name: Encrypt to identity in a named pipe + if: matrix.identity run: ./${{ matrix.alice }} -e -i <(cat key.txt) -o test5.age test5.txt - name: Decrypt with identity in a named pipe + if: matrix.identity run: ./${{ matrix.bob }} -d -i <(cat key.txt) test5.age | grep -q "^Test 5$" - name: Store test5.age uses: actions/upload-artifact@v4 @@ -218,6 +243,7 @@ jobs: - name: Encrypt to recipient in standard input run: cat key.txt.pub | ./${{ matrix.alice }} -e -R - -o test6.age test5.txt - name: Decrypt with identity in standard input + if: matrix.identity run: cat key.txt | ./${{ matrix.bob }} -d -i - test6.age | grep -q "^Test 5$" - name: Store test6.age uses: actions/upload-artifact@v4 @@ -227,6 +253,7 @@ jobs: path: test6.age - name: Keygen prevents overwriting an existing file + if: matrix.identity run: | touch do_not_overwrite_key.txt if $(./${{ matrix.alice }}-keygen -o do_not_overwrite_key.txt); then @@ -236,6 +263,7 @@ jobs: fi - name: Keygen supports conversion from stdin + if: matrix.identity run: ./${{ matrix.alice }}-keygen | ./${{ matrix.bob }}-keygen -y - name: Keygen supports conversion from file diff --git a/Cargo.lock b/Cargo.lock index a95242b1..c6134da9 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -80,14 +80,18 @@ dependencies = [ "futures", "futures-test", "hex", + "hkdf", "hmac", + "hpke", "i18n-embed", "i18n-embed-fl", "is-terminal", "lazy_static", "memchr", + "ml-kem", "nom", "num-traits", + "p256", "pin-project", "pinentry", "pprof", @@ -98,6 +102,7 @@ dependencies = [ "rust-embed", "scrypt", "sha2", + "sha3", "subtle", "test-case", "tokio", @@ -116,6 +121,7 @@ dependencies = [ "chacha20poly1305", "cookie-factory", "hkdf", + "hpke", "io_tee", "nom", "rand", @@ -306,6 +312,12 @@ dependencies = [ "rustc-demangle", ] +[[package]] +name = "base16ct" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf" + [[package]] name = "base64" version = "0.22.1" @@ -764,6 +776,18 @@ version = "0.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" +[[package]] +name = "crypto-bigint" +version = "0.5.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76" +dependencies = [ + "generic-array", + "rand_core", + "subtle", + "zeroize", +] + [[package]] name = "crypto-common" version = "0.1.6" @@ -894,6 +918,25 @@ version = "1.15.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719" +[[package]] +name = "elliptic-curve" +version = "0.13.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47" +dependencies = [ + "base16ct", + "crypto-bigint", + "digest", + "ff", + "generic-array", + "group", + "hkdf", + "rand_core", + "sec1", + "subtle", + "zeroize", +] + [[package]] name = "encode_unicode" version = "1.0.0" @@ -941,6 +984,16 @@ version = "2.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be" +[[package]] +name = "ff" +version = "0.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0b50bfb653653f9ca9095b427bed08ab8d75a137839d9ad64eb11810d5b6393" +dependencies = [ + "rand_core", + "subtle", +] + [[package]] name = "fiat-crypto" version = "0.2.9" @@ -1187,6 +1240,7 @@ checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" dependencies = [ "typenum", "version_check", + "zeroize", ] [[package]] @@ -1234,6 +1288,17 @@ version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280" +[[package]] +name = "group" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63" +dependencies = [ + "ff", + "rand_core", + "subtle", +] + [[package]] name = "half" version = "2.2.1" @@ -1285,6 +1350,26 @@ dependencies = [ "digest", ] +[[package]] +name = "hpke" +version = "0.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4917627a14198c3603282c5158b815ad5534795451d3c074b53cf3cee0960b11" +dependencies = [ + "aead", + "aes-gcm", + "chacha20poly1305", + "digest", + "generic-array", + "hkdf", + "hmac", + "p256", + "rand_core", + "sha2", + "subtle", + "zeroize", +] + [[package]] name = "humantime" version = "2.2.0" @@ -1301,6 +1386,15 @@ dependencies = [ "serde", ] +[[package]] +name = "hybrid-array" +version = "0.2.0-rc.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4d306b679262030ad8813a82d4915fc04efff97776e4db7f8eb5137039d56400" +dependencies = [ + "typenum", +] + [[package]] name = "i18n-config" version = "0.4.8" @@ -1507,6 +1601,25 @@ dependencies = [ "wasm-bindgen", ] +[[package]] +name = "keccak" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8f6d5ed8676d904364de097082f4e7d240b571b67989ced0240f08b7f966f940" +dependencies = [ + "cpufeatures", +] + +[[package]] +name = "kem" +version = "0.3.0-pre.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b8645470337db67b01a7f966decf7d0bafedbae74147d33e641c67a91df239f" +dependencies = [ + "rand_core", + "zeroize", +] + [[package]] name = "lazy_static" version = "1.5.0" @@ -1594,6 +1707,18 @@ dependencies = [ "adler2", ] +[[package]] +name = "ml-kem" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "97befee0c869cb56f3118f49d0f9bb68c9e3f380dec23c1100aedc4ec3ba239a" +dependencies = [ + "hybrid-array", + "kem", + "rand_core", + "sha3", +] + [[package]] name = "nix" version = "0.26.4" @@ -1769,6 +1894,16 @@ dependencies = [ "windows-sys 0.59.0", ] +[[package]] +name = "p256" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c9863ad85fa8f4460f9c48cb909d38a0d689dba1f6f6988a5e3e0d31071bcd4b" +dependencies = [ + "elliptic-curve", + "primeorder", +] + [[package]] name = "page_size" version = "0.5.0" @@ -1980,6 +2115,15 @@ dependencies = [ "zerocopy 0.8.26", ] +[[package]] +name = "primeorder" +version = "0.13.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "353e1ca18966c16d9deb1c69278edbc5f194139612772bd9537af60ac231e1e6" +dependencies = [ + "elliptic-curve", +] + [[package]] name = "proc-macro-crate" version = "3.4.0" @@ -2378,6 +2522,19 @@ dependencies = [ "sha2", ] +[[package]] +name = "sec1" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc" +dependencies = [ + "base16ct", + "der", + "generic-array", + "subtle", + "zeroize", +] + [[package]] name = "secrecy" version = "0.10.3" @@ -2472,6 +2629,16 @@ dependencies = [ "digest", ] +[[package]] +name = "sha3" +version = "0.10.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "75872d278a8f37ef87fa0ddbda7802605cb18344497949862c0d4dcb291eba60" +dependencies = [ + "digest", + "keccak", +] + [[package]] name = "shlex" version = "1.3.0" diff --git a/Cargo.toml b/Cargo.toml index 3d081601..df418853 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,7 +10,7 @@ resolver = "2" [workspace.package] authors = ["Jack Grigg "] edition = "2021" -rust-version = "1.70" +rust-version = "1.74" repository = "https://github.com/str4d/rage" license = "MIT OR Apache-2.0" @@ -25,15 +25,27 @@ base64 = "0.22" # - ChaCha20-Poly1305 from RFC 7539 chacha20poly1305 = { version = "0.10", default-features = false, features = ["alloc"] } +# - SHA3-256 from FIPS 202 +sha3 = "0.10" + +# - ML-KEM from FIPS 203 +ml-kem = { version = "0.2", features = ["deterministic"] } + # - X25519 from RFC 7748 x25519-dalek = { version = "2", features = ["static_secrets"] } +# - P-256 +p256 = { version = "0.13", default-features = false, features = ["arithmetic"] } + # - HKDF from RFC 5869 with SHA-256 # - HMAC from RFC 2104 with SHA-256 hkdf = "0.12" hmac = "0.12" sha2 = "0.10" +# - HPKE from RFC 9180 +hpke = { version = "0.12", default-features = false, features = ["alloc"] } + # - scrypt from RFC 7914 scrypt = { version = "0.11", default-features = false } @@ -50,7 +62,7 @@ nom = { version = "8", default-features = false, features = ["alloc"] } # Secret management pinentry = "0.8" secrecy = "0.10" -subtle = "2" +subtle = "2.6" zeroize = "1" # Localization @@ -65,3 +77,7 @@ clap = { version = "4.3", features = ["derive"] } console = { version = "0.16", default-features = false } env_logger = "0.10" log = "0.4" + +[workspace.lints.rust] +# Requires MSRV 1.80 +#unexpected_cfgs = { level = "warn", check-cfg = ['cfg(fuzzing)'] } diff --git a/README.md b/README.md index fd120401..d36ba013 100644 --- a/README.md +++ b/README.md @@ -23,7 +23,7 @@ For more plugins, implementations, tools, and integrations, check out the | Environment | CLI command | |-------------|-------------| -| Cargo (Rust 1.65+) | `cargo install rage` | +| Cargo (Rust 1.74+) | `cargo install rage` | | Homebrew (macOS or Linux) | `brew install rage` | | MacPorts | `port install rage` | | Alpine Linux (edge) | `apk add rage` | diff --git a/age-core/CHANGELOG.md b/age-core/CHANGELOG.md index e48b0e63..48eb63f7 100644 --- a/age-core/CHANGELOG.md +++ b/age-core/CHANGELOG.md @@ -8,8 +8,11 @@ to 1.0.0 are beta releases. ## [Unreleased] +### Added +- `age_core::primitives::{hpke_seal, hpke_open}` + ### Changed -- MSRV is now 1.70.0. +- MSRV is now 1.74.0. ## [0.11.0] - 2024-11-03 ### Added diff --git a/age-core/Cargo.toml b/age-core/Cargo.toml index 131a54dd..b820d249 100644 --- a/age-core/Cargo.toml +++ b/age-core/Cargo.toml @@ -21,6 +21,7 @@ maintenance = { status = "experimental" } # (Breaking upgrades to these require a breaking upgrade to this crate.) chacha20poly1305.workspace = true cookie-factory.workspace = true +hpke.workspace = true io_tee = "0.1.1" nom.workspace = true secrecy.workspace = true @@ -33,9 +34,15 @@ rand.workspace = true sha2.workspace = true tempfile = { version = "3.2.0", optional = true } +[dev-dependencies] +hpke = { workspace = true, features = ["p256"] } + [features] plugin = ["tempfile"] unstable = [] [lib] bench = false + +[lints] +workspace = true diff --git a/age-core/src/primitives.rs b/age-core/src/primitives.rs index 75571873..f217422e 100644 --- a/age-core/src/primitives.rs +++ b/age-core/src/primitives.rs @@ -53,9 +53,68 @@ pub fn hkdf(salt: &[u8], label: &[u8], ikm: &[u8]) -> [u8; 32] { okm } +/// `HPKE.SealBase(pk_recip, info, aad = "", plaintext)` +/// +/// HPKE from [RFC 9180] with: +/// - KDF: HKDF-SHA256 +/// - AEAD: ChaCha20Poly1305 +/// - `aad = ""` (empty) +/// +/// # Panics +/// +/// Panics if the configured `Kem` produces an error. The native age recipient types that +/// use HPKE are configured with parameters that ensure errors either cannot occur or are +/// cryptographically negligible. If you are using this method for an age plugin, ensure +/// that you choose a KEM with equivalent properties. +/// +/// [RFC 9180]: https://tools.ietf.org/html/rfc9180 +pub fn hpke_seal( + pk_recip: &Kem::PublicKey, + info: &[u8], + plaintext: &[u8], + rng: &mut R, +) -> (Kem::EncappedKey, Vec) { + hpke::single_shot_seal::( + &hpke::OpModeS::Base, + pk_recip, + info, + plaintext, + &[], + rng, + ) + .expect("no errors should occur with these HPKE parameters") +} + +/// `HPKE.OpenBase(enc, sk_recip, info, aad = "", ciphertext)` +/// +/// HPKE from [RFC 9180] with: +/// - KDF: HKDF-SHA256 +/// - AEAD: ChaCha20Poly1305 +/// - `aad = ""` (empty) +/// +/// [RFC 9180]: https://tools.ietf.org/html/rfc9180 +pub fn hpke_open( + encapped_key: &Kem::EncappedKey, + sk_recip: &Kem::PrivateKey, + info: &[u8], + ciphertext: &[u8], +) -> Result, hpke::HpkeError> { + hpke::single_shot_open::( + &hpke::OpModeR::Base, + sk_recip, + encapped_key, + info, + ciphertext, + &[], + ) +} + #[cfg(test)] mod tests { - use super::{aead_decrypt, aead_encrypt}; + use hpke::Kem; + use rand::rngs::OsRng; + + use super::{aead_decrypt, aead_encrypt, hpke_open, hpke_seal}; #[test] fn aead_round_trip() { @@ -65,4 +124,20 @@ mod tests { let decrypted = aead_decrypt(&key, plaintext.len(), &encrypted).unwrap(); assert_eq!(decrypted, plaintext); } + + #[test] + fn hpke_round_trip() { + type Kem = hpke::kem::DhP256HkdfSha256; + let mut rng = OsRng; + + let (sk_recip, pk_recip) = Kem::gen_keypair(&mut rng); + + let info = b"foobar"; + let plaintext = b"12345678"; + + let (encapped_key, ciphertext) = hpke_seal::(&pk_recip, info, plaintext, &mut rng); + let decrypted = hpke_open::(&encapped_key, &sk_recip, info, &ciphertext).unwrap(); + + assert_eq!(decrypted, plaintext); + } } diff --git a/age-plugin/CHANGELOG.md b/age-plugin/CHANGELOG.md index 2d728354..a461883d 100644 --- a/age-plugin/CHANGELOG.md +++ b/age-plugin/CHANGELOG.md @@ -11,7 +11,7 @@ to 1.0.0 are beta releases. ## [Unreleased] ### Changed -- MSRV is now 1.70.0. +- MSRV is now 1.74.0. ## [0.6.1] - 2025-12-07 ### Changed diff --git a/age-plugin/Cargo.toml b/age-plugin/Cargo.toml index c0a17300..999666a4 100644 --- a/age-plugin/Cargo.toml +++ b/age-plugin/Cargo.toml @@ -25,3 +25,6 @@ clap.workspace = true [lib] bench = false + +[lints] +workspace = true diff --git a/age/CHANGELOG.md b/age/CHANGELOG.md index d0315bdd..33e7fc47 100644 --- a/age/CHANGELOG.md +++ b/age/CHANGELOG.md @@ -11,9 +11,12 @@ to 1.0.0 are beta releases. ## [Unreleased] ### Added - `age::encrypted::EncryptedIdentity` +- Support for the new native age recipient types: + - `age::tag::Recipient` (encryption-only) + - `age::tagpq::Recipient` (encryption-only) ### Changed -- MSRV is now 1.70.0. +- MSRV is now 1.74.0. - Migrated to `base64 0.22`, `i18n-embed 0.16`. - `age::IdentityFile::into_identities` now returns `Result>, DecryptError>` instead of diff --git a/age/Cargo.toml b/age/Cargo.toml index 18938067..76949beb 100644 --- a/age/Cargo.toml +++ b/age/Cargo.toml @@ -42,13 +42,19 @@ pinentry = { workspace = true, optional = true } # Dependencies used internally: # (Breaking upgrades to these are usually backwards-compatible, but check MSRVs.) bech32.workspace = true +cipher = { version = "0.4.3", features = ["alloc"] } cookie-factory.workspace = true +hkdf.workspace = true +hpke = { workspace = true, features = ["p256"] } i18n-embed-fl.workspace = true lazy_static.workspace = true +ml-kem.workspace = true nom.workspace = true +p256.workspace = true rust-embed.workspace = true scrypt.workspace = true sha2.workspace = true +sha3.workspace = true subtle.workspace = true x25519-dalek.workspace = true zeroize.workspace = true @@ -62,7 +68,6 @@ aes = { version = "0.8", optional = true } aes-gcm = { version = "0.10", optional = true } bcrypt-pbkdf = { version = "0.10", optional = true } cbc = { version = "0.1", optional = true } -cipher = { version = "0.4.3", features = ["alloc"], optional = true } ctr = { version = "0.9", optional = true } # scrypt Performance timer @@ -107,7 +112,6 @@ ssh = [ "aes-gcm", "bcrypt-pbkdf", "cbc", - "cipher", "ctr", "curve25519-dalek", "num-traits", @@ -137,3 +141,6 @@ harness = false [package.metadata.docs.rs] all-features = true rustdoc-args = ["--cfg", "docsrs"] + +[lints] +workspace = true diff --git a/age/src/cli_common/recipients.rs b/age/src/cli_common/recipients.rs index 913a8326..e9030c35 100644 --- a/age/src/cli_common/recipients.rs +++ b/age/src/cli_common/recipients.rs @@ -2,8 +2,7 @@ use std::io::{self, BufReader}; use super::StdinGuard; use super::{identities::parse_identity_files, ReadError}; -use crate::identity::RecipientsAccumulator; -use crate::{x25519, Recipient}; +use crate::{identity::RecipientsAccumulator, tag, tagpq, x25519, Recipient}; #[cfg(feature = "plugin")] use crate::{cli_common::UiCallbacks, plugin}; @@ -57,6 +56,10 @@ fn parse_recipient( ) -> Result<(), ReadError> { if let Ok(pk) = s.parse::() { recipients.push(Box::new(pk)); + } else if let Ok(pk) = s.parse::() { + recipients.push(Box::new(pk)); + } else if let Ok(pk) = s.parse::() { + recipients.push(Box::new(pk)); } else if let Some(pk) = { #[cfg(feature = "ssh")] { diff --git a/age/src/lib.rs b/age/src/lib.rs index 7e800806..229df65b 100644 --- a/age/src/lib.rs +++ b/age/src/lib.rs @@ -6,8 +6,11 @@ //! //! The encryption and decryption APIs are provided by [`Encryptor`] and [`Decryptor`]. //! There are several ways to use these: -//! - For most cases (including programmatic usage), use [`Encryptor::with_recipients`] -//! with [`x25519::Recipient`], and [`Decryptor`] with [`x25519::Identity`]. +//! - For most cases (including programmatic usage): +//! - Use [`Encryptor::with_recipients`] with a compatible set of recipients: +//! - Classic: [`x25519::Recipient`] and/or [`tag::Recipient`]. +//! - Post-quantum: [`tagpq::Recipient`]. +//! - Use [`Decryptor`] with [`x25519::Identity`]. //! - For passphrase-based encryption and decryption, use [`scrypt::Recipient`] and //! [`scrypt::Identity`], or the helper method [`Encryptor::with_user_passphrase`]. //! These should only be used with passphrases that were provided by (or generated for) @@ -249,9 +252,13 @@ pub use simple::encrypt_and_armor; // Identity types // +mod native; +pub use native::scrypt; +pub use native::tag; +pub use native::tagpq; +pub use native::x25519; + pub mod encrypted; -pub mod scrypt; -pub mod x25519; #[cfg(feature = "plugin")] #[cfg_attr(docsrs, doc(cfg(feature = "plugin")))] diff --git a/age/src/native.rs b/age/src/native.rs new file mode 100644 index 00000000..d7af6795 --- /dev/null +++ b/age/src/native.rs @@ -0,0 +1,25 @@ +use std::collections::HashSet; + +use hkdf::Hkdf; +use sha2::{Digest, Sha256}; + +pub mod scrypt; +pub mod tag; +pub mod tagpq; +pub mod x25519; + +fn static_tag(pk: &[u8]) -> [u8; 4] { + Sha256::digest(pk)[..4] + .try_into() + .expect("length is correct") +} + +/// Derives a tag for the tagged age recipient formats. +fn stanza_tag(ikm: &[u8], salt: &str) -> [u8; 4] { + let (tag, _) = Hkdf::::extract(Some(salt.as_bytes()), ikm); + tag[..4].try_into().expect("correct length") +} + +fn label_pq_only() -> HashSet { + ["postquantum".into()].into_iter().collect() +} diff --git a/age/src/scrypt.rs b/age/src/native/scrypt.rs similarity index 99% rename from age/src/scrypt.rs rename to age/src/native/scrypt.rs index 60938e86..663c034a 100644 --- a/age/src/scrypt.rs +++ b/age/src/native/scrypt.rs @@ -23,7 +23,7 @@ use crate::{ util::read::{base64_arg, decimal_digit_arg}, }; -pub(super) const SCRYPT_RECIPIENT_TAG: &str = "scrypt"; +pub(crate) const SCRYPT_RECIPIENT_TAG: &str = "scrypt"; const SCRYPT_SALT_LABEL: &[u8] = b"age-encryption.org/v1/scrypt"; const ONE_SECOND: Duration = Duration::from_secs(1); diff --git a/age/src/native/tag.rs b/age/src/native/tag.rs new file mode 100644 index 00000000..1af948f2 --- /dev/null +++ b/age/src/native/tag.rs @@ -0,0 +1,139 @@ +//! The "tag" recipient type, native to age. + +use std::collections::HashSet; +use std::fmt; + +use age_core::{ + format::{FileKey, Stanza}, + primitives::hpke_seal, + secrecy::ExposeSecret, +}; +use base64::{prelude::BASE64_STANDARD_NO_PAD, Engine}; +use bech32::{Bech32, Hrp}; +use hpke::{Deserializable, Serializable}; +use p256::{ + elliptic_curve::sec1::{FromEncodedPoint, ToEncodedPoint}, + EncodedPoint, PublicKey, +}; +use rand::rngs::OsRng; + +use crate::{util::parse_bech32, EncryptError}; + +const RECIPIENT_PREFIX: &str = "age1tag"; + +const P256TAG_RECIPIENT_TAG: &str = "p256tag"; +const P256TAG_SALT: &str = "age-encryption.org/p256tag"; + +type Kem = hpke::kem::DhP256HkdfSha256; + +/// The non-hybrid tagged age recipient type, designed for hardware keys where decryption +/// potentially requires user presence. +/// +/// With knowledge of the recipient, it is possible to check if a stanza was addressed to +/// a specific recipient before attempting decryption. This offers less privacy than the +/// untagged recipient types. +#[derive(Clone, PartialEq, Eq)] +pub struct Recipient { + /// Compressed encoding of the recipient public key. + compressed: EncodedPoint, + /// Cached in-memory representation, for HPKE. + pk_recip: ::PublicKey, +} + +impl std::str::FromStr for Recipient { + type Err = &'static str; + + /// Parses a recipient key from a string. + fn from_str(s: &str) -> Result { + let (hrp, bytes) = parse_bech32(s).ok_or("invalid Bech32 encoding")?; + + if hrp != RECIPIENT_PREFIX { + return Err("incorrect HRP"); + } + + let encoded = EncodedPoint::from_bytes(bytes).map_err(|_| "invalid SEC-1 encoding")?; + if !encoded.is_compressed() { + return Err("not a compressed SEC-1 encoding"); + } + + let point = PublicKey::from_encoded_point(&encoded) + .into_option() + .ok_or("invalid P-256 point")?; + + let pk_recip = + ::PublicKey::from_bytes(point.to_encoded_point(false).as_bytes()) + .expect("valid"); + + Ok(Self { + compressed: encoded, + pk_recip, + }) + } +} + +impl fmt::Display for Recipient { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!( + f, + "{}", + bech32::encode::( + Hrp::parse_unchecked(RECIPIENT_PREFIX), + self.compressed.as_bytes(), + ) + .expect("HRP is valid") + ) + } +} + +impl fmt::Debug for Recipient { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", self) + } +} + +impl crate::Recipient for Recipient { + fn wrap_file_key( + &self, + file_key: &FileKey, + ) -> Result<(Vec, HashSet), EncryptError> { + let (enc, ct) = hpke_seal::( + &self.pk_recip, + P256TAG_SALT.as_bytes(), + file_key.expose_secret(), + &mut OsRng, + ); + + let ikm = enc + .to_bytes() + .into_iter() + .chain(super::static_tag(self.compressed.as_bytes())) + .collect::>(); + let tag = super::stanza_tag(&ikm, P256TAG_SALT); + + let encoded_tag = BASE64_STANDARD_NO_PAD.encode(tag); + let encoded_enc = BASE64_STANDARD_NO_PAD.encode(enc.to_bytes()); + + Ok(( + vec![Stanza { + tag: P256TAG_RECIPIENT_TAG.to_owned(), + args: vec![encoded_tag, encoded_enc], + body: ct, + }], + HashSet::new(), + )) + } +} + +#[cfg(test)] +pub(crate) mod tests { + use super::Recipient; + + pub(crate) const TEST_RECIPIENT: &str = + "age1tag1qt8lw0ual6avlwmwatk888yqnmdamm7xfd0wak53ut6elz5c4swx2yqdj4e"; + + #[test] + fn recipient_encoding() { + let recipient: Recipient = TEST_RECIPIENT.parse().unwrap(); + assert_eq!(recipient.to_string(), TEST_RECIPIENT); + } +} diff --git a/age/src/native/tagpq.rs b/age/src/native/tagpq.rs new file mode 100644 index 00000000..3acbad19 --- /dev/null +++ b/age/src/native/tagpq.rs @@ -0,0 +1,140 @@ +//! The "tagpq" recipient type, native to age. + +use std::collections::HashSet; +use std::fmt; + +use age_core::{ + format::{FileKey, Stanza}, + primitives::hpke_seal, + secrecy::{zeroize::Zeroize, ExposeSecret}, +}; +use base64::{prelude::BASE64_STANDARD_NO_PAD, Engine}; +use bech32::{Bech32, Hrp}; +use hpke::{Deserializable, Serializable}; +use ml_kem::{KemCore, MlKem768}; +use p256::elliptic_curve::sec1::ToEncodedPoint; +use rand::rngs::OsRng; + +use crate::{util::parse_bech32, EncryptError}; + +mod kem; + +const RECIPIENT_PREFIX: &str = "age1tagpq"; + +const MLKEM768P256TAG_RECIPIENT_TAG: &str = "mlkem768p256tag"; +const MLKEM768P256TAG_SALT: &str = "age-encryption.org/mlkem768p256tag"; + +type Kem = kem::MlKem768P256; + +pub(crate) fn expand_pq_key( + seed: &[u8; 64], +) -> ( + ::DecapsulationKey, + ::EncapsulationKey, +) { + let mut d = [0; 32]; + let mut z = [0; 32]; + d.copy_from_slice(&seed[..32]); + z.copy_from_slice(&seed[32..]); + + let (dk_pq, ek_pq) = MlKem768::generate_deterministic(&d.into(), &z.into()); + + d.zeroize(); + z.zeroize(); + + (dk_pq, ek_pq) +} + +/// The hybrid post-quantum tagged age recipient type, designed for hardware keys where +/// decryption potentially requires user presence. +/// +/// With knowledge of the recipient, it is possible to check if a stanza was addressed to +/// a specific recipient before attempting decryption. This offers less privacy than the +/// untagged recipient types. +#[derive(Clone, PartialEq)] +pub struct Recipient(::PublicKey); + +impl std::str::FromStr for Recipient { + type Err = &'static str; + + /// Parses a recipient key from a string. + fn from_str(s: &str) -> Result { + parse_bech32(s) + .ok_or("invalid Bech32 encoding") + .and_then(|(hrp, bytes)| { + if hrp == RECIPIENT_PREFIX { + ::PublicKey::from_bytes(&bytes) + .map_err(|_| "invalid recipient") + .map(Self) + } else { + Err("incorrect HRP") + } + }) + } +} + +impl fmt::Display for Recipient { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!( + f, + "{}", + bech32::encode::(Hrp::parse_unchecked(RECIPIENT_PREFIX), &self.0.to_bytes()) + .expect("HRP is valid") + ) + } +} + +impl fmt::Debug for Recipient { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", self) + } +} + +impl crate::Recipient for Recipient { + fn wrap_file_key( + &self, + file_key: &FileKey, + ) -> Result<(Vec, HashSet), EncryptError> { + let (enc, ct) = hpke_seal::( + &self.0, + MLKEM768P256TAG_SALT.as_bytes(), + file_key.expose_secret(), + &mut OsRng, + ); + + let ikm = enc + .to_bytes() + .into_iter() + .chain(super::static_tag( + self.0.ek_t.to_encoded_point(false).as_bytes(), + )) + .collect::>(); + let tag = super::stanza_tag(&ikm, MLKEM768P256TAG_SALT); + + let encoded_tag = BASE64_STANDARD_NO_PAD.encode(tag); + let encoded_enc = BASE64_STANDARD_NO_PAD.encode(enc.to_bytes()); + + Ok(( + vec![Stanza { + tag: MLKEM768P256TAG_RECIPIENT_TAG.to_owned(), + args: vec![encoded_tag, encoded_enc], + body: ct, + }], + super::label_pq_only(), + )) + } +} + +#[cfg(test)] +pub(crate) mod tests { + use super::Recipient; + + pub(crate) const TEST_RECIPIENT: &str = + "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"; + + #[test] + fn recipient_encoding() { + let recipient: Recipient = TEST_RECIPIENT.parse().unwrap(); + assert_eq!(recipient.to_string(), TEST_RECIPIENT); + } +} diff --git a/age/src/native/tagpq/kem.rs b/age/src/native/tagpq/kem.rs new file mode 100644 index 00000000..71aaf7b8 --- /dev/null +++ b/age/src/native/tagpq/kem.rs @@ -0,0 +1,373 @@ +use age_core::secrecy::zeroize::Zeroize; +use cipher::{ + consts::{U32, U65}, + typenum, Unsigned, +}; +use hpke::{kem::SharedSecret, Deserializable, HpkeError, Serializable}; +use ml_kem::{ + kem::{Decapsulate, Encapsulate}, + Ciphertext, EncodedSizeUser, KemCore, MlKem768, +}; +use p256::elliptic_curve::sec1::{FromEncodedPoint, ToEncodedPoint}; +use rand::{CryptoRng, RngCore}; +use sha2::digest::XofReader; +use sha3::{ + digest::{ExtendableOutput, FixedOutput, OutputSizeUser, Update}, + Sha3_256, Shake256, +}; + +const LABEL: &[u8] = b"MLKEM768-P256"; +type KemNct = ::CiphertextSize; +type KemNek = <::EncapsulationKey as EncodedSizeUser>::EncodedSize; +type GroupNelem = U65; + +#[derive(Clone)] +pub(super) struct PrivateKey { + seed: [u8; 32], + dk_pq: ::DecapsulationKey, + dk_t: p256::SecretKey, +} + +impl PartialEq for PrivateKey { + fn eq(&self, other: &Self) -> bool { + self.seed == other.seed + } +} +impl Eq for PrivateKey {} + +impl Deserializable for PrivateKey { + fn from_bytes(encoded: &[u8]) -> Result { + let seed = encoded.try_into().map_err(|_| { + HpkeError::IncorrectInputLength(Self::OutputSize::to_usize(), encoded.len()) + })?; + let (_, _, dk_pq, dk_t) = expand_key(&seed); + Ok(Self { seed, dk_pq, dk_t }) + } +} + +impl Serializable for PrivateKey { + type OutputSize = U32; + + fn write_exact(&self, buf: &mut [u8]) { + buf.copy_from_slice(&self.seed); + } +} + +#[derive(Clone, Debug, PartialEq)] +pub(super) struct PublicKey { + pub(super) ek_pq: ::EncapsulationKey, + pub(super) ek_t: p256::PublicKey, +} + +impl Eq for PublicKey {} + +impl Deserializable for PublicKey { + fn from_bytes(encoded: &[u8]) -> Result { + if encoded.len() != Self::OutputSize::to_usize() { + return Err(HpkeError::IncorrectInputLength( + Self::OutputSize::to_usize(), + encoded.len(), + )); + } + let (encoded_pq, encoded_t) = encoded.split_at(KemNek::to_usize()); + + let ek_pq = ::EncapsulationKey::from_bytes( + encoded_pq.try_into().expect("correct length"), + ); + + let ek_t = + p256::EncodedPoint::from_bytes(encoded_t).map_err(|_| HpkeError::ValidationError)?; + if ek_t.is_compressed() { + return Err(HpkeError::ValidationError); + } + let ek_t = p256::PublicKey::from_encoded_point(&ek_t) + .into_option() + .ok_or(HpkeError::ValidationError)?; + + Ok(Self { ek_pq, ek_t }) + } +} + +impl Serializable for PublicKey { + type OutputSize = typenum::Sum; + + fn write_exact(&self, buf: &mut [u8]) { + let kem_neq = KemNek::to_usize(); + buf[..kem_neq].copy_from_slice(&self.ek_pq.as_bytes()); + buf[kem_neq..].copy_from_slice(self.ek_t.to_encoded_point(false).as_bytes()); + } +} + +#[derive(Clone)] +pub(super) struct EncappedKey { + ct_pq: Ciphertext, + ct_t: p256::EncodedPoint, +} + +impl Deserializable for EncappedKey { + fn from_bytes(encoded: &[u8]) -> Result { + if encoded.len() != Self::OutputSize::to_usize() { + return Err(HpkeError::IncorrectInputLength( + Self::OutputSize::to_usize(), + encoded.len(), + )); + } + let (encoded_pq, encoded_t) = encoded.split_at(KemNct::to_usize()); + + let ct_pq = <[u8; KemNct::USIZE]>::try_from(encoded_pq) + .expect("correct length") + .into(); + + let ct_t = + p256::EncodedPoint::from_bytes(encoded_t).map_err(|_| HpkeError::ValidationError)?; + if ct_t.is_compressed() { + return Err(HpkeError::ValidationError); + } + + Ok(Self { ct_pq, ct_t }) + } +} + +impl Serializable for EncappedKey { + type OutputSize = typenum::Sum; + + fn write_exact(&self, buf: &mut [u8]) { + let kem_nct = KemNct::to_usize(); + buf[..kem_nct].copy_from_slice(&self.ct_pq.0); + buf[kem_nct..].copy_from_slice(self.ct_t.as_bytes()); + } +} + +pub(super) struct MlKem768P256; + +impl hpke::Kem for MlKem768P256 { + type PublicKey = PublicKey; + type PrivateKey = PrivateKey; + + fn sk_to_pk(sk: &Self::PrivateKey) -> Self::PublicKey { + PublicKey { + ek_pq: sk.dk_pq.encapsulation_key().clone(), + ek_t: sk.dk_t.public_key(), + } + } + + type EncappedKey = EncappedKey; + type NSecret = ::OutputSize; + const KEM_ID: u16 = 0x0050; + + fn derive_keypair(ikm: &[u8]) -> (Self::PrivateKey, Self::PublicKey) { + let seed = shake256_labeled_derive::<32>(ikm, Self::KEM_ID, b"DeriveKeyPair", b""); + let (ek_pq, ek_t, dk_pq, dk_t) = expand_key(&seed); + (PrivateKey { seed, dk_pq, dk_t }, PublicKey { ek_pq, ek_t }) + } + + fn decap( + sk_recip: &Self::PrivateKey, + pk_sender_id: Option<&Self::PublicKey>, + encapped_key: &Self::EncappedKey, + ) -> Result, HpkeError> { + // TODO: Implement this if it is upstreamed. + assert!(pk_sender_id.is_none()); + + let ct_t = p256::PublicKey::from_encoded_point(&encapped_key.ct_t) + .into_option() + .ok_or(HpkeError::DecapError)?; + + let ss_pq = sk_recip + .dk_pq + .decapsulate(&encapped_key.ct_pq) + .map_err(|()| HpkeError::DecapError)?; + let ss_t = p256::ecdh::diffie_hellman(sk_recip.dk_t.to_nonzero_scalar(), ct_t.as_affine()); + + let ss = ss( + &ss_pq, + ss_t.raw_secret_bytes(), + encapped_key.ct_t.as_bytes(), + sk_recip + .dk_t + .public_key() + .to_encoded_point(false) + .as_bytes(), + ); + + Ok(SharedSecret(ss)) + } + + fn encap( + pk_recip: &Self::PublicKey, + sender_id_keypair: Option<(&Self::PrivateKey, &Self::PublicKey)>, + csprng: &mut R, + ) -> Result<(SharedSecret, Self::EncappedKey), HpkeError> { + // TODO: Implement this if it is upstreamed. + assert!(sender_id_keypair.is_none()); + + let (ct_pq, ss_pq) = pk_recip + .ek_pq + .encapsulate(csprng) + .map_err(|()| HpkeError::EncapError)?; + + let sk_e = p256::ecdh::EphemeralSecret::random(csprng); + let ct_t = sk_e.public_key().to_encoded_point(false); + let ss_t = sk_e.diffie_hellman(&pk_recip.ek_t); + + let ss = ss( + &ss_pq, + ss_t.raw_secret_bytes(), + ct_t.as_bytes(), + pk_recip.ek_t.to_encoded_point(false).as_bytes(), + ); + + Ok((SharedSecret(ss), EncappedKey { ct_pq, ct_t })) + } +} + +fn expand_key( + seed: &[u8; 32], +) -> ( + ::EncapsulationKey, + p256::PublicKey, + ::DecapsulationKey, + p256::SecretKey, +) { + let mut seed_pq = [0; 64]; + let mut seed_t = [0; 128]; + let mut xof = Shake256::default().chain(seed).finalize_xof(); + xof.read(&mut seed_pq); + xof.read(&mut seed_t); + + let (dk_pq, ek_pq) = super::expand_pq_key(&seed_pq); + let dk_t = p256_random_scalar(&seed_t); + let ek_t = dk_t.public_key(); + + seed_pq.zeroize(); + seed_t.zeroize(); + + (ek_pq, ek_t, dk_pq, dk_t) +} + +fn p256_random_scalar(seed: &[u8; 128]) -> p256::SecretKey { + for sk in seed.chunks_exact(32) { + if let Ok(sk) = p256::SecretKey::from_bytes(sk.try_into().expect("correct length")) { + return sk; + } + } + // This happens with cryptographically negligible probability. + // The chance of a single rejection is < 2^-32 for P-256. + // The chance of reaching this is thus < 2^-128 for P-256. + panic!("Rejection sampling failed"); +} + +fn shake256_labeled_derive( + ikm: &[u8], + kem_id: u16, + label: &[u8], + context: &[u8], +) -> [u8; L] { + let mut out = [0; L]; + Shake256::default() + .chain(ikm) + .chain(b"HPKE-v1") + // suite_id + .chain(b"KEM") + .chain(kem_id.to_be_bytes()) + // prefixed_label + .chain( + u16::try_from(label.len()) + .expect("short enough") + .to_be_bytes(), + ) + .chain(label) + .chain(u16::try_from(L).expect("short enough").to_be_bytes()) + .chain(context) + .finalize_xof_into(&mut out); + out +} + +fn ss(ss_pq: &[u8], ss_t: &[u8], ct_t: &[u8], ek_t: &[u8]) -> sha3::digest::Output { + let mut h = Sha3_256::default(); + h.update(ss_pq); + h.update(ss_t); + h.update(ct_t); + h.update(ek_t); + h.update(LABEL); + h.finalize_fixed() +} + +#[cfg(test)] +mod test_vectors; + +#[cfg(test)] +mod tests { + use age_core::primitives::{hpke_open, hpke_seal}; + use hpke::{rand_core, Deserializable, Kem, Serializable}; + use rand::{rngs::OsRng, CryptoRng, RngCore}; + + use super::{test_vectors::TEST_VECTORS, MlKem768P256, PrivateKey, PublicKey}; + + #[test] + fn hpke_round_trip() { + type Kem = MlKem768P256; + let mut rng = OsRng; + + let (sk_recip, pk_recip) = Kem::gen_keypair(&mut rng); + + let info = b"foobar"; + let plaintext = b"12345678"; + + let (encapped_key, ciphertext) = hpke_seal::(&pk_recip, info, plaintext, &mut rng); + let decrypted = hpke_open::(&encapped_key, &sk_recip, info, &ciphertext).unwrap(); + + assert_eq!(decrypted, plaintext); + } + + #[test] + fn test_vectors() { + struct FakeCsprng<'a> { + bytes: &'a [u8], + } + impl<'a> RngCore for FakeCsprng<'a> { + fn next_u32(&mut self) -> u32 { + rand_core::impls::next_u32_via_fill(self) + } + + fn next_u64(&mut self) -> u64 { + rand_core::impls::next_u64_via_fill(self) + } + + fn fill_bytes(&mut self, dest: &mut [u8]) { + self.try_fill_bytes(dest).unwrap() + } + + fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand::Error> { + if dest.len() > self.bytes.len() { + Err(rand::Error::new("ran out of randomness")) + } else { + let (taken, rest) = self.bytes.split_at(dest.len()); + dest.copy_from_slice(taken); + self.bytes = rest; + Ok(()) + } + } + } + impl<'a> CryptoRng for FakeCsprng<'a> {} + + for tv in TEST_VECTORS { + let dk = PrivateKey::from_bytes(&tv.dk).unwrap(); + assert_eq!(dk.dk_t.to_bytes().as_slice(), tv.dk_t.as_slice()); + + let ek = PublicKey::from_bytes(tv.ek).unwrap(); + assert_eq!(MlKem768P256::sk_to_pk(&dk), ek); + + let mut csprng = FakeCsprng { + bytes: &tv.randomness, + }; + let (ss, ct) = MlKem768P256::encap(&ek, None, &mut csprng).unwrap(); + assert_eq!(ss.0.as_slice(), tv.ss.as_slice()); + assert_eq!(ct.to_bytes().as_slice(), tv.ct); + + let enc = super::EncappedKey::from_bytes(tv.ct).unwrap(); + let ss = MlKem768P256::decap(&dk, None, &enc).unwrap(); + assert_eq!(ss.0.as_slice(), tv.ss.as_slice()); + } + } +} diff --git a/age/src/native/tagpq/kem/test_vectors.rs b/age/src/native/tagpq/kem/test_vectors.rs new file mode 100644 index 00000000..dc19402b --- /dev/null +++ b/age/src/native/tagpq/kem/test_vectors.rs @@ -0,0 +1,2005 @@ +#[allow(dead_code)] +pub(super) struct TestVector { + pub(super) seed: [u8; 32], + pub(super) randomness: [u8; 128], + pub(super) ek: &'static [u8], + pub(super) dk: [u8; 32], + pub(super) dk_pq: [u8; 64], + pub(super) dk_t: [u8; 32], + pub(super) ct: &'static [u8], + pub(super) ss: [u8; 32], +} + +/// From https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-concrete-hybrid-kems-02#appendix-A.1 +pub(super) const TEST_VECTORS: &[TestVector] = &[ + TestVector { + seed: [0x00; 32], + randomness: [0x64; 128], + ek: &[ + 0x3d, 0x20, 0x9f, 0x71, 0x67, 0x52, 0xf6, 0x40, 0x8e, 0x7f, 0x89, 0xbc, 0xee, 0xf9, + 0x7a, 0xc3, 0x88, 0x53, 0x00, 0x45, 0x37, 0x79, 0x27, 0x64, 0x4e, 0xf0, 0x46, 0xc0, + 0xa7, 0xca, 0xe9, 0x78, 0xc8, 0x84, 0x1a, 0x01, 0x33, 0xaa, 0xc4, 0xf1, 0xe1, 0xa7, + 0x02, 0x72, 0x77, 0xf6, 0x71, 0x21, 0x9c, 0xf5, 0x8b, 0x85, 0xd2, 0x9c, 0x8f, 0xec, + 0x08, 0xed, 0xd4, 0x32, 0xe7, 0x87, 0xa3, 0xcf, 0x99, 0x36, 0xfe, 0x00, 0x26, 0xa1, + 0x13, 0xcb, 0x9e, 0xfb, 0x1d, 0x72, 0x14, 0x04, 0x95, 0x27, 0xbf, 0xe2, 0x14, 0x1e, + 0xa1, 0x70, 0xb0, 0x29, 0x4a, 0x59, 0x40, 0x3a, 0xb0, 0xce, 0x16, 0x76, 0x0a, 0x8b, + 0xaa, 0x95, 0xb8, 0x23, 0xcb, 0xb8, 0xaa, 0xcd, 0xcc, 0x17, 0xef, 0x32, 0x77, 0x52, + 0x23, 0xc7, 0x91, 0xe3, 0x74, 0x01, 0x63, 0x94, 0x1f, 0x9b, 0xb3, 0xf6, 0x33, 0x46, + 0xbe, 0xf1, 0xc0, 0x50, 0xc3, 0x1f, 0x93, 0x2c, 0x62, 0x71, 0x94, 0x29, 0xaf, 0xf1, + 0x4c, 0x2b, 0xd4, 0x38, 0xab, 0x13, 0x5b, 0xed, 0x69, 0x2d, 0x56, 0xc7, 0x7c, 0x04, + 0xcb, 0xbf, 0xfd, 0x63, 0x35, 0xb5, 0x78, 0x31, 0x8b, 0x51, 0x37, 0x71, 0xe8, 0x4b, + 0x14, 0xea, 0x82, 0x12, 0x62, 0x14, 0x1c, 0xa0, 0x06, 0xcc, 0xb8, 0xbf, 0x25, 0x00, + 0xaa, 0x10, 0x08, 0x97, 0x0f, 0x21, 0x6f, 0xe7, 0xf1, 0xae, 0x34, 0x12, 0x5a, 0xa2, + 0x90, 0x49, 0x2c, 0x06, 0x9a, 0x18, 0x92, 0x22, 0xad, 0xc3, 0x22, 0xf9, 0x76, 0x49, + 0xc7, 0x62, 0xc7, 0xd3, 0x12, 0x8a, 0xd3, 0xbb, 0x26, 0x67, 0x97, 0x1d, 0x07, 0x44, + 0x01, 0x4b, 0xc3, 0xb6, 0x74, 0x45, 0xcb, 0xcd, 0x0b, 0x3e, 0x7e, 0xa6, 0x9f, 0xb1, + 0xcb, 0x9f, 0x9c, 0x33, 0x1f, 0x97, 0x48, 0x79, 0x20, 0x18, 0x72, 0x92, 0x92, 0x6d, + 0x04, 0xa2, 0x5a, 0x26, 0x50, 0xab, 0xbd, 0x44, 0x98, 0x2b, 0xb0, 0xc3, 0xc6, 0x30, + 0x1f, 0xe6, 0xa6, 0x13, 0x30, 0xd2, 0x4d, 0x8a, 0x3c, 0x70, 0x21, 0xdc, 0x3e, 0x33, + 0x92, 0xc7, 0x9a, 0x13, 0x9b, 0x37, 0x61, 0x3b, 0xba, 0x67, 0xa2, 0x98, 0x42, 0x98, + 0x50, 0x7b, 0x84, 0xa4, 0xd6, 0x1e, 0xef, 0x18, 0xac, 0xfb, 0x97, 0x9a, 0xf2, 0xd3, + 0x9c, 0xaa, 0x4c, 0x0d, 0xb4, 0x51, 0x38, 0x15, 0x35, 0x9d, 0x76, 0xfc, 0x37, 0x8c, + 0x63, 0xa7, 0xf4, 0xf3, 0x05, 0x3b, 0x17, 0x16, 0x8d, 0x02, 0x21, 0xcf, 0x0c, 0x2e, + 0xec, 0x55, 0x14, 0xba, 0x23, 0x5f, 0x81, 0xd0, 0x4d, 0x67, 0xc3, 0xb5, 0xc5, 0x18, + 0x09, 0x49, 0x17, 0x67, 0x1c, 0x26, 0xa7, 0xc0, 0x46, 0x45, 0x75, 0x33, 0xcc, 0x32, + 0x84, 0x45, 0x81, 0x27, 0x7a, 0x03, 0xeb, 0x06, 0x5c, 0x45, 0x29, 0xa7, 0x79, 0xa9, + 0xa5, 0x87, 0x8f, 0x2a, 0xac, 0x3f, 0x81, 0xdb, 0x9e, 0xd3, 0xd8, 0xc9, 0x34, 0x56, + 0x97, 0x05, 0x8c, 0xbb, 0x99, 0xd3, 0x79, 0xbc, 0xa1, 0x6d, 0x8f, 0xdb, 0x61, 0xd1, + 0x29, 0x96, 0x03, 0x90, 0x52, 0x47, 0x91, 0xb9, 0xd3, 0xe5, 0x01, 0xb9, 0x00, 0xbd, + 0x1e, 0x50, 0x02, 0xe0, 0x95, 0xbe, 0x06, 0xc2, 0x3f, 0x1f, 0xb2, 0x12, 0xf5, 0x80, + 0x1f, 0x24, 0xb6, 0xb2, 0x8c, 0x0c, 0x54, 0x93, 0xd2, 0x46, 0xd0, 0x2a, 0xa2, 0x9f, + 0xa3, 0xac, 0xfb, 0xe1, 0x5a, 0xc4, 0xe2, 0x12, 0xeb, 0x0b, 0x6f, 0x69, 0xeb, 0xbe, + 0xa2, 0x59, 0xa2, 0x70, 0x3a, 0xa4, 0xc3, 0x08, 0x22, 0x4b, 0xdb, 0x74, 0x1c, 0x65, + 0xc7, 0xa5, 0xd4, 0xbf, 0xf7, 0x88, 0x27, 0x95, 0x07, 0xbb, 0xfe, 0x51, 0x3d, 0x7a, + 0xa5, 0x69, 0x4e, 0x7b, 0x3c, 0xdf, 0x62, 0xab, 0x36, 0x43, 0x27, 0x42, 0xd4, 0xa0, + 0xca, 0x9b, 0x35, 0x70, 0xba, 0x74, 0x2f, 0xa8, 0x03, 0xb4, 0x69, 0x89, 0xc8, 0x52, + 0x6e, 0xa5, 0x86, 0xcc, 0x4f, 0xc3, 0x28, 0x66, 0x14, 0x3b, 0x79, 0x60, 0x17, 0x25, + 0xfa, 0x54, 0x5f, 0xd2, 0x80, 0xb4, 0x04, 0x53, 0x03, 0x18, 0xbb, 0xc3, 0x37, 0x11, + 0x94, 0x71, 0x0b, 0x6d, 0x74, 0xbe, 0xaa, 0x62, 0x9e, 0xb1, 0x8a, 0x36, 0xa9, 0x53, + 0xb7, 0x59, 0x15, 0xae, 0x96, 0x99, 0x9b, 0xa5, 0xc8, 0x8c, 0xdc, 0x56, 0xa4, 0x68, + 0x61, 0xc5, 0x00, 0x32, 0xc9, 0xb6, 0x30, 0xbc, 0xc1, 0x44, 0x5a, 0x30, 0x87, 0x89, + 0x79, 0xbc, 0x55, 0xa2, 0xc0, 0x95, 0x5b, 0xf3, 0x99, 0xb2, 0x31, 0x20, 0x3b, 0x90, + 0xc6, 0x51, 0xb6, 0xaf, 0xe0, 0xe2, 0x42, 0xb5, 0xa5, 0x43, 0x25, 0x0b, 0x14, 0x2f, + 0x72, 0x91, 0xed, 0x75, 0x3d, 0x81, 0x60, 0x98, 0xf7, 0x91, 0x33, 0x02, 0xa8, 0xce, + 0x91, 0x64, 0x17, 0x16, 0x62, 0x3d, 0x4f, 0xc2, 0xac, 0x67, 0x72, 0xaa, 0x5f, 0x36, + 0x74, 0x04, 0x2b, 0x7c, 0x4a, 0x18, 0xa2, 0x18, 0x62, 0x89, 0xa4, 0xac, 0x4e, 0x20, + 0x07, 0x74, 0x59, 0x6c, 0xa0, 0x3e, 0x67, 0x98, 0xc7, 0x50, 0x6b, 0x98, 0x49, 0x99, + 0xdb, 0x6a, 0xc1, 0x42, 0x58, 0x6b, 0xae, 0x07, 0x99, 0xf1, 0xe7, 0x76, 0xf9, 0xf5, + 0x24, 0x7d, 0xc5, 0x74, 0xd8, 0x55, 0x6d, 0xdf, 0x9b, 0xbb, 0xc4, 0xca, 0x36, 0x43, + 0x26, 0x34, 0x57, 0xf7, 0x42, 0x48, 0x01, 0x0d, 0x62, 0xd4, 0x31, 0x12, 0x68, 0x36, + 0x0a, 0xec, 0xb4, 0x90, 0x2b, 0x45, 0x0b, 0xf2, 0x05, 0x0e, 0xcb, 0x8b, 0xa7, 0xa9, + 0x28, 0x20, 0xd2, 0x33, 0xf5, 0xa1, 0x4e, 0xd3, 0x12, 0x25, 0xa1, 0xd1, 0x7c, 0xa6, + 0xf1, 0x9e, 0x82, 0x58, 0x94, 0xcf, 0xb1, 0x80, 0x7d, 0x92, 0x2c, 0xbd, 0x60, 0x76, + 0x11, 0x34, 0xbe, 0x41, 0x91, 0x44, 0xbc, 0xf7, 0x20, 0x06, 0x36, 0x6a, 0x44, 0x60, + 0x13, 0x7a, 0xd9, 0x13, 0x6c, 0x11, 0x3f, 0x05, 0xeb, 0x54, 0xc4, 0x09, 0x52, 0x0e, + 0xdc, 0x72, 0xe4, 0x15, 0x0c, 0xc3, 0xa2, 0x4b, 0x0f, 0x81, 0x9e, 0xec, 0x11, 0xbb, + 0xd1, 0x9c, 0xa9, 0x64, 0x5b, 0x08, 0x10, 0xa6, 0x0b, 0x4a, 0x8a, 0x9e, 0x9c, 0x39, + 0x55, 0x39, 0x6a, 0x16, 0x53, 0x95, 0x5b, 0x04, 0x7b, 0xcf, 0x4f, 0x98, 0x43, 0x3c, + 0x27, 0x23, 0x6c, 0x57, 0x0d, 0x75, 0xf8, 0x09, 0xe4, 0x4a, 0xaf, 0x2d, 0xc3, 0x36, + 0x65, 0x82, 0x63, 0x51, 0x87, 0x2c, 0x29, 0x33, 0x50, 0xab, 0x32, 0x45, 0x18, 0xc8, + 0xc0, 0xc8, 0x0b, 0x52, 0x1c, 0x80, 0xc8, 0x1a, 0x56, 0xbd, 0xc9, 0x68, 0xa5, 0x65, + 0x03, 0x15, 0xa8, 0x30, 0xc8, 0xbb, 0x17, 0x53, 0x2c, 0x62, 0xcc, 0xc2, 0x3b, 0x1d, + 0x46, 0x41, 0x2c, 0x25, 0x6b, 0x22, 0x4f, 0xd4, 0x67, 0x44, 0x91, 0x80, 0x35, 0x01, + 0xd0, 0x14, 0x31, 0x25, 0xc7, 0x57, 0x72, 0x39, 0x68, 0x99, 0x65, 0xb6, 0x98, 0x9c, + 0xa5, 0x61, 0x79, 0x3c, 0x0f, 0x85, 0xc6, 0x2a, 0x9e, 0x13, 0x48, 0x7d, 0xa1, 0x76, + 0x62, 0xa7, 0x18, 0x8c, 0x70, 0xb1, 0x04, 0x0a, 0x67, 0xed, 0x4c, 0x3f, 0x85, 0xe7, + 0x4e, 0x36, 0x91, 0x82, 0x2f, 0xb9, 0x63, 0x14, 0xd6, 0x13, 0x4f, 0xe6, 0xa6, 0x26, + 0xb3, 0xcb, 0xe1, 0x46, 0x1d, 0x62, 0xa7, 0xb5, 0x73, 0xb2, 0xcc, 0x75, 0x57, 0x9f, + 0xfa, 0x22, 0x96, 0x7e, 0x36, 0xce, 0xb2, 0xa1, 0xaa, 0x0b, 0x71, 0x87, 0x5a, 0x22, + 0x75, 0x1d, 0x70, 0x6b, 0x72, 0xca, 0x9e, 0xcd, 0x0c, 0x81, 0x00, 0xad, 0x0a, 0xa5, + 0x80, 0x09, 0xa5, 0xc8, 0x3f, 0xff, 0xe9, 0x17, 0x59, 0xe6, 0xba, 0xa0, 0xa9, 0x34, + 0x5a, 0xf9, 0x9f, 0xe3, 0xb6, 0x95, 0x09, 0xdb, 0xc8, 0x40, 0x32, 0x86, 0x88, 0x44, + 0xab, 0x3f, 0x65, 0xbb, 0x1d, 0xf8, 0xbe, 0xad, 0xf3, 0x64, 0x42, 0xe4, 0x8e, 0x33, + 0x9c, 0x96, 0x70, 0x23, 0xa5, 0x25, 0x41, 0x15, 0x44, 0xc7, 0x89, 0xa2, 0xf0, 0x4d, + 0xac, 0xd0, 0x6f, 0xfe, 0xf7, 0x83, 0x02, 0x21, 0x04, 0x50, 0xb9, 0x31, 0xf6, 0xb4, + 0xc3, 0x2a, 0xab, 0x34, 0xa3, 0xf5, 0x26, 0x0b, 0x81, 0x0f, 0x4c, 0x9a, 0x94, 0x6f, + 0xc2, 0x2d, 0x3b, 0xaa, 0xba, 0xa8, 0x0b, 0xa8, 0xd9, 0x95, 0x5d, 0x6d, 0xc3, 0x5e, + 0x86, 0x09, 0xb4, 0x25, 0x6b, 0x48, 0x2c, 0xdc, 0x9d, 0x89, 0x77, 0xc1, 0xa4, 0x7a, + 0x35, 0x4e, 0x7c, 0x52, 0x7f, 0xdb, 0x16, 0x72, 0xe1, 0x66, 0x91, 0x7b, 0x95, 0xcd, + 0x63, 0x51, 0x82, 0x02, 0x61, 0xda, 0xab, 0x36, 0x1f, 0x8a, 0x2d, 0xcb, 0xb2, 0x40, + 0xc5, 0x5a, 0xbd, 0x6a, 0x81, 0x05, 0xe5, 0x29, 0x1b, 0x42, 0x7b, 0x56, 0x6d, 0x73, + 0x1e, 0x6b, 0x70, 0x47, 0x18, 0x9c, 0xff, 0x20, 0xd8, 0xb1, 0x20, 0xe0, 0xb3, 0xe7, + 0x24, 0x72, 0xd1, 0xb0, 0x08, 0x68, 0x12, 0x20, 0x0f, 0xd3, 0x69, 0x8e, 0x23, 0xf0, + 0x6e, 0x4f, 0x4e, 0x08, 0xbb, 0xb5, 0x4c, 0xc2, 0x04, 0x9c, 0x03, 0x9c, 0x84, 0x5b, + 0xe6, 0x59, 0x99, 0x9c, 0x8f, 0xa4, 0x8d, 0x7f, 0x62, 0x32, 0x7c, 0x14, 0x6c, 0xf1, + 0xbc, 0x0b, 0x0b, 0xb1, 0xb9, 0x1b, 0x30, 0x17, 0x4b, 0x7b, 0xc2, 0x20, 0xd4, 0x22, + 0x02, 0x3b, 0xff, 0x6b, 0x0d, 0xee, 0x26, 0x35, 0x32, 0xc5, 0x03, 0xf3, 0x98, 0x2e, + 0x4d, 0x3e, 0x27, 0x07, 0x1b, 0x85, 0x55, 0x78, 0xa9, 0xa9, 0xaa, 0x63, 0xb8, 0xa8, + 0xc3, 0x39, 0xbf, + ], + dk: [0x00; 32], + dk_pq: [ + 0xf5, 0x97, 0x7c, 0x82, 0x83, 0x54, 0x6a, 0x63, 0x72, 0x3b, 0xc3, 0x1d, 0x26, 0x19, + 0x12, 0x4f, 0x11, 0xdb, 0x46, 0x58, 0x64, 0x33, 0x36, 0x74, 0x1d, 0xf8, 0x17, 0x57, + 0xd5, 0xad, 0x30, 0x62, 0x22, 0x1e, 0x12, 0x43, 0x11, 0xec, 0x7f, 0x71, 0x81, 0x56, + 0x8d, 0xe7, 0x93, 0x8d, 0xf8, 0x05, 0xd8, 0x94, 0xf5, 0xfd, 0xed, 0x46, 0x50, 0x01, + 0xa0, 0x4e, 0x26, 0x0a, 0x49, 0x48, 0x2c, 0xf5, + ], + dk_t: [ + 0xe0, 0x0b, 0x3f, 0x9d, 0x33, 0x8d, 0xe9, 0x04, 0x88, 0x97, 0x37, 0x87, 0xb0, 0x91, + 0x6a, 0x4a, 0x9a, 0xe8, 0xbe, 0xbf, 0x4e, 0x2b, 0xc0, 0x7a, 0x7b, 0xc1, 0x8f, 0x1a, + 0x62, 0x21, 0x51, 0x82, + ], + ct: &[ + 0xd8, 0x10, 0x18, 0xa9, 0x4f, 0x80, 0x78, 0xe0, 0x21, 0x05, 0xbe, 0xaa, 0x81, 0x4e, + 0x00, 0x33, 0x90, 0xbe, 0xfa, 0x45, 0x89, 0xbb, 0x61, 0x4f, 0x77, 0x39, 0x7a, 0xf4, + 0x2d, 0x8e, 0x81, 0x50, 0x79, 0x6f, 0x2c, 0x88, 0xa4, 0xef, 0xca, 0x81, 0xb8, 0xcf, + 0x93, 0xc0, 0xae, 0x37, 0x16, 0xc5, 0x4e, 0xc1, 0xb0, 0x45, 0xe3, 0x87, 0x5f, 0x38, + 0xc2, 0xdd, 0x12, 0xd7, 0xf7, 0x17, 0xbd, 0x7f, 0xb7, 0x01, 0xa9, 0xfe, 0xcd, 0xa5, + 0xed, 0x8b, 0x76, 0x4c, 0x9a, 0x35, 0xd4, 0xa5, 0xc1, 0xd8, 0x93, 0x0f, 0x60, 0x71, + 0xf6, 0x53, 0xee, 0xbb, 0x2d, 0x1a, 0xfa, 0x77, 0xde, 0xbb, 0x83, 0x02, 0xd1, 0x6f, + 0x17, 0xe0, 0xf5, 0xf3, 0x92, 0x0a, 0x71, 0xa4, 0xd4, 0x9b, 0xea, 0xfa, 0x0e, 0x1c, + 0x7e, 0x44, 0x3f, 0x8a, 0xbc, 0xa6, 0x4a, 0x65, 0xa9, 0xe8, 0x1a, 0x97, 0xe7, 0x35, + 0x7b, 0xf9, 0x02, 0x57, 0x33, 0x63, 0xc0, 0xe1, 0xa1, 0x2e, 0x52, 0x28, 0x03, 0x68, + 0x28, 0xe3, 0xf7, 0x59, 0x12, 0x1f, 0xad, 0xa9, 0x24, 0x41, 0xfe, 0x33, 0x4e, 0x85, + 0xd7, 0x93, 0x47, 0xe4, 0x70, 0xd2, 0xfe, 0xd9, 0x45, 0x54, 0x1d, 0x83, 0x2c, 0x54, + 0xba, 0xaa, 0x3c, 0xb7, 0x52, 0x6c, 0x38, 0x53, 0x95, 0x4d, 0xb4, 0xf7, 0x35, 0x47, + 0xcc, 0x7c, 0x27, 0xfd, 0x38, 0x39, 0x8b, 0xfa, 0x77, 0x04, 0x95, 0x2c, 0xb8, 0x41, + 0xe3, 0x8b, 0x27, 0x0e, 0x4d, 0xb7, 0x43, 0x5f, 0x0e, 0xe2, 0x2f, 0x57, 0xd7, 0xad, + 0x32, 0x70, 0xbd, 0x0c, 0x88, 0xe7, 0x1b, 0x4b, 0x86, 0x4c, 0xf2, 0x27, 0x7c, 0x65, + 0xda, 0xa1, 0x0a, 0x6d, 0xad, 0x4c, 0x7a, 0xbe, 0xcd, 0x95, 0xcc, 0x4e, 0xbe, 0xc3, + 0x9c, 0x08, 0x40, 0x4b, 0x52, 0x2e, 0x4e, 0xcc, 0x15, 0x45, 0x71, 0x3f, 0x76, 0xbe, + 0xbd, 0x3b, 0x5a, 0x0f, 0x2f, 0xeb, 0x34, 0x61, 0x93, 0x60, 0x65, 0xdb, 0xd1, 0x3f, + 0x6a, 0x1f, 0x61, 0xe1, 0xb1, 0x42, 0xa2, 0xaf, 0x2e, 0x5a, 0x48, 0x2b, 0xa2, 0xc5, + 0x0c, 0xf0, 0x31, 0x70, 0x49, 0xc0, 0xb3, 0xbf, 0xd6, 0xd5, 0xe9, 0x24, 0x0e, 0xba, + 0x91, 0x11, 0xd2, 0x03, 0x0f, 0xde, 0xa1, 0x7e, 0x33, 0xb6, 0x52, 0x40, 0x20, 0xd3, + 0x0b, 0x0c, 0x4f, 0x80, 0x69, 0x28, 0x5f, 0x3a, 0x6c, 0xa2, 0x67, 0xd2, 0x87, 0xd0, + 0x1e, 0x82, 0x7d, 0x84, 0x22, 0xbf, 0x54, 0x26, 0xe1, 0x16, 0x88, 0xbf, 0xc7, 0x37, + 0x56, 0xaf, 0x18, 0x41, 0xb1, 0xc8, 0x7e, 0x12, 0x6c, 0xb5, 0x0c, 0x91, 0x4b, 0x5b, + 0x2b, 0x86, 0x73, 0x48, 0x8a, 0xd3, 0xb0, 0x74, 0xca, 0xd7, 0x7a, 0x38, 0x40, 0xeb, + 0x12, 0xdd, 0x68, 0x8f, 0x31, 0x3e, 0xe1, 0xe9, 0xff, 0x8c, 0x47, 0x9a, 0x67, 0x8f, + 0x27, 0x63, 0x56, 0xfc, 0x9d, 0x65, 0xe1, 0xd5, 0xb4, 0xc1, 0xe9, 0x85, 0x5b, 0x41, + 0x75, 0xdb, 0x14, 0x4f, 0x77, 0x67, 0xc1, 0x20, 0x61, 0x76, 0x91, 0x90, 0xfe, 0x6b, + 0x5e, 0x51, 0x56, 0x3b, 0x91, 0xf9, 0x4d, 0x13, 0x1a, 0x2b, 0x79, 0x6b, 0xd2, 0x98, + 0x0e, 0xd0, 0xda, 0xb4, 0xae, 0x7a, 0x71, 0x10, 0xe9, 0x20, 0x00, 0x7a, 0x75, 0x71, + 0x58, 0xa5, 0xeb, 0x86, 0x62, 0xcb, 0xf8, 0x9d, 0xdf, 0xfe, 0x9d, 0x81, 0x96, 0x82, + 0x13, 0x13, 0xcd, 0xc0, 0x01, 0x08, 0x85, 0x3f, 0xc4, 0x74, 0x6b, 0x11, 0x1d, 0x5b, + 0x56, 0xda, 0x63, 0x8d, 0x8e, 0xd2, 0x97, 0x39, 0x18, 0x96, 0x0f, 0x5d, 0xfe, 0x93, + 0xea, 0xd3, 0xae, 0x52, 0x1e, 0x95, 0x7c, 0xec, 0x3c, 0x8d, 0x84, 0x3e, 0x8f, 0xce, + 0x23, 0x4c, 0x70, 0xad, 0x05, 0x51, 0x77, 0xf2, 0x35, 0x43, 0x9d, 0x60, 0x98, 0xbd, + 0xd7, 0x71, 0xb1, 0xcf, 0xcf, 0xad, 0xaa, 0xb4, 0xf5, 0x0a, 0x73, 0x78, 0x18, 0x5c, + 0x62, 0x40, 0x9f, 0x38, 0x3c, 0x8f, 0xf6, 0x58, 0xc2, 0xa2, 0xaf, 0x66, 0x49, 0x8c, + 0xfd, 0x81, 0xe9, 0x62, 0x76, 0x6a, 0xc6, 0xb7, 0x74, 0xe8, 0x84, 0x24, 0xfb, 0x4f, + 0x33, 0x18, 0x37, 0xd0, 0xa2, 0x85, 0x02, 0x70, 0x84, 0x77, 0xca, 0xf8, 0x78, 0x0a, + 0x15, 0x6d, 0x72, 0x3f, 0x68, 0xfc, 0xa7, 0x91, 0xe1, 0xcd, 0x23, 0x97, 0xbf, 0xc2, + 0xb2, 0x4c, 0x77, 0xc7, 0x65, 0xd9, 0xb2, 0xaf, 0x36, 0xf7, 0x32, 0xd5, 0x21, 0x07, + 0x51, 0x7e, 0xfd, 0x81, 0x57, 0xb2, 0x83, 0xb4, 0x40, 0xa6, 0x13, 0xf7, 0x56, 0xc3, + 0x64, 0xca, 0x10, 0x89, 0x71, 0xa8, 0x87, 0x81, 0x99, 0xa9, 0x3f, 0x26, 0x0b, 0xae, + 0xc3, 0xe8, 0x50, 0x03, 0x3c, 0xc0, 0x32, 0xc2, 0xe5, 0x3f, 0x82, 0x35, 0x76, 0xaf, + 0xfb, 0x4d, 0x3b, 0x11, 0x6e, 0x2d, 0x16, 0x04, 0x91, 0x52, 0xc3, 0x5a, 0xaa, 0x26, + 0x3a, 0xb3, 0x76, 0xf0, 0xad, 0x5e, 0xde, 0x6a, 0x74, 0x96, 0x07, 0xa2, 0x83, 0xe3, + 0x01, 0x6e, 0x62, 0x19, 0x1c, 0x0e, 0x8f, 0xde, 0x33, 0xe7, 0x18, 0xcd, 0x98, 0x95, + 0x91, 0xc9, 0xa2, 0x05, 0xd6, 0x08, 0xd9, 0x9f, 0xcb, 0x8a, 0x74, 0x71, 0x60, 0x3d, + 0x71, 0x6c, 0xb0, 0x1b, 0x56, 0x32, 0x8d, 0x7d, 0x88, 0x0a, 0xec, 0x28, 0x51, 0xf4, + 0xe6, 0xd8, 0xb5, 0x01, 0x6c, 0x25, 0x64, 0x7e, 0x90, 0x26, 0xeb, 0xb4, 0x41, 0x54, + 0x3e, 0x80, 0x12, 0xdb, 0xfc, 0xf0, 0x78, 0xd4, 0x01, 0x2b, 0x8c, 0x39, 0x18, 0x4d, + 0xd6, 0x4f, 0x38, 0x21, 0xb4, 0x77, 0x4a, 0xe4, 0xe3, 0x63, 0x65, 0xf8, 0xba, 0xf2, + 0xbd, 0x1f, 0x66, 0x67, 0xc0, 0x17, 0xa1, 0xe6, 0x5f, 0xf8, 0xa1, 0x55, 0x44, 0x58, + 0xfb, 0x3f, 0x36, 0x7c, 0x02, 0x72, 0x17, 0x52, 0xbf, 0xa5, 0x6f, 0xc7, 0xfd, 0x56, + 0x6a, 0xe9, 0x5f, 0xfb, 0x20, 0x8f, 0x91, 0x9e, 0xf1, 0x2f, 0x4c, 0xf8, 0xa2, 0xfd, + 0xd1, 0x41, 0xa8, 0xdf, 0x55, 0x9b, 0xdd, 0xb7, 0xb8, 0xd1, 0xf0, 0x4e, 0xe6, 0xd4, + 0xcf, 0x78, 0x05, 0xd1, 0x42, 0x98, 0x9c, 0xaf, 0x21, 0x6d, 0xfa, 0xe9, 0x85, 0xfa, + 0xaa, 0xb9, 0x97, 0x4f, 0x6d, 0x9f, 0x8a, 0xa1, 0x12, 0x90, 0x84, 0xdb, 0x8d, 0xb9, + 0x12, 0xb1, 0x65, 0x5f, 0x59, 0x5f, 0xfb, 0xaa, 0x66, 0x49, 0x1a, 0xb4, 0x65, 0x5f, + 0xd7, 0x34, 0xcf, 0xd4, 0xbb, 0x0c, 0x02, 0x89, 0xd4, 0xbc, 0xc8, 0xfc, 0x5e, 0x99, + 0x43, 0xb3, 0x51, 0xcb, 0x14, 0x7c, 0x8d, 0xb0, 0x59, 0xa2, 0x40, 0x04, 0xd1, 0xc3, + 0xe3, 0xbb, 0x4c, 0x14, 0xa8, 0x81, 0xe5, 0x10, 0x1a, 0xcb, 0x73, 0x6c, 0x65, 0xc5, + 0xd5, 0x79, 0xac, 0xb6, 0x7e, 0xe8, 0x5a, 0x56, 0x02, 0x77, 0xb4, 0x33, 0x38, 0xfe, + 0x79, 0xd3, 0x4b, 0x77, 0x2c, 0x5d, 0xa0, 0x01, 0xda, 0x3b, 0x5a, 0x33, 0x83, 0xdd, + 0x81, 0x31, 0x9a, 0x0b, 0x45, 0x42, 0xe6, 0xd7, 0xe4, 0x6e, 0xed, 0x53, 0x14, 0xcc, + 0x70, 0xeb, 0x23, 0x1d, 0xe2, 0x7b, 0x6e, 0x76, 0x0d, 0xb5, 0x98, 0xba, 0x19, 0x99, + 0x5c, 0xf6, 0x9b, 0xe0, 0xe4, 0x45, 0x8e, 0x35, 0xf3, 0xf2, 0x74, 0xac, 0xa2, 0x45, + 0x5d, 0x43, 0xfe, 0x33, 0x44, 0xe1, 0x83, 0xc6, 0xdc, 0x47, 0xc8, 0x57, 0xdb, 0xe9, + 0x90, 0x7b, 0x41, 0xe4, 0x10, 0x06, 0xd9, 0x1b, 0x25, 0xad, 0xca, 0xfc, 0x09, 0x8f, + 0xe6, 0x6f, 0x75, 0x54, 0xbe, 0x8d, 0xad, 0x49, 0x3c, 0x4f, 0x4b, 0x1d, 0xbf, 0x7a, + 0x51, 0x46, 0x41, 0x39, 0xdb, 0x47, 0x4a, 0xfa, 0xb5, 0x57, 0x2f, 0x92, 0xa2, 0x23, + 0x2b, 0x59, 0xbe, 0x56, 0xa7, 0x2c, 0x05, 0x05, 0x14, 0x9d, 0xae, 0x5c, 0xde, 0x1e, + 0x60, 0x28, 0x77, 0x03, 0x7d, 0xe7, 0x80, 0x2b, 0x5f, 0x6f, 0xa4, 0x7a, 0x4c, 0x9a, + 0x3e, 0x52, 0xd6, 0xca, 0x15, 0x33, 0x99, 0x20, 0x25, 0x4e, 0x9f, 0xfb, 0x53, 0xc7, + 0xb8, 0x34, 0xcc, 0x02, 0x88, 0xed, 0x99, 0x05, 0xa1, 0x84, 0x1e, 0x93, 0x90, 0xea, + 0x94, 0xa8, 0x89, 0x8b, 0xd4, 0xc6, 0xb6, 0xd6, 0x02, 0x7e, 0x4d, 0x43, 0xc7, 0x86, + 0x72, 0x42, 0x51, 0x5b, 0xbe, 0xef, 0xe1, 0x23, 0x40, 0xfc, 0x04, 0x42, 0x8a, 0x82, + 0x4e, 0xa7, 0xcf, 0x56, 0xad, 0x2a, 0x64, 0xed, 0x36, 0x8b, 0x71, 0x31, 0x5d, 0x80, + 0xce, 0xe8, 0x46, 0x00, 0x7c, 0xff, 0x1d, 0x2e, 0xea, 0x2c, 0x3f, 0x0f, 0x92, 0x15, + 0x37, 0x30, 0x4a, 0xe5, 0x98, 0xf9, 0x8d, 0xd1, 0x0d, 0x1f, 0x10, 0x28, 0x11, 0xa4, + 0xe2, 0xd1, 0x61, 0xc3, 0xfd, 0x8b, 0xbb, 0x19, 0x3d, 0x4b, 0x25, 0xbe, 0xe9, 0x50, + 0xac, 0x83, 0x9c, 0x0f, 0x9d, + ], + ss: [ + 0x9b, 0xd0, 0x18, 0xe8, 0x69, 0xbb, 0x01, 0xb6, 0x3f, 0xb8, 0xf5, 0xda, 0x37, 0x4a, + 0x73, 0xd3, 0x47, 0xea, 0x14, 0xcb, 0x2b, 0xc5, 0x70, 0xb1, 0x3d, 0x09, 0x08, 0xe2, + 0x28, 0x8e, 0xc4, 0x56, + ], + }, + TestVector { + seed: [0x01; 32], + randomness: [0x65; 128], + ek: &[ + 0xec, 0x7b, 0x50, 0xcd, 0xdc, 0x83, 0x60, 0xf9, 0x8b, 0x18, 0x9b, 0xac, 0x73, 0xd3, + 0x95, 0xef, 0x94, 0x7b, 0x37, 0xd8, 0x45, 0x38, 0x86, 0xa2, 0x53, 0x26, 0x9f, 0x7b, + 0x18, 0xb9, 0xeb, 0x78, 0xc1, 0xb6, 0x32, 0x12, 0x47, 0x1a, 0x0f, 0x97, 0x97, 0x93, + 0xf9, 0x93, 0x6b, 0x3f, 0x49, 0x6f, 0x4b, 0x53, 0x94, 0xea, 0x69, 0xc2, 0xa3, 0x57, + 0x29, 0xf9, 0x1c, 0x68, 0x8f, 0x6b, 0xbb, 0xb8, 0x64, 0xcd, 0x5e, 0x87, 0x10, 0x86, + 0x76, 0xc4, 0x01, 0x4c, 0x2b, 0xa9, 0x82, 0x04, 0xf9, 0x11, 0xbe, 0xca, 0xe3, 0x3a, + 0x71, 0xe8, 0x32, 0xac, 0x01, 0x2b, 0xb8, 0x27, 0x57, 0x88, 0x10, 0x95, 0x5f, 0x8c, + 0x6e, 0x2d, 0x26, 0xc0, 0xb1, 0x7b, 0x7b, 0xa5, 0x74, 0x99, 0x08, 0x84, 0x54, 0x6b, + 0xa5, 0x8b, 0xf6, 0x78, 0x57, 0x21, 0xf3, 0x85, 0x4f, 0x43, 0x4c, 0xfe, 0xa6, 0x02, + 0xe8, 0x59, 0x5c, 0x71, 0x64, 0x2e, 0x8d, 0x4c, 0x70, 0x93, 0x4b, 0x7e, 0x54, 0xc6, + 0x38, 0xf5, 0xa1, 0x3e, 0x1a, 0x13, 0x6b, 0xc8, 0x65, 0x65, 0xe6, 0xb4, 0x0a, 0xbc, + 0x16, 0x3c, 0xa6, 0x56, 0x50, 0xba, 0xf9, 0x53, 0xde, 0x7b, 0xb9, 0x9b, 0x13, 0x8a, + 0xc1, 0xb6, 0x95, 0x02, 0x31, 0x03, 0xc9, 0xb4, 0x17, 0x85, 0x3c, 0x9d, 0x42, 0xe5, + 0x4f, 0xdb, 0x81, 0x61, 0x74, 0x65, 0x9d, 0x85, 0xa7, 0x83, 0xe3, 0xd4, 0x61, 0x3d, + 0xb1, 0xcb, 0xba, 0xa6, 0x3f, 0xb6, 0x67, 0xa4, 0xa6, 0x36, 0x80, 0x4b, 0x6c, 0x4a, + 0xe8, 0x21, 0xac, 0x5d, 0x65, 0x56, 0x68, 0x8b, 0xab, 0x1d, 0xc1, 0x0d, 0x67, 0x79, + 0xb4, 0x85, 0xc6, 0x3c, 0x0d, 0xda, 0xcb, 0x91, 0x83, 0x7c, 0x4f, 0xf3, 0x40, 0x2e, + 0x62, 0x14, 0x18, 0x80, 0x72, 0xb4, 0x18, 0x6a, 0x39, 0xc6, 0x5b, 0xde, 0x52, 0x4c, + 0x68, 0x3c, 0x95, 0xd3, 0xc8, 0xb6, 0x5e, 0x37, 0x10, 0x4f, 0x55, 0x1b, 0x6a, 0x36, + 0x02, 0xed, 0xa5, 0x0b, 0x78, 0x71, 0x82, 0xd7, 0x03, 0xac, 0x6a, 0x22, 0x14, 0x28, + 0xb4, 0x55, 0x3e, 0x3b, 0x99, 0xc2, 0xb2, 0x51, 0xef, 0x64, 0x2e, 0x31, 0x25, 0x6c, + 0x32, 0x9b, 0x21, 0xd1, 0x24, 0x6a, 0x71, 0x45, 0x6f, 0xce, 0x70, 0x0d, 0x7f, 0x50, + 0xcf, 0xe5, 0x39, 0x0a, 0x1c, 0x37, 0xbc, 0x13, 0x38, 0x09, 0xf1, 0x02, 0xc2, 0x29, + 0x14, 0xa1, 0x40, 0x2c, 0x20, 0x5c, 0x05, 0x12, 0xb7, 0x33, 0xaf, 0xee, 0xa0, 0x44, + 0x11, 0xca, 0x5e, 0xbb, 0x0b, 0xca, 0x93, 0x92, 0xb1, 0xee, 0x23, 0x93, 0x5e, 0xb1, + 0x96, 0x02, 0x47, 0x32, 0xda, 0xa2, 0xa1, 0xf7, 0x93, 0x58, 0xe6, 0xe7, 0x4b, 0x73, + 0xc9, 0x65, 0xa9, 0xe7, 0x47, 0x78, 0xdc, 0x69, 0x21, 0x44, 0x2b, 0x19, 0x32, 0x8f, + 0x62, 0x16, 0xa5, 0xe8, 0x14, 0xcc, 0xc0, 0x63, 0x9a, 0x86, 0x3a, 0x43, 0x7a, 0x61, + 0x4d, 0xef, 0x5a, 0x61, 0xf3, 0x88, 0x52, 0x15, 0x10, 0x11, 0xb0, 0x4a, 0x37, 0xbb, + 0xc7, 0x8c, 0x1e, 0xba, 0x4d, 0x8d, 0x1b, 0x3a, 0x16, 0x22, 0xa0, 0xdf, 0xf7, 0x4d, + 0x25, 0xc7, 0x31, 0xab, 0xb2, 0xa5, 0xfe, 0x59, 0x19, 0xf8, 0x35, 0xbd, 0x3d, 0xd9, + 0x73, 0x30, 0xcb, 0xb7, 0xdb, 0xa0, 0xb7, 0x42, 0x60, 0xc9, 0x63, 0x40, 0x21, 0x60, + 0xc4, 0x01, 0x7d, 0x92, 0x25, 0x6a, 0x37, 0x13, 0xc9, 0xe7, 0x7e, 0xa0, 0xf4, 0x90, + 0x1a, 0xcc, 0xbd, 0x38, 0x71, 0x55, 0x11, 0x78, 0x4c, 0x9e, 0xc2, 0x87, 0xdd, 0x85, + 0xa7, 0x69, 0xe0, 0x81, 0x85, 0x4b, 0x32, 0xab, 0xa9, 0x32, 0x2a, 0x38, 0x40, 0xf6, + 0x06, 0x51, 0x33, 0x22, 0x8c, 0x41, 0x85, 0x1a, 0xfc, 0xb4, 0x0e, 0xa5, 0x09, 0xcf, + 0xbb, 0x86, 0x14, 0x5f, 0xb8, 0x85, 0x3c, 0xe1, 0x4c, 0x64, 0x96, 0x91, 0x13, 0x6b, + 0x86, 0x60, 0xb0, 0x07, 0x7f, 0x3b, 0x2f, 0x9d, 0xa8, 0x2d, 0x48, 0x3c, 0x14, 0x14, + 0xc3, 0x9a, 0x97, 0x77, 0x66, 0x58, 0x99, 0x13, 0x1a, 0x83, 0x36, 0xfb, 0x82, 0x84, + 0x80, 0x98, 0x6d, 0xf1, 0x02, 0x62, 0x8d, 0x10, 0xb5, 0x42, 0x39, 0xcc, 0x20, 0x23, + 0x14, 0x57, 0xd4, 0xbb, 0xb7, 0x01, 0x6f, 0x76, 0x02, 0x96, 0x61, 0xf1, 0x4f, 0xfd, + 0x35, 0x32, 0xe2, 0xf8, 0x49, 0x4e, 0x16, 0x13, 0x43, 0x07, 0x30, 0xab, 0x91, 0x56, + 0x83, 0xc3, 0xc8, 0xc4, 0xdb, 0x2b, 0x43, 0x73, 0xa3, 0x05, 0x7a, 0x09, 0x7e, 0x23, + 0x33, 0x36, 0x05, 0x39, 0x8b, 0x15, 0xcc, 0x4d, 0x6a, 0xc3, 0xfb, 0xd0, 0x73, 0x2f, + 0x21, 0x02, 0x6b, 0xb0, 0xcd, 0x51, 0xfb, 0x73, 0x8a, 0x74, 0x04, 0x67, 0x11, 0x4e, + 0x7c, 0x66, 0x25, 0x6b, 0x83, 0x00, 0x22, 0xf2, 0x8c, 0x02, 0x83, 0x92, 0xcf, 0xf8, + 0x01, 0x3d, 0x61, 0x7c, 0x77, 0xa4, 0x7b, 0xbd, 0xa1, 0x1c, 0x4a, 0x52, 0x2f, 0x8f, + 0x2b, 0x49, 0xf2, 0x82, 0x2c, 0xc0, 0x63, 0x38, 0x60, 0x56, 0x71, 0xfc, 0xa4, 0x51, + 0x8d, 0xf9, 0xb3, 0xc5, 0x06, 0x53, 0x2c, 0x9c, 0xca, 0x31, 0x75, 0x33, 0x0f, 0x87, + 0x33, 0xce, 0x11, 0xcb, 0x3f, 0xd8, 0xb9, 0x52, 0x39, 0xce, 0xeb, 0xc9, 0x48, 0x3c, + 0xb6, 0x8b, 0xff, 0x43, 0xb6, 0x22, 0x91, 0x1f, 0xcf, 0x4a, 0x9c, 0x57, 0xc2, 0x26, + 0xca, 0xa3, 0x8b, 0xf0, 0xb0, 0x81, 0x53, 0x59, 0x99, 0xf5, 0x73, 0x01, 0x6b, 0x14, + 0x56, 0x3e, 0xc4, 0x82, 0x6d, 0xc2, 0x81, 0xdb, 0xab, 0xc6, 0x33, 0x86, 0x8a, 0x1d, + 0x90, 0x3d, 0x59, 0x20, 0x7f, 0xc6, 0x62, 0xa2, 0x93, 0x73, 0x50, 0x85, 0xc0, 0x1f, + 0x40, 0xb5, 0xb5, 0x6c, 0xbb, 0x79, 0x5e, 0xca, 0xbf, 0xad, 0x70, 0x9d, 0x61, 0x1c, + 0xac, 0x73, 0xea, 0xca, 0x57, 0x97, 0x68, 0x21, 0x3c, 0x18, 0xc9, 0x69, 0xc5, 0x9b, + 0xe5, 0x8f, 0xce, 0xf6, 0xbd, 0xd8, 0xa8, 0x51, 0x92, 0x90, 0x7c, 0xd0, 0x77, 0x3f, + 0x81, 0xea, 0xa2, 0x4b, 0xe0, 0x7e, 0x0d, 0x62, 0x0e, 0x96, 0x85, 0xac, 0xb0, 0xc6, + 0xb0, 0xf5, 0x4b, 0x47, 0xdf, 0xfb, 0x51, 0x03, 0x84, 0x24, 0x1c, 0x4b, 0x73, 0x3f, + 0xe0, 0x8d, 0xac, 0xb2, 0x85, 0x2b, 0x2b, 0x74, 0xcc, 0x01, 0x4e, 0x97, 0x4a, 0x5e, + 0x9d, 0xb3, 0x5d, 0x80, 0xd7, 0xb8, 0x3a, 0xd3, 0x1d, 0xa1, 0x48, 0x7a, 0x01, 0x70, + 0xba, 0x7f, 0xbc, 0x1c, 0x55, 0x1a, 0x6f, 0x1e, 0xec, 0xb5, 0x72, 0x08, 0x41, 0x80, + 0xb2, 0x56, 0x96, 0x27, 0x48, 0xd5, 0xe3, 0x20, 0x0b, 0x73, 0x1a, 0xc7, 0xc3, 0x92, + 0x85, 0x85, 0xa1, 0x53, 0xb1, 0x67, 0xc9, 0x2a, 0x48, 0xcd, 0x91, 0x66, 0x8c, 0x77, + 0x37, 0x07, 0xc0, 0x54, 0xaf, 0x16, 0xaa, 0x7b, 0xfa, 0xca, 0xa1, 0x61, 0xa6, 0x20, + 0x60, 0x0e, 0x8d, 0x08, 0xcc, 0x97, 0x60, 0x1a, 0x53, 0x39, 0x1d, 0xa0, 0x24, 0x7e, + 0x5f, 0xca, 0x60, 0xcd, 0x1b, 0xb6, 0x5e, 0xc0, 0x41, 0x71, 0x77, 0xa9, 0xeb, 0x78, + 0xcd, 0xe5, 0xaa, 0x1d, 0xfa, 0xe3, 0x4e, 0x94, 0x84, 0x17, 0xb3, 0xcc, 0x0b, 0x22, + 0x38, 0x03, 0xf5, 0xf4, 0x0e, 0x8a, 0xe3, 0xa3, 0x82, 0x84, 0x8f, 0xf8, 0x0c, 0x41, + 0x85, 0x82, 0x40, 0x76, 0x42, 0x3a, 0xe4, 0xc1, 0x37, 0xbd, 0x30, 0xbd, 0x81, 0xf0, + 0x40, 0x95, 0xc2, 0x0a, 0x01, 0xe0, 0xa4, 0x9f, 0x66, 0x4f, 0x8f, 0x2b, 0x7f, 0x6b, + 0xf6, 0xa9, 0x90, 0x99, 0x3c, 0xbc, 0x05, 0x96, 0xa5, 0x14, 0xcc, 0xeb, 0xc5, 0x78, + 0xc6, 0x41, 0x8e, 0x82, 0x59, 0x03, 0xae, 0x11, 0xac, 0x52, 0x83, 0x1c, 0x6a, 0x48, + 0xc6, 0x77, 0x27, 0x40, 0x9e, 0xd7, 0x27, 0x4e, 0xea, 0x03, 0xee, 0xf3, 0x20, 0x94, + 0x27, 0x1b, 0x02, 0xd4, 0x53, 0x55, 0x63, 0xaa, 0x49, 0x24, 0xa2, 0x66, 0x68, 0x71, + 0xa4, 0xb6, 0x90, 0x54, 0x0c, 0x78, 0xb0, 0x60, 0x43, 0xbc, 0xa3, 0x1c, 0xa4, 0xe4, + 0x2a, 0x03, 0x65, 0x0e, 0xca, 0xb7, 0x47, 0x92, 0x01, 0x72, 0x17, 0xd1, 0x06, 0x15, + 0xd0, 0xac, 0xde, 0xe1, 0x24, 0xe3, 0x22, 0x2c, 0x90, 0xd7, 0x93, 0x62, 0x20, 0x7e, + 0x4f, 0x77, 0x79, 0xe0, 0x97, 0x50, 0x1c, 0xf1, 0x40, 0xb1, 0xa3, 0x43, 0x1e, 0xe0, + 0xcf, 0x27, 0xb2, 0x3a, 0x50, 0x37, 0x3d, 0x59, 0x97, 0x6d, 0x82, 0xb5, 0xb1, 0xce, + 0x16, 0x5f, 0x4a, 0xa1, 0x36, 0x11, 0x57, 0xaf, 0xad, 0x56, 0x40, 0x81, 0xc8, 0x57, + 0x77, 0x58, 0x4d, 0xd6, 0x05, 0x8a, 0x1a, 0x46, 0x63, 0xb5, 0x32, 0x34, 0xd7, 0x26, + 0x4f, 0xba, 0xc6, 0x87, 0x73, 0x51, 0xd1, 0x92, 0x8c, 0x67, 0x80, 0xf7, 0x7d, 0x47, + 0x20, 0x93, 0x37, 0x27, 0x1e, 0x30, 0x53, 0x70, 0xdf, 0x9a, 0xef, 0xfb, 0x74, 0xd7, + 0xc7, 0x5d, 0xe5, 0x5c, 0x00, 0x6e, 0x2b, 0x2a, 0x04, 0x7a, 0x93, 0xf1, 0x83, 0x3d, + 0xa6, 0xf7, 0xc4, 0x22, 0x6f, 0x8c, 0x05, 0x39, 0x2b, 0xa9, 0x06, 0x26, 0xe4, 0xed, + 0x81, 0xbc, 0x9d, 0xff, 0x57, 0x3a, 0xa2, 0x43, 0x05, 0x5f, 0x08, 0xa5, 0x67, 0xe2, + 0x95, 0x77, 0xce, 0x8d, 0xaf, 0xa0, 0x82, 0x97, 0xe6, 0xb0, 0x4a, 0x77, 0x9b, 0xed, + 0x85, 0x2b, 0x95, 0xec, 0x0a, 0xc1, 0x4e, 0x04, 0xb1, 0xcb, 0x58, 0xeb, 0x65, 0x64, + 0x55, 0xba, 0xd9, + ], + dk: [0x01; 32], + dk_pq: [ + 0xdb, 0xf7, 0x7c, 0x8d, 0x79, 0xc8, 0x0a, 0xd6, 0xb0, 0x76, 0x3d, 0x42, 0xa3, 0xfe, + 0x53, 0xf0, 0xf1, 0xdc, 0x03, 0x02, 0x20, 0xc2, 0xe3, 0xfe, 0xdc, 0x2a, 0xa9, 0x03, + 0xab, 0xfc, 0xad, 0x08, 0x33, 0x0d, 0xb4, 0xba, 0x49, 0x0c, 0xce, 0xe0, 0x95, 0x98, + 0x8d, 0x93, 0x55, 0xe8, 0x16, 0x05, 0x5c, 0xf9, 0x86, 0xe2, 0x80, 0x53, 0x2d, 0x47, + 0xcc, 0x19, 0xf2, 0x24, 0x0c, 0xc2, 0x34, 0x19, + ], + dk_t: [ + 0xa2, 0x03, 0x15, 0x48, 0x5f, 0x73, 0xa3, 0xc1, 0x7e, 0x18, 0xa3, 0xf1, 0x55, 0xac, + 0x33, 0xe9, 0xa9, 0x80, 0x89, 0x6b, 0x2f, 0x17, 0xdc, 0x7f, 0x96, 0xa9, 0x49, 0x5d, + 0x95, 0x84, 0x05, 0x60, + ], + ct: &[ + 0x60, 0x0e, 0xcf, 0x40, 0x26, 0x68, 0x38, 0x98, 0xd0, 0xe3, 0x39, 0xee, 0xea, 0x9e, + 0xbd, 0x43, 0x7a, 0x4a, 0x80, 0x29, 0x52, 0xbf, 0x32, 0xbf, 0xa3, 0x26, 0xb4, 0x8e, + 0xb7, 0x49, 0x46, 0xd0, 0xcd, 0xd5, 0x43, 0x7e, 0x70, 0xdf, 0x4b, 0x6b, 0x7a, 0xcb, + 0xf7, 0x9e, 0xfe, 0x60, 0xdd, 0xcd, 0xe9, 0x85, 0xac, 0xfd, 0x8c, 0x2d, 0x23, 0x77, + 0x5e, 0x1e, 0xcc, 0x54, 0xeb, 0x6e, 0xe0, 0x3d, 0xcc, 0x9b, 0x4a, 0xac, 0x15, 0x01, + 0x72, 0x73, 0x78, 0x31, 0xad, 0xfa, 0xf0, 0xe6, 0x3a, 0x47, 0x82, 0xba, 0xd2, 0xa7, + 0x85, 0xb9, 0xc3, 0x9b, 0xf5, 0xe3, 0x46, 0x40, 0xea, 0x3d, 0xa4, 0x47, 0xef, 0xc2, + 0xa0, 0x3e, 0x23, 0xa3, 0x37, 0xad, 0x1f, 0x54, 0x2c, 0x32, 0xc2, 0xeb, 0x46, 0xf7, + 0xb8, 0x8d, 0x0b, 0xfb, 0xa8, 0x7d, 0x8e, 0xfe, 0x8c, 0xd4, 0x45, 0x6e, 0x6f, 0x21, + 0xbe, 0xeb, 0xcf, 0x3d, 0xd5, 0x02, 0xb5, 0x3d, 0x53, 0x73, 0x95, 0x75, 0x0c, 0xe9, + 0x63, 0xd2, 0x89, 0xef, 0xf7, 0x46, 0x21, 0x54, 0x5d, 0x4a, 0x5d, 0x92, 0x62, 0xbd, + 0x14, 0xb3, 0xdd, 0xdd, 0x4e, 0xf8, 0x80, 0xe6, 0x5c, 0xbe, 0x8f, 0x2f, 0x8a, 0xad, + 0x82, 0x6f, 0x57, 0xf7, 0x27, 0xa6, 0x0a, 0xaa, 0xee, 0xe8, 0xc6, 0x9e, 0x89, 0xaf, + 0x6c, 0x53, 0x9f, 0xd4, 0xf2, 0x67, 0xc4, 0x4b, 0xee, 0x8b, 0x53, 0x85, 0xa4, 0x60, + 0xa7, 0xc8, 0xe4, 0xa8, 0x09, 0x95, 0x9d, 0xf8, 0x6c, 0x11, 0x36, 0xee, 0x23, 0xe7, + 0x54, 0x4c, 0xfa, 0x75, 0x24, 0xc6, 0xc0, 0x4e, 0xd9, 0xec, 0x29, 0xae, 0xd3, 0x07, + 0xb5, 0xdf, 0xd0, 0x10, 0x8f, 0x29, 0x29, 0x4a, 0xce, 0xeb, 0x51, 0x7a, 0x09, 0x8b, + 0x8c, 0xdb, 0xad, 0x59, 0x11, 0xbc, 0x75, 0xe9, 0x62, 0x58, 0xbb, 0xf3, 0x8a, 0x20, + 0x28, 0x8c, 0x69, 0x11, 0xb2, 0x34, 0x6f, 0x84, 0x2c, 0x09, 0x43, 0xbf, 0x8e, 0x9c, + 0x34, 0xa0, 0xa8, 0xe5, 0x18, 0xe9, 0x2c, 0x87, 0x61, 0xc6, 0xef, 0xe6, 0xb1, 0xd3, + 0xea, 0x8a, 0xed, 0x9b, 0x2c, 0x4f, 0xea, 0xcf, 0xbf, 0x35, 0x59, 0xf3, 0xa5, 0xe4, + 0x6e, 0x4d, 0xfd, 0xdf, 0x81, 0x93, 0x61, 0x83, 0xd4, 0xd1, 0xf9, 0xc8, 0xc1, 0x61, + 0x6b, 0x14, 0xdb, 0x20, 0x57, 0x43, 0x5a, 0xd7, 0x16, 0x55, 0xd7, 0x43, 0xfa, 0xd4, + 0x98, 0x7a, 0x19, 0xe8, 0x21, 0xd0, 0xac, 0x66, 0x6f, 0xf3, 0xe4, 0x6b, 0x7c, 0xc0, + 0xe9, 0x0b, 0x85, 0xe1, 0x96, 0x69, 0x62, 0x27, 0x9a, 0x48, 0xaf, 0xe2, 0xe9, 0xbb, + 0xce, 0x89, 0xc8, 0x19, 0xa8, 0xba, 0x52, 0x47, 0x6a, 0xf0, 0x74, 0xa0, 0x71, 0x49, + 0x53, 0x98, 0xbd, 0x49, 0x7f, 0x4d, 0x4f, 0x34, 0x02, 0x60, 0x25, 0x45, 0x29, 0x75, + 0xcf, 0xda, 0xa3, 0xe7, 0xe1, 0x83, 0xa9, 0x62, 0xbd, 0xa0, 0x09, 0x10, 0x82, 0x21, + 0xec, 0xb2, 0x0d, 0x21, 0x8c, 0x42, 0xe3, 0x87, 0x74, 0x01, 0x9d, 0x2d, 0xc3, 0x26, + 0x21, 0x27, 0x8b, 0x5e, 0x88, 0xf9, 0x9b, 0x62, 0xa9, 0xe7, 0x46, 0xd1, 0x6c, 0x16, + 0x91, 0xcc, 0xf3, 0xe7, 0xe9, 0x18, 0x5c, 0x3c, 0x49, 0x3e, 0x76, 0x17, 0xf4, 0x51, + 0xf6, 0x32, 0xc1, 0x61, 0xfb, 0xe6, 0xd8, 0xac, 0x32, 0x17, 0xf1, 0x0e, 0xd4, 0xbf, + 0xee, 0xe4, 0x7e, 0x49, 0x60, 0xec, 0x4a, 0x53, 0xe4, 0x85, 0x2c, 0xa0, 0x24, 0x15, + 0x43, 0x84, 0x84, 0x22, 0x04, 0x4a, 0x67, 0x56, 0x7a, 0x83, 0xe0, 0x9d, 0x8e, 0x74, + 0xb9, 0xd1, 0x1a, 0xf1, 0x7d, 0x53, 0xc4, 0x95, 0x65, 0xca, 0x53, 0xde, 0xda, 0x7c, + 0x4d, 0xf0, 0x76, 0xa3, 0xe1, 0xb6, 0x36, 0x8b, 0x19, 0x31, 0xd8, 0x1d, 0xb9, 0x3e, + 0x87, 0xf7, 0x5b, 0xea, 0x69, 0x24, 0xa3, 0x21, 0x37, 0x6f, 0xe7, 0x3b, 0x5a, 0x5b, + 0x07, 0xb8, 0x0a, 0x98, 0xdc, 0x3a, 0xb8, 0xd1, 0x47, 0x32, 0x54, 0x0f, 0x1b, 0x4b, + 0x71, 0x76, 0xe2, 0x74, 0xa9, 0x05, 0xd4, 0x53, 0xea, 0xc1, 0xca, 0xaf, 0xe2, 0xbf, + 0xe4, 0xe6, 0xc9, 0x04, 0x55, 0x6c, 0xa9, 0x1b, 0x01, 0xb2, 0x30, 0x22, 0x15, 0xab, + 0x3d, 0xfe, 0x6b, 0x49, 0xf4, 0x69, 0x63, 0xdf, 0x63, 0x2a, 0x9e, 0x7c, 0xb8, 0x43, + 0x9c, 0xd5, 0xee, 0x56, 0xa1, 0xf8, 0xe2, 0xcd, 0x3f, 0xaa, 0xe5, 0xd8, 0xf3, 0x46, + 0x2d, 0x0f, 0xf9, 0x31, 0xf5, 0x03, 0x8c, 0xfa, 0x70, 0x25, 0x9d, 0x96, 0x31, 0x63, + 0xd6, 0x16, 0x3e, 0xf2, 0x2b, 0x0c, 0x32, 0x08, 0x1b, 0xff, 0x27, 0x63, 0xe9, 0x8d, + 0xa8, 0x78, 0x17, 0x04, 0x8d, 0x4c, 0xe7, 0x55, 0xe5, 0xd2, 0xb1, 0xcf, 0xe7, 0xd6, + 0xee, 0xab, 0x0f, 0xdb, 0xe7, 0x66, 0xc9, 0x5f, 0x12, 0x55, 0x37, 0xa0, 0x4b, 0xcf, + 0x99, 0x02, 0x6f, 0x9b, 0xd5, 0xbe, 0x3b, 0x26, 0xb9, 0xb7, 0x61, 0x4f, 0x13, 0x2f, + 0x67, 0x47, 0xdd, 0x6d, 0x96, 0x00, 0x9a, 0x85, 0xae, 0x6c, 0xbb, 0x1a, 0x14, 0xb9, + 0x23, 0x10, 0x99, 0xb6, 0x7b, 0x04, 0xd7, 0x84, 0x98, 0x75, 0xb6, 0x49, 0x2f, 0x3b, + 0x64, 0x82, 0xf8, 0xbd, 0xac, 0x30, 0x5f, 0x7e, 0xc2, 0x9f, 0x28, 0xef, 0x47, 0x39, + 0x93, 0x4c, 0x6a, 0x7a, 0x28, 0x00, 0xfb, 0xdb, 0xff, 0x6e, 0xb2, 0x23, 0x7d, 0x6a, + 0x08, 0x5d, 0xdf, 0xab, 0x85, 0x19, 0xdb, 0x1d, 0x2b, 0x1e, 0x63, 0xaa, 0x6c, 0xb9, + 0xb3, 0xb0, 0x44, 0x27, 0x89, 0x47, 0xdc, 0x3b, 0xcd, 0x32, 0x9a, 0xa4, 0x27, 0xd1, + 0x32, 0x67, 0xf9, 0x3a, 0x6c, 0xf2, 0xae, 0xe8, 0xa2, 0xab, 0x74, 0xd4, 0x28, 0x8f, + 0xe0, 0xb6, 0x76, 0xea, 0x85, 0x58, 0x68, 0x34, 0xab, 0x57, 0xe8, 0x63, 0xd4, 0x80, + 0x57, 0x03, 0xeb, 0x8b, 0xf6, 0xe7, 0x1f, 0xbb, 0x11, 0xa3, 0x86, 0xe7, 0xb6, 0x4a, + 0x0d, 0x66, 0x1d, 0xbd, 0x05, 0xf5, 0xe2, 0x92, 0x4f, 0x14, 0x19, 0xbc, 0x79, 0x9a, + 0x08, 0x9d, 0x44, 0xdd, 0xa9, 0x06, 0x6c, 0x6c, 0x50, 0x3f, 0x8c, 0x80, 0xbe, 0x8d, + 0xaa, 0x99, 0xbd, 0x48, 0x33, 0x8d, 0xae, 0xb4, 0x91, 0x1a, 0xcf, 0x19, 0x32, 0x81, + 0x03, 0xc9, 0x6f, 0x40, 0xa7, 0x7f, 0xfd, 0x82, 0x7d, 0x52, 0x29, 0x4b, 0xa2, 0x1a, + 0xd1, 0xd5, 0x2f, 0xc2, 0x7e, 0x8b, 0x12, 0xad, 0x65, 0x88, 0x70, 0x24, 0xf4, 0x1e, + 0x63, 0xfc, 0xfe, 0x65, 0x41, 0x52, 0x67, 0x6a, 0xc3, 0x63, 0xf2, 0x37, 0x7c, 0x5b, + 0x0b, 0x43, 0x7e, 0x07, 0x58, 0x97, 0xe3, 0x3d, 0xd8, 0xd5, 0x72, 0x27, 0xfc, 0x5a, + 0x53, 0x66, 0x29, 0xef, 0xad, 0x99, 0x8a, 0x27, 0x91, 0x03, 0x15, 0x0e, 0x7d, 0x47, + 0xe4, 0xb7, 0xd1, 0x1a, 0x0d, 0x64, 0x9d, 0x14, 0x6c, 0x65, 0x60, 0xc4, 0x8c, 0x9c, + 0x0c, 0x56, 0xc8, 0x11, 0xcf, 0xa6, 0xf3, 0xf6, 0x2c, 0xf7, 0x17, 0xae, 0x57, 0x15, + 0x97, 0xbc, 0x29, 0x7d, 0xee, 0xd8, 0x87, 0x67, 0x2d, 0x8a, 0x8c, 0xec, 0x29, 0x29, + 0xc2, 0xb5, 0x5b, 0x95, 0xf2, 0x6b, 0xd5, 0xd1, 0x0e, 0xf3, 0x0c, 0x0c, 0x4a, 0x62, + 0x95, 0xd5, 0xca, 0x60, 0x15, 0x38, 0xf5, 0xa2, 0x0a, 0xc1, 0x06, 0x4d, 0x2f, 0x4c, + 0x2a, 0x07, 0x8a, 0xf1, 0xb1, 0x62, 0x9a, 0x0c, 0x20, 0x3a, 0xd0, 0x47, 0x12, 0x5e, + 0xb9, 0xdc, 0xe0, 0xd1, 0x26, 0x0e, 0xef, 0x19, 0xcd, 0x4a, 0xd8, 0xec, 0x5d, 0x73, + 0xa0, 0x1b, 0xa2, 0x3e, 0x26, 0x6c, 0xc6, 0xdd, 0x26, 0x6c, 0x5a, 0x81, 0xaf, 0x58, + 0xcc, 0xf1, 0xb5, 0xce, 0x04, 0x40, 0xef, 0xdd, 0x1f, 0xe7, 0xbb, 0x42, 0x17, 0x76, + 0x79, 0xb5, 0xe5, 0x09, 0x5f, 0xfa, 0x0d, 0x45, 0x3b, 0xc1, 0x7b, 0x89, 0x21, 0x00, + 0x85, 0x31, 0xc2, 0xd0, 0x96, 0xa3, 0xa4, 0xa4, 0x85, 0x63, 0x37, 0x04, 0x62, 0xa5, + 0x9f, 0xe1, 0xfa, 0xff, 0x2a, 0x81, 0x60, 0x3f, 0x2d, 0x09, 0xca, 0x2e, 0x0b, 0xea, + 0xc4, 0x42, 0x04, 0xa4, 0xe0, 0x3a, 0xa8, 0x52, 0x74, 0x5b, 0x17, 0x47, 0xbb, 0x6c, + 0x42, 0x42, 0x06, 0xae, 0x09, 0x3e, 0xcb, 0x91, 0x78, 0x97, 0x04, 0x20, 0x39, 0x48, + 0x06, 0x0e, 0xfd, 0x68, 0x1e, 0xda, 0xf7, 0xf1, 0xab, 0x49, 0xd5, 0xf6, 0x31, 0xf1, + 0x12, 0x2d, 0x2e, 0x0c, 0xb4, 0x52, 0xa2, 0xce, 0x54, 0x90, 0x49, 0x7b, 0x32, 0xdf, + 0x22, 0x53, 0x72, 0xb8, 0x0b, 0x86, 0xe5, 0xa7, 0x10, 0xa6, 0x4e, 0x8b, 0x4d, 0x92, + 0x31, 0x84, 0x14, 0xa1, 0x79, 0x47, 0x9b, 0x96, 0x82, 0x7f, 0x33, 0x79, 0xde, 0x24, + 0x71, 0x63, 0x94, 0x90, 0x84, + ], + ss: [ + 0xd3, 0x3a, 0x83, 0xed, 0xb4, 0xfb, 0x5a, 0x75, 0x08, 0x68, 0x6b, 0xa4, 0xdd, 0xff, + 0x00, 0x1c, 0x17, 0xba, 0x88, 0x90, 0xe9, 0xe3, 0xbe, 0x06, 0x7d, 0x50, 0xc9, 0x59, + 0xb5, 0x12, 0xf9, 0xbe, + ], + }, + TestVector { + seed: [0x02; 32], + randomness: [0x66; 128], + ek: &[ + 0x08, 0x11, 0x8d, 0x88, 0x19, 0x77, 0x22, 0x92, 0xc9, 0x76, 0xec, 0x97, 0x1e, 0xe3, + 0x03, 0x91, 0x95, 0x80, 0x0c, 0x82, 0x35, 0x44, 0x48, 0x45, 0x95, 0xcc, 0x63, 0x45, + 0x0b, 0x9d, 0xb9, 0x41, 0x43, 0x30, 0x41, 0x92, 0x08, 0xc5, 0x09, 0xcb, 0x62, 0x62, + 0x60, 0x67, 0xa8, 0xfd, 0x82, 0x59, 0x16, 0x01, 0x05, 0xb6, 0xd8, 0xa4, 0x02, 0x3b, + 0x05, 0x6f, 0x5a, 0xc2, 0xd6, 0x15, 0x9f, 0xa5, 0xf2, 0x45, 0xf0, 0x0c, 0x71, 0x95, + 0x39, 0xa4, 0x60, 0x14, 0x66, 0xf6, 0xb4, 0x5b, 0x2a, 0x68, 0xbd, 0xb0, 0xdb, 0x74, + 0x24, 0xd4, 0xca, 0xd4, 0x75, 0xa8, 0xd6, 0x8b, 0x0d, 0x6e, 0x08, 0x6c, 0x3f, 0x01, + 0x24, 0x14, 0xe2, 0x29, 0x00, 0xf0, 0x11, 0x79, 0xe8, 0xc9, 0x0a, 0x8b, 0xa1, 0xd2, + 0x85, 0xcd, 0xcc, 0x7c, 0x7a, 0xb1, 0xc7, 0x06, 0x4e, 0x2c, 0x15, 0x23, 0x3a, 0xce, + 0xe1, 0x83, 0xa1, 0x07, 0x5c, 0x04, 0xf0, 0x92, 0xa5, 0xe3, 0x67, 0x6b, 0x1e, 0xc0, + 0x6d, 0x15, 0xd3, 0x48, 0xe7, 0x78, 0x13, 0x46, 0xec, 0x95, 0x80, 0x6a, 0x5e, 0x00, + 0xf6, 0x4d, 0x1e, 0x10, 0x1b, 0xfb, 0x28, 0xbb, 0xc6, 0x82, 0x93, 0x72, 0xf3, 0x2b, + 0xed, 0xcc, 0x0d, 0xe9, 0xa7, 0x0a, 0x02, 0xe5, 0x08, 0xb7, 0x60, 0x42, 0x25, 0x05, + 0x48, 0x17, 0x09, 0xbe, 0xf1, 0x06, 0x97, 0xfb, 0xfa, 0x21, 0x9b, 0x99, 0xa8, 0x15, + 0xf4, 0x7e, 0x4b, 0xac, 0xab, 0x0e, 0x78, 0x9c, 0xa1, 0xe4, 0x14, 0xdb, 0x52, 0x9d, + 0xeb, 0x04, 0x3b, 0xd8, 0x52, 0x1c, 0x2d, 0x45, 0x6a, 0x06, 0x2a, 0x65, 0xae, 0xba, + 0x2a, 0x40, 0xdc, 0x6b, 0x9c, 0xe0, 0x24, 0x74, 0xa7, 0x1f, 0xdf, 0x85, 0x2f, 0x34, + 0x3b, 0x22, 0xd2, 0x11, 0x05, 0x19, 0x95, 0x5b, 0x96, 0x43, 0x82, 0xe7, 0x4a, 0x3c, + 0xf7, 0x85, 0x86, 0xea, 0xba, 0x35, 0x3b, 0x98, 0x22, 0x8b, 0x02, 0x68, 0xf8, 0x48, + 0x0b, 0x02, 0xc4, 0xb4, 0xee, 0x20, 0x81, 0x98, 0xfb, 0xc4, 0x72, 0x11, 0x7c, 0x4b, + 0xe5, 0x67, 0x85, 0x8c, 0x09, 0x7f, 0xb0, 0x86, 0x9a, 0x40, 0x58, 0x84, 0x18, 0x97, + 0x3c, 0x58, 0x75, 0x3d, 0xa8, 0x45, 0xe3, 0x6c, 0x0a, 0xdf, 0x39, 0xc5, 0x3e, 0xa9, + 0xc8, 0xae, 0x24, 0xc3, 0x43, 0xbc, 0x87, 0xbc, 0xc3, 0xbe, 0x69, 0xea, 0x40, 0xd9, + 0x49, 0x05, 0x92, 0xec, 0x99, 0xe9, 0xa8, 0x53, 0xf4, 0xf2, 0x2b, 0x02, 0x4a, 0x1b, + 0x15, 0x96, 0x2b, 0x04, 0x9a, 0x62, 0xbc, 0x19, 0x87, 0x06, 0xe3, 0x10, 0xc8, 0x52, + 0x4c, 0x51, 0x87, 0x27, 0x18, 0xd7, 0x6c, 0x6d, 0xb2, 0x5c, 0xd8, 0x24, 0xa1, 0xb7, + 0x5a, 0x94, 0xa7, 0xd3, 0x41, 0xca, 0x40, 0xbe, 0x12, 0x83, 0xb2, 0x11, 0x1b, 0x68, + 0x7b, 0xe6, 0x9d, 0x38, 0xb7, 0x29, 0x7a, 0x90, 0x38, 0x4b, 0x0c, 0x02, 0x69, 0xac, + 0x91, 0x1c, 0xd8, 0x03, 0x84, 0xb3, 0x26, 0x35, 0x72, 0x62, 0xac, 0x13, 0x68, 0x0d, + 0xca, 0x37, 0xee, 0x18, 0x47, 0x7a, 0xb2, 0x3e, 0x16, 0x44, 0x88, 0x05, 0x67, 0x6a, + 0xdb, 0xe1, 0xa5, 0xb7, 0x73, 0x2e, 0x73, 0xc0, 0xab, 0xc3, 0xc5, 0x18, 0x8e, 0x6c, + 0x7a, 0xda, 0x3c, 0x1f, 0x1f, 0x12, 0x46, 0x63, 0xe8, 0x3a, 0xd5, 0x89, 0x96, 0x74, + 0x25, 0x3e, 0x9b, 0xb1, 0x5f, 0x39, 0x90, 0x8b, 0xa4, 0x91, 0x7d, 0xc1, 0x10, 0x25, + 0xf7, 0x50, 0x44, 0x25, 0xa3, 0x05, 0x84, 0x86, 0x61, 0xc3, 0x8c, 0xb0, 0x9a, 0x82, + 0x02, 0x6d, 0x20, 0xc9, 0xbd, 0x23, 0x94, 0x9f, 0x28, 0x55, 0x19, 0xdb, 0x29, 0x84, + 0x18, 0x71, 0x80, 0x23, 0xc8, 0xd7, 0xe3, 0x7a, 0x5b, 0xb1, 0x06, 0x29, 0x51, 0xb4, + 0x32, 0x52, 0x49, 0xaa, 0xd5, 0x9a, 0xcc, 0x06, 0xb1, 0x01, 0x61, 0x41, 0x6c, 0xcc, + 0x78, 0xdb, 0x6c, 0x6c, 0x3f, 0x68, 0x5a, 0xd3, 0xd9, 0xb4, 0x91, 0x6c, 0x62, 0x21, + 0x63, 0x01, 0x7f, 0x96, 0x62, 0xda, 0x42, 0x34, 0xba, 0xb8, 0xb8, 0xb1, 0xe7, 0x72, + 0x90, 0x86, 0x7d, 0x48, 0xc2, 0x8a, 0x2c, 0xb3, 0x3c, 0x7d, 0x2c, 0x78, 0x74, 0xc2, + 0xbe, 0x93, 0x6c, 0xa0, 0xd6, 0xba, 0x90, 0x7d, 0x6a, 0x82, 0x3f, 0xa2, 0x4a, 0x18, + 0xc5, 0x6c, 0xc1, 0x24, 0x20, 0x9e, 0xa4, 0x88, 0xce, 0x62, 0x0c, 0x18, 0xd0, 0x0f, + 0xfc, 0x8b, 0x8f, 0x0c, 0x11, 0xcc, 0x58, 0x50, 0xc3, 0x0b, 0x3a, 0x0f, 0xb7, 0xfa, + 0xaf, 0x6e, 0x52, 0x6f, 0x9b, 0x08, 0x97, 0x22, 0x07, 0xa3, 0x8f, 0x76, 0x0b, 0xad, + 0x18, 0x24, 0x72, 0x60, 0x17, 0xa3, 0x06, 0x34, 0xfd, 0x23, 0x9e, 0xbd, 0xa5, 0x96, + 0x51, 0xb4, 0xc8, 0x16, 0x23, 0x46, 0xbb, 0x36, 0x52, 0xde, 0xc3, 0x9f, 0x56, 0x62, + 0x65, 0x47, 0x82, 0x9f, 0xfb, 0xb0, 0x52, 0xa5, 0xa6, 0x93, 0x0f, 0x27, 0x00, 0xfa, + 0xd3, 0x3f, 0xb1, 0xec, 0xa8, 0xbb, 0xc4, 0x0f, 0xcf, 0xe7, 0x78, 0x18, 0x93, 0x98, + 0xb5, 0x52, 0x7a, 0x09, 0xa2, 0x4a, 0x53, 0xa9, 0x58, 0xe5, 0xc2, 0x53, 0x53, 0x95, + 0x1b, 0x78, 0xd8, 0x59, 0x16, 0x45, 0x7c, 0x1c, 0x50, 0x46, 0xe4, 0x97, 0xae, 0x0f, + 0xa2, 0x48, 0x10, 0xe8, 0x2d, 0x36, 0x00, 0x50, 0xe4, 0xfa, 0x1b, 0xf5, 0x5b, 0x71, + 0x9a, 0xb8, 0xa0, 0x80, 0xc2, 0x3d, 0xcd, 0x80, 0xc0, 0xd4, 0x91, 0x5d, 0x84, 0x58, + 0x65, 0x2d, 0x47, 0x6f, 0x50, 0xf3, 0xa5, 0xb8, 0x0b, 0xa6, 0xff, 0xa9, 0xa7, 0x6b, + 0xd9, 0x52, 0x4d, 0xbb, 0x39, 0xdf, 0x78, 0x26, 0xcc, 0x50, 0x7a, 0x9d, 0x31, 0xaa, + 0x29, 0xb6, 0x20, 0x7e, 0xaa, 0x52, 0xb3, 0xe2, 0x24, 0x25, 0x9c, 0x49, 0x31, 0xb1, + 0xce, 0xd9, 0xb9, 0x7a, 0x42, 0xe6, 0x74, 0x57, 0x52, 0xac, 0x06, 0x03, 0x91, 0x7a, + 0x69, 0x4d, 0x7e, 0xc9, 0x51, 0x45, 0x09, 0x4e, 0xd0, 0x89, 0x00, 0x8a, 0xf6, 0x75, + 0xfe, 0x51, 0xb2, 0xb7, 0x99, 0x70, 0xab, 0xc2, 0x82, 0xdc, 0xb6, 0x32, 0xc1, 0xfc, + 0x3d, 0xab, 0x85, 0xad, 0x14, 0x89, 0x3d, 0x0a, 0xb6, 0x3b, 0x9e, 0x21, 0xa3, 0x68, + 0x84, 0x5e, 0x87, 0x2b, 0xb1, 0x46, 0x8a, 0xa2, 0x52, 0x55, 0x4f, 0x59, 0xf9, 0x0c, + 0x96, 0x75, 0xcd, 0x04, 0x4b, 0x93, 0x0e, 0x37, 0xa9, 0x6a, 0x21, 0x3a, 0x28, 0x27, + 0x76, 0x14, 0x44, 0x3c, 0xca, 0x43, 0x17, 0xe4, 0xa2, 0xaf, 0x9f, 0x4c, 0x71, 0x24, + 0xfa, 0x76, 0xe1, 0xd4, 0x8f, 0x38, 0x98, 0x1d, 0x7d, 0xf0, 0x3d, 0x2b, 0xf8, 0x40, + 0x61, 0x08, 0x61, 0xb2, 0x10, 0x30, 0x01, 0x56, 0xc3, 0xf9, 0x99, 0xaa, 0xac, 0x1b, + 0x29, 0x83, 0xc4, 0x5c, 0xf0, 0x00, 0x2c, 0x92, 0x20, 0x37, 0xbb, 0x40, 0x55, 0xdd, + 0x1c, 0x27, 0xdf, 0x51, 0x1c, 0xed, 0x57, 0x7b, 0xb8, 0x04, 0x6e, 0x00, 0x35, 0x07, + 0xaa, 0x7b, 0x2c, 0x52, 0x19, 0x46, 0x80, 0xb9, 0x3e, 0x2e, 0xb4, 0x07, 0x19, 0x53, + 0x9b, 0x8a, 0x93, 0xb8, 0xe8, 0x3b, 0x9e, 0x20, 0x57, 0x14, 0x92, 0x72, 0x64, 0xcb, + 0xf0, 0x65, 0x3d, 0x44, 0x29, 0xf5, 0x04, 0x81, 0x67, 0x66, 0xbf, 0x97, 0xf1, 0x41, + 0x41, 0x62, 0x2e, 0x91, 0xb2, 0x01, 0x77, 0xd9, 0x8b, 0x8d, 0xb9, 0x35, 0x1b, 0x39, + 0x63, 0x2b, 0xe4, 0x1a, 0x48, 0xf3, 0x9e, 0xe0, 0x50, 0xcc, 0x19, 0x19, 0x14, 0x3a, + 0x24, 0x48, 0xd0, 0x9c, 0x2f, 0xb1, 0x5a, 0x68, 0x0e, 0xbc, 0x07, 0x96, 0x3b, 0x78, + 0x84, 0x80, 0x63, 0x1e, 0xca, 0x37, 0xe1, 0x92, 0x13, 0xdb, 0xb6, 0xc5, 0xe8, 0xda, + 0xc3, 0xee, 0xe8, 0x1b, 0x02, 0x92, 0xcb, 0xc6, 0x81, 0x56, 0x3d, 0x05, 0x77, 0x9b, + 0x79, 0xb5, 0xd8, 0xec, 0x37, 0xb3, 0x31, 0xb3, 0xc0, 0x21, 0x71, 0x9c, 0xb9, 0x5e, + 0x69, 0xec, 0x99, 0xa0, 0xf9, 0x7b, 0x72, 0x33, 0x03, 0x27, 0x8b, 0x94, 0x03, 0xfb, + 0xaa, 0x7f, 0x71, 0xba, 0x70, 0xd6, 0x1d, 0x08, 0x2c, 0x91, 0xa6, 0xaa, 0x2c, 0x8a, + 0x35, 0x43, 0xb5, 0x28, 0x1e, 0x16, 0x05, 0x83, 0x2c, 0x74, 0x0b, 0xf6, 0x70, 0x36, + 0xf2, 0x37, 0x35, 0x71, 0xf0, 0x94, 0x82, 0xb2, 0x72, 0x72, 0xc8, 0xac, 0x2c, 0x69, + 0xb0, 0x1f, 0x71, 0x5d, 0xda, 0x83, 0x37, 0x7a, 0xa0, 0x93, 0xa0, 0x44, 0x54, 0x1f, + 0x60, 0x00, 0x84, 0x8a, 0xb1, 0xea, 0x65, 0xca, 0xb1, 0x34, 0x51, 0x35, 0xa4, 0x55, + 0x2b, 0xe4, 0x2b, 0x27, 0xc4, 0xb9, 0x80, 0x06, 0x56, 0x94, 0x13, 0x4a, 0x90, 0xd4, + 0x36, 0xf0, 0xe0, 0x91, 0xb0, 0x2a, 0x02, 0xaa, 0x99, 0xea, 0xc7, 0x33, 0x99, 0x07, + 0xaf, 0xbb, 0xc1, 0x58, 0xa5, 0x12, 0x75, 0x40, 0x42, 0x3f, 0x23, 0xf6, 0x92, 0x7e, + 0xff, 0x66, 0x91, 0x5d, 0x74, 0x5f, 0x4d, 0x42, 0x04, 0x59, 0xd5, 0x05, 0x76, 0x31, + 0xd9, 0x42, 0x14, 0x46, 0x1c, 0x9b, 0xe8, 0x03, 0xe9, 0xd6, 0x08, 0x0e, 0x10, 0x89, + 0x78, 0xf6, 0x0a, 0xf4, 0x79, 0x5f, 0xc3, 0x48, 0x70, 0xe1, 0xc0, 0x18, 0x19, 0x8d, + 0x85, 0xa4, 0xa1, 0x16, 0xee, 0x21, 0xdf, 0x20, 0xfe, 0x81, 0xd9, 0x21, 0x8e, 0xe2, + 0x2a, 0x9e, 0x81, 0x65, 0x2b, 0x80, 0x6a, 0x71, 0xae, 0xe1, 0x4f, 0x84, 0x50, 0x74, + 0x85, 0x35, 0x6e, + ], + dk: [0x02; 32], + dk_pq: [ + 0x97, 0x16, 0x19, 0xc0, 0x9e, 0x66, 0x27, 0xce, 0xa8, 0x55, 0xbb, 0xf7, 0x81, 0x7d, + 0xd3, 0x6c, 0xdb, 0xf7, 0xd2, 0xde, 0x91, 0x2d, 0x66, 0xaa, 0x2d, 0x94, 0xdd, 0x0d, + 0xa3, 0x0c, 0x9a, 0xc1, 0x20, 0x0f, 0xe8, 0x1d, 0x6e, 0xa2, 0xb4, 0x29, 0x28, 0xde, + 0x29, 0x42, 0x0f, 0xb4, 0x51, 0x10, 0x33, 0x47, 0x53, 0x6b, 0xb6, 0x55, 0xa2, 0xba, + 0xb5, 0xfb, 0xab, 0xa8, 0xa6, 0x78, 0x6f, 0xe9, + ], + dk_t: [ + 0x96, 0x14, 0x18, 0x96, 0x44, 0x2e, 0x2d, 0xca, 0x19, 0xab, 0x5f, 0x49, 0xcc, 0x24, + 0x50, 0xf8, 0x04, 0xfa, 0x3e, 0xb9, 0x49, 0x7f, 0x87, 0x96, 0x79, 0x27, 0x41, 0x66, + 0x88, 0x15, 0x96, 0xf0, + ], + ct: &[ + 0x41, 0x3c, 0x55, 0xd5, 0x71, 0x0b, 0xae, 0x63, 0x76, 0x76, 0x1d, 0xad, 0xa8, 0x07, + 0xda, 0xff, 0xd4, 0xdc, 0x45, 0xf9, 0xf7, 0x0d, 0x82, 0x5e, 0x0d, 0x46, 0x17, 0x6d, + 0x4a, 0x34, 0x2f, 0x58, 0xf2, 0x0d, 0x61, 0x87, 0x92, 0x15, 0xbb, 0xe4, 0xa7, 0x74, + 0x58, 0x88, 0x38, 0x17, 0x53, 0x42, 0x62, 0x8a, 0x90, 0x5d, 0xa0, 0xdb, 0xaa, 0x13, + 0x46, 0xe8, 0xe9, 0x13, 0xf4, 0x73, 0x8d, 0xef, 0xa0, 0x76, 0x84, 0x45, 0xf1, 0xc6, + 0x25, 0xd2, 0x96, 0xab, 0x06, 0xcd, 0x54, 0x7b, 0x93, 0xe7, 0x64, 0xa3, 0x88, 0xe6, + 0x38, 0x15, 0xb5, 0x88, 0x05, 0x97, 0x96, 0xe9, 0xbf, 0x3f, 0xbe, 0xad, 0x07, 0x27, + 0x27, 0x70, 0x3b, 0x03, 0x6a, 0xa7, 0x32, 0x23, 0x00, 0x7a, 0xd1, 0xca, 0xaa, 0xea, + 0x0c, 0x6c, 0xc3, 0x8d, 0x38, 0x5b, 0xeb, 0x06, 0xfe, 0x8d, 0x37, 0x2e, 0x91, 0x45, + 0xc0, 0x8e, 0x1b, 0xc3, 0xcb, 0x5c, 0xcb, 0x12, 0xf4, 0x50, 0xab, 0x0f, 0x6f, 0x9d, + 0xa5, 0x52, 0x96, 0x29, 0xa3, 0xf1, 0xff, 0x63, 0x12, 0x34, 0x6b, 0x6d, 0x2f, 0xcb, + 0x20, 0x46, 0x1e, 0x7b, 0x3b, 0x24, 0x5a, 0x97, 0xa0, 0x3e, 0xf2, 0x7f, 0x2e, 0x54, + 0x42, 0xda, 0xf2, 0xa5, 0xea, 0x31, 0x7f, 0x45, 0x45, 0x28, 0xe9, 0x74, 0x9f, 0x06, + 0x34, 0x2a, 0xa7, 0x59, 0x4e, 0xa9, 0xbd, 0xa0, 0xcd, 0xcc, 0x7c, 0x09, 0x53, 0xc3, + 0x63, 0x72, 0x35, 0x9f, 0xfd, 0x69, 0xf2, 0xae, 0xdc, 0x1a, 0xda, 0xbf, 0x8a, 0x35, + 0x40, 0xe3, 0x2a, 0xb3, 0x6e, 0xbc, 0x13, 0x50, 0xad, 0xed, 0x10, 0x72, 0xaf, 0xe3, + 0xb7, 0x8a, 0x6e, 0xc2, 0xf9, 0x43, 0xd5, 0x60, 0xf4, 0x84, 0x9d, 0x6b, 0xb1, 0xee, + 0x24, 0x67, 0x9e, 0x8f, 0x70, 0xcc, 0x0f, 0x4c, 0xab, 0xe7, 0xd4, 0xcb, 0xc6, 0xe0, + 0x90, 0x35, 0x3c, 0xe8, 0x41, 0x4a, 0x93, 0xde, 0x9c, 0x84, 0xa3, 0x2e, 0x19, 0x7a, + 0x2a, 0xc9, 0x5e, 0x9f, 0xbc, 0x5d, 0x61, 0x6f, 0x85, 0xfe, 0x19, 0x9e, 0x80, 0x79, + 0x3f, 0x6d, 0xcc, 0xac, 0x20, 0x3d, 0x2f, 0x23, 0x6e, 0x7b, 0xad, 0x1a, 0x4e, 0x7f, + 0xf5, 0x1b, 0x3f, 0x33, 0x26, 0xa9, 0x74, 0x28, 0x26, 0xac, 0x6a, 0x23, 0xef, 0x5a, + 0x94, 0x5a, 0xaf, 0xfb, 0x54, 0xfa, 0xf5, 0x0a, 0x8f, 0x0b, 0x8c, 0x09, 0xc5, 0x5c, + 0xf2, 0xbc, 0x81, 0x2e, 0x30, 0xfb, 0x3e, 0x68, 0x7e, 0xca, 0x91, 0xb4, 0x94, 0x78, + 0x5f, 0x12, 0x12, 0x41, 0xa1, 0xea, 0x8d, 0x0c, 0xea, 0x08, 0x92, 0x16, 0xc5, 0xa9, + 0x6a, 0x46, 0x7c, 0x06, 0xd4, 0xf0, 0xa1, 0x0c, 0x2a, 0x6b, 0xf5, 0x51, 0x63, 0x7f, + 0x0f, 0xd5, 0x63, 0x5d, 0xc1, 0x73, 0x4e, 0x96, 0xec, 0xa5, 0xe7, 0xc5, 0x45, 0xd6, + 0x64, 0x35, 0xb8, 0xb5, 0xdd, 0x88, 0xef, 0xf4, 0xc2, 0xcb, 0x3c, 0x73, 0xc4, 0x9d, + 0xfc, 0x9e, 0x56, 0xc2, 0x93, 0xfe, 0xbe, 0xf7, 0x97, 0xa7, 0xd3, 0x6d, 0x21, 0xba, + 0x30, 0x36, 0x1f, 0x7f, 0xec, 0x7b, 0x0e, 0x51, 0x79, 0x3f, 0x6f, 0xdc, 0x22, 0x14, + 0xf4, 0x20, 0xb7, 0x13, 0xa1, 0x59, 0x8f, 0x4d, 0xda, 0x1a, 0x29, 0xf9, 0x12, 0x44, + 0x69, 0x40, 0x7e, 0x5c, 0x5c, 0x5c, 0x90, 0x8e, 0x39, 0xa7, 0x8e, 0xa0, 0xfc, 0xfe, + 0x4d, 0xf3, 0x41, 0x96, 0x92, 0x43, 0x5a, 0x92, 0xe0, 0xf9, 0xa5, 0x84, 0x66, 0x90, + 0x70, 0x6c, 0xdd, 0x23, 0xb1, 0x82, 0x5b, 0xe8, 0xd0, 0xa8, 0x43, 0x75, 0x6f, 0xd9, + 0x7b, 0x4f, 0x27, 0x7c, 0xf0, 0x71, 0x4a, 0x0d, 0x9d, 0xa3, 0xcc, 0xf1, 0xa3, 0x1a, + 0x07, 0x17, 0x83, 0x99, 0xb8, 0x03, 0xc7, 0xb4, 0x83, 0x79, 0x80, 0xbc, 0x01, 0x72, + 0xf5, 0x87, 0x16, 0xb3, 0xba, 0xee, 0x5e, 0x86, 0x44, 0x1d, 0x32, 0xbf, 0x31, 0xc7, + 0xed, 0x6e, 0x9c, 0x6d, 0x55, 0xeb, 0x1e, 0xd5, 0x28, 0xa4, 0xa3, 0x06, 0xde, 0xc7, + 0xf3, 0x7b, 0x3a, 0x57, 0x50, 0x86, 0x38, 0x5a, 0x9f, 0x46, 0x41, 0xef, 0x28, 0xda, + 0x16, 0xd3, 0x55, 0x78, 0xc7, 0x43, 0xc8, 0xec, 0xcb, 0x05, 0x81, 0xb2, 0xfd, 0x30, + 0x8a, 0x3c, 0x9f, 0xa1, 0x5c, 0x83, 0x19, 0x95, 0x4c, 0x8f, 0x42, 0x59, 0xab, 0x09, + 0xf1, 0x78, 0x50, 0x87, 0x20, 0xeb, 0xb8, 0xa0, 0xd8, 0x93, 0xa8, 0xc4, 0x5e, 0xc2, + 0x3b, 0x2c, 0x1c, 0x2e, 0x43, 0xdb, 0x43, 0x9f, 0xf7, 0x1f, 0xea, 0x6a, 0x9f, 0xdc, + 0xd8, 0xa9, 0xd3, 0xc6, 0xe0, 0xf8, 0xb9, 0xe9, 0xe7, 0x1d, 0xdc, 0x2a, 0xa5, 0x2f, + 0xc5, 0xcb, 0xf2, 0x2e, 0xd6, 0x72, 0x17, 0xd8, 0x47, 0xe4, 0xc8, 0x4b, 0x72, 0xe7, + 0xf2, 0x01, 0xac, 0xa5, 0x6c, 0x7d, 0x1d, 0x5e, 0x51, 0xe0, 0xc0, 0x3c, 0xb5, 0x96, + 0xa0, 0x1d, 0x20, 0x20, 0x3b, 0x38, 0xe0, 0xe7, 0xd3, 0x08, 0x6c, 0x83, 0xa4, 0xa1, + 0x93, 0x07, 0x54, 0x13, 0x49, 0x04, 0x48, 0x7c, 0x43, 0xfb, 0x96, 0xde, 0xb4, 0x49, + 0xaa, 0x83, 0x2e, 0x63, 0xa8, 0x2d, 0x13, 0x26, 0x60, 0xcb, 0x79, 0x76, 0xd9, 0xd5, + 0x07, 0x42, 0x64, 0x1c, 0x28, 0xc8, 0xe2, 0xe1, 0xbb, 0x00, 0xa2, 0xc6, 0x5e, 0x9f, + 0x8b, 0x95, 0x91, 0x50, 0x1a, 0xd6, 0x05, 0x68, 0xaf, 0x11, 0x2a, 0x5c, 0xba, 0xb1, + 0x34, 0xbb, 0x47, 0x2f, 0xec, 0xbd, 0xf2, 0x4b, 0xad, 0xbc, 0x65, 0x62, 0x20, 0x1e, + 0x02, 0x2c, 0x23, 0xfb, 0xc6, 0x35, 0x42, 0x92, 0xab, 0x74, 0x3a, 0x86, 0x3a, 0x13, + 0x9d, 0xd4, 0xd6, 0x7b, 0x1b, 0xdb, 0x55, 0x3b, 0x3c, 0x57, 0xa5, 0xc7, 0xf5, 0xb9, + 0x8c, 0xf1, 0x45, 0xac, 0x14, 0x2e, 0x1a, 0xd6, 0xad, 0x5e, 0xa3, 0x95, 0x4f, 0xa3, + 0xc2, 0xb8, 0xeb, 0xfb, 0x6c, 0xd0, 0x5b, 0x91, 0x5d, 0xd1, 0xd8, 0x72, 0x62, 0xd7, + 0xab, 0x1f, 0x1b, 0x47, 0xcc, 0x0a, 0x3b, 0xab, 0xc1, 0x5a, 0x7a, 0x14, 0x15, 0x97, + 0x66, 0x44, 0xc5, 0x4e, 0x29, 0x33, 0x8d, 0x79, 0xaf, 0xa9, 0xd1, 0x2a, 0x66, 0x9d, + 0x3c, 0x67, 0xbf, 0x70, 0xe6, 0x04, 0x15, 0x78, 0x15, 0xf0, 0x41, 0x55, 0x6a, 0x5c, + 0xc1, 0xc8, 0x42, 0x98, 0x80, 0xa5, 0x44, 0x9d, 0x03, 0x3b, 0xb3, 0xf1, 0xf2, 0xb8, + 0x79, 0xf0, 0xe6, 0x89, 0xfc, 0x2a, 0x3e, 0x29, 0x72, 0xf7, 0x5f, 0x6f, 0x25, 0xb9, + 0x5b, 0xea, 0xd0, 0x46, 0x0f, 0x35, 0xef, 0x71, 0xd0, 0xbd, 0xba, 0x38, 0x0e, 0xfb, + 0xab, 0xed, 0x63, 0x65, 0xc6, 0xe7, 0xfc, 0xf2, 0xe2, 0x23, 0x61, 0xb5, 0x72, 0x02, + 0x9f, 0x0c, 0x90, 0xf2, 0xf7, 0x4c, 0x8e, 0x40, 0xc7, 0x94, 0x1e, 0xd8, 0xb6, 0xee, + 0xf5, 0xa7, 0x22, 0xbf, 0x2e, 0x51, 0x41, 0xcf, 0x43, 0xed, 0x2a, 0x69, 0xb8, 0x79, + 0x01, 0xd5, 0x46, 0xa8, 0x57, 0x65, 0xfc, 0x49, 0x45, 0x31, 0xe6, 0x1f, 0x3d, 0x72, + 0x31, 0x07, 0x65, 0x9b, 0x4c, 0xe1, 0xf2, 0x94, 0xc3, 0x52, 0xfc, 0x45, 0xc2, 0x8a, + 0x82, 0xcb, 0x3c, 0x24, 0x2e, 0x5d, 0x6b, 0x9c, 0xf4, 0x3d, 0x07, 0x1b, 0xd5, 0x5b, + 0x8b, 0xc0, 0xd4, 0x7b, 0x22, 0x54, 0x63, 0xa5, 0x07, 0x56, 0x39, 0x56, 0x9c, 0xb0, + 0x73, 0xff, 0xc4, 0xe0, 0x74, 0x17, 0xdb, 0xc5, 0xa3, 0x0a, 0x8e, 0x30, 0x54, 0x52, + 0x64, 0xd6, 0x4d, 0x98, 0xd1, 0x33, 0x36, 0xfd, 0xb6, 0xbd, 0xf8, 0xc7, 0x10, 0x41, + 0xe9, 0x95, 0xcd, 0x43, 0x3a, 0x77, 0xa9, 0xd4, 0xee, 0x25, 0xe2, 0x0f, 0x75, 0x7c, + 0xf7, 0x6d, 0xd7, 0x02, 0xf7, 0xc8, 0xf2, 0x2a, 0x26, 0x77, 0xf0, 0x3d, 0xcb, 0xa4, + 0x7e, 0xa1, 0x99, 0x6b, 0x9d, 0x78, 0x3e, 0x44, 0x73, 0x7e, 0xc5, 0x01, 0xa8, 0xc7, + 0x5a, 0xcb, 0x6d, 0x76, 0x06, 0xa2, 0xb6, 0xeb, 0x1e, 0x06, 0x95, 0x76, 0xf3, 0xa8, + 0x7b, 0x32, 0xe5, 0x87, 0x92, 0x3f, 0xb7, 0x91, 0x71, 0xc7, 0x70, 0x83, 0xbb, 0x62, + 0x9e, 0xfd, 0xa6, 0xb9, 0xdd, 0xc1, 0xd5, 0x66, 0xd7, 0x2a, 0x53, 0x16, 0x1c, 0x16, + 0x5d, 0x0c, 0xce, 0xa7, 0x67, 0x4e, 0x5b, 0x1a, 0xf4, 0x2b, 0x04, 0x0b, 0xbb, 0xc5, + 0xe8, 0xbc, 0x84, 0xbd, 0x33, 0xd1, 0xd3, 0xce, 0x03, 0xff, 0xac, 0x9a, 0x74, 0x7f, + 0x4c, 0x19, 0x93, 0xfd, 0xdb, 0x2e, 0xc9, 0x3a, 0x41, 0x16, 0xa8, 0x6f, 0x02, 0x2a, + 0x77, 0xc3, 0xc1, 0x71, 0x91, 0x55, 0x9a, 0x4c, 0x2a, 0x1a, 0xa5, 0x7e, 0x79, 0xb8, + 0xd1, 0x97, 0x7d, 0xa2, 0xc9, 0x59, 0x17, 0x2f, 0x47, 0x8e, 0x34, 0x1e, 0x27, 0x02, + 0x8d, 0x69, 0xff, 0xfb, 0x7b, + ], + ss: [ + 0xd1, 0x7a, 0x7c, 0xa8, 0x59, 0xa1, 0x8c, 0xfb, 0xb5, 0xfc, 0x7b, 0xcb, 0xa2, 0xec, + 0x54, 0xaa, 0x0e, 0x9a, 0xc4, 0x49, 0x59, 0x02, 0x31, 0x99, 0xff, 0xf5, 0xb6, 0x0d, + 0xb9, 0xf2, 0x44, 0x01, + ], + }, + TestVector { + seed: [0x03; 32], + randomness: [0x67; 128], + ek: &[ + 0x04, 0xcc, 0xc6, 0x8e, 0xbb, 0x7b, 0x60, 0xc6, 0x14, 0x8f, 0xa9, 0x45, 0x74, 0xeb, + 0xae, 0xdb, 0x9c, 0x5c, 0xe5, 0xeb, 0x1a, 0xd6, 0x9c, 0xc5, 0xa4, 0xd7, 0xbb, 0xf9, + 0xa4, 0x10, 0x29, 0x55, 0x40, 0xbb, 0xa2, 0x71, 0xae, 0x8a, 0x17, 0x8b, 0xd0, 0x25, + 0xea, 0x28, 0x88, 0x7c, 0xa8, 0x80, 0x8a, 0xba, 0x8f, 0xac, 0x7a, 0x44, 0x26, 0x0c, + 0x6e, 0x39, 0xb8, 0x83, 0x11, 0x01, 0x55, 0xd0, 0xdc, 0xb8, 0x2a, 0xe7, 0x60, 0x9b, + 0xc8, 0x03, 0xa8, 0xf9, 0x27, 0xdc, 0xc2, 0xc2, 0x03, 0x3c, 0xb0, 0x7b, 0xa9, 0x0f, + 0xc8, 0xb0, 0x68, 0x18, 0x8a, 0x72, 0x14, 0xe7, 0x13, 0x57, 0x95, 0x37, 0xe6, 0x98, + 0x01, 0xce, 0x30, 0x42, 0x51, 0xea, 0xbc, 0x8b, 0x34, 0xb0, 0x3a, 0xd7, 0x12, 0x46, + 0xcc, 0x22, 0xf7, 0x67, 0x1a, 0xdf, 0x57, 0x2c, 0xd6, 0xa2, 0x73, 0x09, 0x76, 0x95, + 0x35, 0x35, 0xc5, 0x9d, 0x7c, 0x93, 0xba, 0xa5, 0x78, 0x88, 0x54, 0xad, 0x52, 0xf4, + 0x8e, 0x9c, 0xdc, 0x8a, 0xcc, 0xf4, 0xa3, 0x44, 0x13, 0x92, 0xf0, 0x06, 0x37, 0x8a, + 0x45, 0x02, 0x89, 0x05, 0x3c, 0x2e, 0xa6, 0x89, 0xa8, 0x06, 0x99, 0xde, 0x7a, 0xcc, + 0x6b, 0xec, 0x4c, 0x2b, 0x18, 0x2e, 0x31, 0x94, 0xac, 0xc9, 0xfb, 0x1c, 0xe3, 0xe1, + 0xb3, 0x89, 0xc5, 0x87, 0x9c, 0xe6, 0x6b, 0xc6, 0x92, 0xa3, 0xb1, 0x53, 0x43, 0xd6, + 0xe5, 0x57, 0xff, 0x93, 0x12, 0x7a, 0xe6, 0x90, 0x07, 0xe6, 0x91, 0x3d, 0x51, 0xce, + 0x70, 0x38, 0x98, 0xc5, 0x44, 0x9e, 0xd3, 0x60, 0x25, 0x93, 0x84, 0x81, 0x95, 0x29, + 0xc7, 0xb5, 0x4b, 0x9f, 0x5b, 0x6c, 0x97, 0x55, 0xd0, 0xa6, 0x27, 0x55, 0x47, 0x72, + 0x84, 0x61, 0x27, 0xc8, 0xa5, 0x80, 0xa5, 0xb6, 0xa9, 0xea, 0x66, 0x95, 0x44, 0x9b, + 0xe1, 0x44, 0x30, 0x6d, 0x64, 0xcc, 0x81, 0x02, 0x12, 0x72, 0x78, 0x82, 0x7d, 0xc2, + 0x5d, 0xa9, 0x6b, 0x6f, 0x48, 0x23, 0xce, 0x5e, 0xd2, 0x5a, 0x2b, 0x19, 0x9f, 0x39, + 0x02, 0xcd, 0x8b, 0xb8, 0x20, 0x58, 0xd4, 0x69, 0x4b, 0x40, 0xce, 0x0c, 0xe1, 0xca, + 0xc1, 0xea, 0x8a, 0x04, 0x7a, 0x1c, 0xed, 0x94, 0x2d, 0x78, 0xac, 0x29, 0x23, 0xc9, + 0xce, 0xd1, 0xd5, 0x63, 0xfc, 0xc2, 0x48, 0x95, 0xb1, 0x68, 0x36, 0x15, 0xb1, 0x34, + 0x85, 0x6a, 0xe3, 0xf3, 0x6e, 0x4b, 0x38, 0x2b, 0xb1, 0x60, 0x17, 0x1e, 0xd4, 0x00, + 0x90, 0x24, 0x99, 0xc6, 0xa0, 0xb1, 0xb8, 0x70, 0x1d, 0x89, 0x09, 0x3d, 0x6d, 0x72, + 0xa9, 0x92, 0xc9, 0xad, 0x29, 0x63, 0x08, 0xa2, 0xd4, 0x4d, 0x26, 0x81, 0x6b, 0x1c, + 0x94, 0x2a, 0x3b, 0xc4, 0x79, 0x97, 0x95, 0x16, 0xa0, 0xdc, 0xbf, 0x16, 0xbb, 0xca, + 0x11, 0x40, 0x55, 0x4b, 0xe6, 0x98, 0x85, 0xa4, 0x77, 0xd0, 0x78, 0xac, 0x0a, 0x26, + 0x7e, 0x82, 0x94, 0x11, 0x1c, 0xbb, 0x42, 0xba, 0xc3, 0xcc, 0x73, 0x32, 0x69, 0xc7, + 0xf8, 0x4b, 0xf3, 0x15, 0x25, 0x8c, 0xf8, 0xcd, 0x04, 0x77, 0x4f, 0x9c, 0xa9, 0x32, + 0xc7, 0x41, 0x67, 0x85, 0x79, 0x6e, 0xcd, 0x78, 0x1e, 0x17, 0xb6, 0xac, 0x32, 0x27, + 0x7d, 0x6d, 0x14, 0x19, 0x06, 0x81, 0x14, 0x30, 0xda, 0x86, 0x64, 0x78, 0x49, 0x9a, + 0x8c, 0x94, 0xc5, 0x21, 0xaa, 0x4d, 0x46, 0x63, 0xaf, 0x06, 0x7f, 0xcd, 0x2c, 0x82, + 0x32, 0x52, 0xc1, 0xdf, 0xba, 0x80, 0x0c, 0x7b, 0x16, 0x81, 0x95, 0x5d, 0xe3, 0x91, + 0x12, 0xc2, 0xfc, 0x5f, 0x4a, 0x14, 0x02, 0x04, 0x69, 0xbc, 0x22, 0x27, 0x8a, 0x84, + 0x49, 0x48, 0x06, 0xd4, 0x35, 0x28, 0xf8, 0xad, 0x8e, 0xfc, 0x88, 0x64, 0x30, 0x38, + 0xd9, 0xd7, 0x1c, 0x79, 0xa5, 0x07, 0x10, 0xdb, 0xac, 0xff, 0x68, 0x63, 0x96, 0xc3, + 0x4f, 0x98, 0x00, 0xb0, 0x67, 0x1b, 0x0d, 0xa3, 0xc2, 0xad, 0x4d, 0xbb, 0x37, 0x51, + 0xb3, 0xb3, 0x74, 0x9b, 0x63, 0xe1, 0x32, 0xa3, 0x36, 0xf1, 0x9a, 0xe8, 0xf3, 0x7a, + 0x79, 0xf6, 0xc7, 0x13, 0xc4, 0x8b, 0x72, 0x4c, 0x80, 0x46, 0x5b, 0x28, 0xe5, 0x78, + 0x65, 0x8b, 0xc8, 0x32, 0x9f, 0x0c, 0x1d, 0x75, 0xd0, 0xab, 0x1d, 0x63, 0x20, 0x27, + 0xa3, 0xcc, 0x8d, 0x74, 0x92, 0x16, 0xf5, 0x04, 0x40, 0x10, 0x9a, 0xd7, 0x63, 0x7f, + 0x3a, 0xb1, 0x66, 0x1e, 0xe7, 0x63, 0x7e, 0xb0, 0x6e, 0x70, 0xd4, 0xc1, 0x5d, 0xb8, + 0x1a, 0x2e, 0xa2, 0x5e, 0xca, 0xe4, 0x52, 0x44, 0x76, 0x10, 0x62, 0x10, 0x36, 0x2a, + 0x7b, 0x35, 0xc0, 0x13, 0x12, 0x0b, 0x51, 0xad, 0x9b, 0x2c, 0x88, 0xb4, 0x52, 0x45, + 0x7b, 0x75, 0xa9, 0x8f, 0xa3, 0xcc, 0xdc, 0xb1, 0x83, 0xae, 0xbb, 0x16, 0x84, 0xb7, + 0x2c, 0x3f, 0xb5, 0x43, 0x4c, 0x27, 0x79, 0x07, 0x68, 0x0e, 0x8c, 0xec, 0xa5, 0xd2, + 0xfb, 0x88, 0xdc, 0xb4, 0x3b, 0x05, 0x0a, 0x55, 0x57, 0xb1, 0x9d, 0x15, 0x9a, 0x60, + 0x50, 0xa6, 0x11, 0x5c, 0x1c, 0x49, 0x23, 0x2c, 0xb5, 0x15, 0x04, 0x63, 0xe1, 0x65, + 0xac, 0xd4, 0x62, 0x9c, 0xa4, 0x92, 0x7e, 0x3c, 0xe4, 0x6d, 0xdd, 0x1a, 0x73, 0x3d, + 0xd2, 0x3f, 0x77, 0xb4, 0x4d, 0xfb, 0x7b, 0x46, 0xeb, 0xe4, 0x29, 0x15, 0x94, 0x01, + 0x5a, 0x4a, 0xb5, 0xff, 0x00, 0xb6, 0x43, 0x32, 0x18, 0x56, 0xb3, 0xb0, 0x62, 0xac, + 0x28, 0xf2, 0xc4, 0xcf, 0x7b, 0x30, 0x71, 0x6b, 0x6c, 0x9a, 0x53, 0x27, 0x11, 0x39, + 0x68, 0x5b, 0x3d, 0x2b, 0xc2, 0x0c, 0xf5, 0xc7, 0x66, 0x26, 0x5a, 0x66, 0x66, 0x65, + 0x23, 0x93, 0xaf, 0x58, 0xac, 0x25, 0xef, 0xcb, 0x50, 0x2a, 0x30, 0xb9, 0xf6, 0xbc, + 0x25, 0x24, 0xcc, 0x61, 0x5a, 0x91, 0x1b, 0x1d, 0xe6, 0x3b, 0xf1, 0x71, 0x0f, 0x9f, + 0x82, 0x9c, 0x91, 0xa5, 0x73, 0xa9, 0x60, 0xa4, 0x4d, 0x43, 0x13, 0x8a, 0x65, 0xc4, + 0x2d, 0x41, 0x00, 0x0c, 0x60, 0x1c, 0x7a, 0xd1, 0x53, 0x76, 0x33, 0x43, 0x3e, 0xdb, + 0x50, 0x23, 0x38, 0x7a, 0xad, 0x50, 0x07, 0xa0, 0x98, 0x27, 0xa5, 0x5b, 0x6a, 0x7e, + 0x7a, 0x29, 0x11, 0x30, 0x7e, 0x0f, 0x22, 0x6e, 0x9e, 0x52, 0xae, 0x3b, 0xa4, 0xc0, + 0xf1, 0x4a, 0x1e, 0xfe, 0x95, 0x71, 0x35, 0x22, 0x78, 0xc5, 0xa4, 0xa0, 0x8c, 0xbb, + 0xa7, 0x40, 0x3c, 0x35, 0xec, 0x69, 0xcc, 0x2a, 0x2b, 0x36, 0x4e, 0xd1, 0x45, 0xb1, + 0x1a, 0x4e, 0x85, 0x94, 0x08, 0x72, 0x36, 0xa4, 0xba, 0x7a, 0x2d, 0x00, 0x3a, 0xa8, + 0x9f, 0xb2, 0xc9, 0x75, 0x80, 0xc3, 0xce, 0x11, 0x57, 0x27, 0xea, 0x0e, 0x99, 0xea, + 0x81, 0xcc, 0x83, 0x54, 0x16, 0x4b, 0x06, 0x02, 0xe5, 0x3c, 0xb3, 0x36, 0x38, 0xda, + 0xd5, 0xa3, 0x96, 0x32, 0xb7, 0x0f, 0x47, 0x06, 0xeb, 0x8b, 0xb6, 0xd5, 0x98, 0xc6, + 0x71, 0x76, 0x27, 0xfe, 0x3c, 0x02, 0x42, 0x05, 0x83, 0xcb, 0xda, 0xc9, 0x46, 0x0a, + 0x9d, 0x55, 0x58, 0x8f, 0xfa, 0xfb, 0xa8, 0xcf, 0x74, 0x8c, 0x16, 0x28, 0x3b, 0x0e, + 0x96, 0xb8, 0xf9, 0x51, 0x00, 0xca, 0xa7, 0xa8, 0xd1, 0x20, 0x29, 0xa4, 0x33, 0xab, + 0x4e, 0xfb, 0xb9, 0xb2, 0x06, 0x7a, 0x0c, 0x61, 0x5d, 0x53, 0x58, 0xac, 0xee, 0xa0, + 0x4b, 0x4c, 0xa4, 0xbf, 0x58, 0x4a, 0x45, 0x2f, 0xe2, 0x76, 0x8c, 0xb5, 0xba, 0xb0, + 0xfb, 0x52, 0xae, 0xc3, 0x75, 0xc3, 0x33, 0x7f, 0xae, 0x44, 0xb3, 0x05, 0xf1, 0x38, + 0x9f, 0x12, 0x31, 0x03, 0x66, 0x9c, 0x79, 0x01, 0xa1, 0x82, 0x1c, 0x47, 0x15, 0xb5, + 0xca, 0xc1, 0xc8, 0x93, 0x89, 0xcc, 0x9f, 0x4d, 0xf1, 0x92, 0xcc, 0xa7, 0x89, 0xed, + 0x23, 0x6f, 0x7b, 0x37, 0x8f, 0xb2, 0x91, 0x51, 0x06, 0xea, 0x3c, 0xc1, 0xb9, 0x0c, + 0xe9, 0xd6, 0xc0, 0x7b, 0x36, 0xc4, 0xf0, 0x9b, 0x56, 0x54, 0xe3, 0xa1, 0x16, 0xc6, + 0x0d, 0xda, 0x68, 0x5b, 0x9e, 0xf6, 0x89, 0x3b, 0x1b, 0x42, 0x34, 0x8a, 0x3a, 0xc8, + 0x72, 0x84, 0xee, 0xd6, 0x83, 0xfb, 0x34, 0x6d, 0x25, 0xa5, 0x62, 0xb9, 0x0a, 0x77, + 0x8e, 0x6b, 0x54, 0x6e, 0x40, 0xb4, 0xfd, 0x7c, 0x1d, 0x3c, 0x01, 0x98, 0x3f, 0x85, + 0x14, 0x74, 0xc3, 0x83, 0x22, 0x97, 0x01, 0x9a, 0x80, 0x8e, 0xf6, 0x49, 0x57, 0xd7, + 0x90, 0x25, 0x78, 0x98, 0x1d, 0x92, 0x31, 0xb3, 0x82, 0x16, 0x9d, 0x53, 0x3a, 0x22, + 0x02, 0xe9, 0x5d, 0x18, 0xf1, 0x52, 0xe8, 0xfc, 0x25, 0xb6, 0x15, 0xbb, 0x8a, 0x65, + 0x48, 0x2a, 0x21, 0x67, 0xdf, 0x6a, 0xb2, 0x81, 0x1c, 0x73, 0xbf, 0x8f, 0xef, 0xbe, + 0xc0, 0x77, 0xf1, 0xe6, 0x68, 0x49, 0x4d, 0x42, 0x24, 0x43, 0xa0, 0x83, 0xb9, 0x61, + 0x92, 0x54, 0xec, 0x3e, 0x6b, 0xc6, 0xf3, 0x02, 0x04, 0x78, 0xcd, 0x35, 0xc1, 0x61, + 0x6f, 0xf2, 0x9a, 0x19, 0x60, 0x10, 0x8b, 0xe1, 0x2b, 0x65, 0xf0, 0xa2, 0x99, 0xf3, + 0xe1, 0xa5, 0xef, 0xe7, 0x66, 0x4d, 0xdb, 0xe3, 0x38, 0x52, 0xe4, 0x80, 0x5a, 0xaf, + 0x60, 0x43, 0x5e, 0xfc, 0x12, 0x31, 0x44, 0x54, 0x03, 0x91, 0xb8, 0x16, 0x83, 0xb5, + 0x71, 0x2f, 0xef, 0xe4, 0x01, 0x26, 0xd0, 0x70, 0xb4, 0xf9, 0xfc, 0x5e, 0x40, 0x9d, + 0xa8, 0x96, 0xa4, + ], + dk: [0x03; 32], + dk_pq: [ + 0x49, 0xb4, 0x63, 0x21, 0xef, 0x5a, 0x24, 0xc1, 0xc0, 0x36, 0x75, 0x08, 0x79, 0xc0, + 0xad, 0x29, 0xdd, 0x08, 0x60, 0x7d, 0x48, 0x9b, 0xd7, 0xea, 0xa5, 0x86, 0x94, 0x92, + 0x75, 0x9d, 0x99, 0x4d, 0x87, 0x5e, 0x0b, 0xea, 0xac, 0x3c, 0xf9, 0x0d, 0xf1, 0xb3, + 0xf1, 0xe0, 0xdd, 0x70, 0x35, 0x7a, 0x5b, 0xaf, 0xae, 0xc8, 0xa3, 0x6f, 0xc2, 0xd9, + 0xb7, 0x2e, 0xdf, 0x3f, 0x57, 0xf9, 0xdb, 0x20, + ], + dk_t: [ + 0xd2, 0x00, 0x34, 0xc3, 0x80, 0x88, 0xae, 0x9e, 0x33, 0x38, 0xd7, 0x5e, 0x19, 0x54, + 0xdd, 0x00, 0x00, 0x1b, 0xda, 0x61, 0x03, 0x6e, 0xab, 0xac, 0x6a, 0x3e, 0xe5, 0x63, + 0x39, 0xd3, 0x7c, 0xe9, + ], + ct: &[ + 0xf4, 0x0d, 0x55, 0x6d, 0x50, 0x78, 0x02, 0xeb, 0xe7, 0xbe, 0x0e, 0x65, 0xab, 0x82, + 0xb0, 0xaa, 0x9f, 0xf2, 0x6c, 0x82, 0x5d, 0x24, 0xf9, 0x81, 0x48, 0xf7, 0x5d, 0x7e, + 0x91, 0x0d, 0x6c, 0x7f, 0x58, 0x52, 0xe7, 0x02, 0x3a, 0x4e, 0x24, 0x6b, 0xe8, 0x1b, + 0x80, 0x7f, 0xea, 0x96, 0x92, 0x8d, 0xa6, 0xa8, 0xc4, 0xd2, 0x3b, 0x83, 0x26, 0xea, + 0x90, 0xaa, 0x7f, 0x1f, 0x06, 0x73, 0xa5, 0x72, 0x77, 0xbd, 0xd0, 0x89, 0x60, 0xf7, + 0xf8, 0x86, 0x77, 0x7f, 0x17, 0x25, 0xb8, 0x82, 0xe1, 0x99, 0x66, 0x32, 0x58, 0x4f, + 0xce, 0x43, 0x56, 0xf7, 0x34, 0x5a, 0xbd, 0x8f, 0x48, 0x05, 0x14, 0x27, 0x5f, 0xbb, + 0xd9, 0x6e, 0xc6, 0xd3, 0x20, 0x2d, 0xe4, 0x6e, 0x18, 0xe7, 0xa8, 0x27, 0xd4, 0xdc, + 0x62, 0xc1, 0x68, 0x1c, 0x36, 0x01, 0x88, 0x61, 0xc3, 0x3c, 0xb2, 0xf4, 0xe1, 0x3b, + 0xa5, 0xda, 0x65, 0x55, 0x84, 0x41, 0xca, 0xa6, 0xec, 0xf8, 0x2a, 0x5e, 0x74, 0x84, + 0x22, 0x68, 0xf4, 0xef, 0x50, 0x36, 0xde, 0xb2, 0xf0, 0xf6, 0xf5, 0xcb, 0x42, 0x2d, + 0xc2, 0xb7, 0x23, 0xa7, 0xf2, 0xf6, 0x98, 0x30, 0xa5, 0x23, 0x26, 0x62, 0x1e, 0xe0, + 0x34, 0xc8, 0xa9, 0xe8, 0x0f, 0x39, 0x07, 0x04, 0x56, 0xbf, 0xdd, 0xe6, 0x53, 0x31, + 0x40, 0x40, 0xb4, 0xf4, 0x15, 0x90, 0x72, 0x3b, 0x66, 0xa2, 0xd7, 0xe4, 0x11, 0x53, + 0x93, 0x25, 0x21, 0xe8, 0xe5, 0x11, 0x08, 0xd2, 0xd9, 0x88, 0x41, 0xb2, 0x98, 0x3b, + 0xaa, 0x43, 0xb0, 0xdd, 0x6a, 0x46, 0x78, 0x3b, 0xe0, 0x63, 0x85, 0x0b, 0x22, 0xa2, + 0xdd, 0x05, 0xc1, 0xf9, 0xf5, 0x78, 0x36, 0x0d, 0xc3, 0xdf, 0xef, 0x4d, 0x79, 0xe8, + 0xc2, 0x0d, 0x2d, 0x0c, 0x45, 0x68, 0x7a, 0xe1, 0x93, 0x95, 0x35, 0x5e, 0x7c, 0xdc, + 0xfa, 0x03, 0x9e, 0x3c, 0x36, 0xb6, 0xdf, 0x4e, 0xa1, 0x1b, 0x41, 0x22, 0x91, 0x8f, + 0xd6, 0xec, 0x63, 0xec, 0x67, 0x2a, 0xce, 0x58, 0xa8, 0xed, 0x9d, 0xfc, 0x61, 0xe7, + 0xd3, 0xb5, 0x82, 0x9d, 0x57, 0x48, 0x33, 0xe0, 0xe6, 0x1f, 0xa0, 0x84, 0x19, 0xcb, + 0xda, 0x05, 0xa8, 0x5b, 0x3c, 0x4b, 0x99, 0x57, 0xa0, 0x96, 0x8d, 0x58, 0x25, 0xd0, + 0xd0, 0x52, 0x01, 0x3e, 0x75, 0xf1, 0x38, 0xc8, 0xd7, 0x49, 0x29, 0xa6, 0x31, 0xa0, + 0xba, 0x2e, 0xc9, 0x55, 0x5e, 0x27, 0x67, 0xf1, 0x7e, 0x6e, 0x22, 0x89, 0x0a, 0x5c, + 0xb0, 0x0f, 0x63, 0xf0, 0x9e, 0x00, 0xb8, 0xde, 0xcc, 0xcf, 0x7d, 0x7d, 0x0e, 0x36, + 0x9c, 0x43, 0x96, 0xcb, 0x42, 0x9e, 0x53, 0xd8, 0xcd, 0x46, 0x36, 0xea, 0x63, 0x0d, + 0x6f, 0xc5, 0x51, 0x43, 0xe6, 0x14, 0x6a, 0x96, 0x9e, 0xd0, 0x83, 0x9a, 0xb0, 0x5d, + 0xd0, 0x79, 0xda, 0x3f, 0x94, 0x6b, 0x3d, 0xea, 0xad, 0x27, 0x74, 0x36, 0x05, 0x29, + 0xf2, 0xaa, 0x7e, 0x6c, 0x40, 0x0b, 0x66, 0xa5, 0xc4, 0x49, 0xdd, 0x83, 0x62, 0xfa, + 0xe1, 0xa1, 0xbb, 0xf1, 0x10, 0x22, 0x98, 0x10, 0xe0, 0xd4, 0x72, 0x5c, 0xfa, 0x2d, + 0xfd, 0xc0, 0x46, 0xd4, 0xc1, 0x86, 0x37, 0xe1, 0xde, 0x3e, 0xc2, 0xb5, 0x20, 0x55, + 0xc2, 0x37, 0x23, 0x8d, 0xe0, 0x16, 0x7e, 0xb0, 0x84, 0x4c, 0x24, 0xa8, 0xfd, 0x91, + 0xac, 0x9f, 0x66, 0xf8, 0x6e, 0xfc, 0x94, 0x5c, 0x0a, 0x50, 0x67, 0x29, 0x26, 0xef, + 0xab, 0x53, 0xbd, 0x07, 0x25, 0xae, 0x9f, 0xf3, 0x6e, 0x9f, 0xcb, 0xec, 0xd5, 0x82, + 0x12, 0xcb, 0xe7, 0xe0, 0xf2, 0x48, 0xb9, 0xab, 0x90, 0xb2, 0xf5, 0x64, 0x97, 0xf1, + 0x96, 0x19, 0x80, 0x43, 0xfa, 0x10, 0xde, 0x90, 0x9b, 0x05, 0xbf, 0x3d, 0xd1, 0xd2, + 0x06, 0x30, 0xf9, 0x70, 0x70, 0x95, 0xf4, 0xf8, 0x0d, 0x04, 0x44, 0x18, 0xe6, 0x7c, + 0xcd, 0x79, 0xe8, 0xf2, 0x8d, 0xb7, 0xac, 0xb1, 0x08, 0x3a, 0x2b, 0xc6, 0x32, 0x33, + 0xa4, 0xf4, 0x79, 0x8f, 0x13, 0xf2, 0x1e, 0x81, 0xda, 0x6e, 0xe0, 0x3c, 0x61, 0x4c, + 0xb3, 0x67, 0xaf, 0xf0, 0x54, 0x10, 0x96, 0x0f, 0xd3, 0x66, 0xdf, 0x06, 0x69, 0x1b, + 0x37, 0x42, 0x47, 0xde, 0x70, 0xfc, 0xf9, 0x16, 0xe6, 0x53, 0xb2, 0xbf, 0x01, 0xb4, + 0x9c, 0xf1, 0x16, 0x32, 0x4e, 0x81, 0x04, 0xda, 0x61, 0xa6, 0x21, 0xb5, 0x66, 0xa6, + 0x2c, 0x97, 0xc6, 0xc0, 0x58, 0x20, 0x8e, 0x48, 0x25, 0x72, 0x7c, 0xbb, 0x6c, 0x2e, + 0xba, 0xa0, 0xe8, 0x88, 0x65, 0x90, 0x94, 0xaa, 0x03, 0x70, 0x96, 0x59, 0xe2, 0x72, + 0xb4, 0x20, 0x9c, 0x18, 0x36, 0x61, 0x96, 0x11, 0x0d, 0x71, 0x12, 0x0b, 0x20, 0x3f, + 0xc7, 0x1d, 0xd5, 0xd3, 0xc1, 0x7b, 0xe4, 0x58, 0x0e, 0x5a, 0xde, 0x64, 0xa3, 0xfd, + 0xee, 0xa5, 0xb8, 0x5a, 0xd3, 0x3f, 0xce, 0xbf, 0x30, 0xb8, 0x57, 0xdc, 0x7c, 0xfe, + 0x3b, 0xa5, 0x2e, 0xa8, 0x26, 0x9c, 0xad, 0xd7, 0xdd, 0xa3, 0x08, 0x46, 0x02, 0x01, + 0xe0, 0x11, 0x9f, 0x89, 0x18, 0xde, 0x89, 0x80, 0xf0, 0x4b, 0x31, 0x8f, 0x39, 0x48, + 0x7e, 0x65, 0xef, 0x0e, 0x0b, 0x83, 0xc2, 0x39, 0x6d, 0x2f, 0xd8, 0x7f, 0x4d, 0x54, + 0xdd, 0x00, 0xb4, 0x05, 0x06, 0x3f, 0x07, 0x26, 0x59, 0xd6, 0xb1, 0x15, 0x13, 0xf4, + 0x48, 0xb2, 0x0d, 0xed, 0xa3, 0xd8, 0x74, 0x98, 0x7c, 0x25, 0x2b, 0x7d, 0x16, 0xd9, + 0x4c, 0x4f, 0x81, 0x1c, 0x97, 0x13, 0x4e, 0x5e, 0x00, 0xbf, 0xf8, 0x30, 0x0e, 0x71, + 0x8e, 0x17, 0xde, 0x37, 0x35, 0xbb, 0x4b, 0xc0, 0x52, 0x10, 0x0a, 0x38, 0x23, 0xf8, + 0xdb, 0x4b, 0xe2, 0xd7, 0x55, 0x40, 0x03, 0x48, 0x1c, 0xe6, 0xd8, 0x99, 0xd7, 0x4c, + 0x1a, 0xd9, 0x94, 0x4c, 0x01, 0xd9, 0x33, 0x30, 0x58, 0x51, 0x45, 0x89, 0x33, 0xb3, + 0xf7, 0x80, 0xad, 0x6c, 0x1d, 0xb4, 0x89, 0xda, 0x50, 0x76, 0x21, 0xe3, 0x9b, 0xe1, + 0x74, 0xc7, 0x1f, 0x73, 0xec, 0x9c, 0x1e, 0xf6, 0x44, 0x57, 0x8b, 0xb1, 0x56, 0x61, + 0x36, 0xf1, 0x7e, 0x91, 0xb4, 0x75, 0xfd, 0xbf, 0x35, 0x4c, 0xf4, 0xf5, 0xa6, 0xee, + 0x30, 0x0d, 0x39, 0x38, 0xf5, 0xb4, 0xa7, 0xb9, 0xbc, 0xb9, 0x01, 0x88, 0xa3, 0xd9, + 0xc8, 0xfa, 0xb1, 0x32, 0x6d, 0xf6, 0x9f, 0x5c, 0x37, 0x53, 0xa8, 0xff, 0x9c, 0x5a, + 0x7b, 0xbc, 0x4e, 0x22, 0x55, 0x95, 0x4d, 0xfb, 0x6a, 0x2c, 0xe8, 0x13, 0x81, 0xea, + 0xf9, 0xd2, 0x24, 0x00, 0x5e, 0x05, 0x0e, 0xb5, 0xf5, 0x3d, 0x05, 0xf0, 0xa4, 0x1b, + 0xcf, 0x4f, 0x3c, 0x0e, 0x87, 0x71, 0xe8, 0x4e, 0xaa, 0x46, 0xce, 0x27, 0xb0, 0x43, + 0x8d, 0x4c, 0xe3, 0xeb, 0xf9, 0xeb, 0x25, 0xb5, 0x35, 0x16, 0x43, 0xa2, 0x6f, 0x60, + 0x7c, 0x41, 0xb6, 0x49, 0x4a, 0xc7, 0x7e, 0x4c, 0x4a, 0x2f, 0xaf, 0xac, 0x8e, 0x3c, + 0xd8, 0x72, 0xf3, 0x18, 0x16, 0x50, 0x1e, 0xfd, 0x66, 0xc4, 0x17, 0x95, 0xfa, 0x0d, + 0x01, 0xac, 0x02, 0x90, 0x25, 0x3c, 0xf6, 0xc9, 0xd0, 0xdd, 0x8d, 0x58, 0x65, 0x68, + 0x4c, 0x1a, 0x02, 0x74, 0x8a, 0x82, 0x44, 0x17, 0x82, 0x7e, 0xe3, 0x74, 0x40, 0x4a, + 0x59, 0xba, 0x87, 0xc3, 0xec, 0x3c, 0xaa, 0xdf, 0x08, 0xb0, 0xf9, 0x20, 0x66, 0x7f, + 0xae, 0x9a, 0xd1, 0x85, 0x60, 0xed, 0xc3, 0xf8, 0x57, 0x19, 0x86, 0xca, 0x0b, 0xf1, + 0xef, 0x11, 0x4d, 0x39, 0x4c, 0x08, 0xec, 0x5f, 0xf2, 0x21, 0xe9, 0xf9, 0xce, 0x7b, + 0x65, 0x08, 0xeb, 0x6c, 0x38, 0xd6, 0x04, 0x1f, 0xbe, 0x73, 0x19, 0xbd, 0x88, 0x74, + 0xf3, 0x5b, 0xac, 0xe8, 0x5c, 0x0b, 0xcc, 0x08, 0xcd, 0xcc, 0x64, 0x2a, 0xe7, 0xfc, + 0x26, 0x4b, 0x9b, 0xe0, 0x8a, 0x26, 0xe5, 0xec, 0x6a, 0x36, 0x18, 0xa0, 0x78, 0xa1, + 0x28, 0xd0, 0xb8, 0xda, 0xf4, 0x6e, 0x40, 0x4e, 0xee, 0x41, 0x23, 0xb3, 0x79, 0xa8, + 0x16, 0x80, 0xc8, 0x33, 0x60, 0x36, 0xd9, 0xa4, 0x4c, 0x12, 0xbc, 0xc2, 0x3e, 0xd7, + 0xb1, 0xb9, 0x64, 0x42, 0x10, 0x88, 0x43, 0xe5, 0xfc, 0xee, 0x04, 0x23, 0x94, 0xb4, + 0x56, 0x98, 0x4b, 0x83, 0xea, 0x78, 0x59, 0xf7, 0xa0, 0xfb, 0x64, 0x75, 0xd5, 0x3b, + 0x4f, 0xd5, 0x52, 0x36, 0xec, 0xf4, 0xf3, 0x31, 0x83, 0xc1, 0xd7, 0x19, 0xee, 0x10, + 0x68, 0x3a, 0x6b, 0x68, 0x9b, 0x46, 0x3a, 0x82, 0x36, 0x65, 0xa4, 0x0b, 0x63, 0x73, + 0x56, 0x47, 0xc2, 0x93, 0x0f, 0x3c, 0x4b, 0x1d, 0x87, 0x87, 0xd4, 0x19, 0x9b, 0xfc, + 0x2d, 0xb8, 0x49, 0x9e, 0x61, + ], + ss: [ + 0xb3, 0xdb, 0x69, 0xcc, 0x03, 0x85, 0xb1, 0xba, 0x71, 0x61, 0x28, 0xb7, 0x0b, 0xd4, + 0xb9, 0x32, 0x88, 0xf9, 0x45, 0xf4, 0x18, 0xce, 0xf5, 0x1d, 0x12, 0x2c, 0xa7, 0xa4, + 0xde, 0x56, 0x4a, 0x81, + ], + }, + TestVector { + seed: [0x04; 32], + randomness: [0x68; 128], + ek: &[ + 0x6a, 0xfa, 0x82, 0xec, 0x0b, 0x8e, 0x84, 0x49, 0x59, 0x1c, 0xb9, 0xa1, 0x1b, 0xe3, + 0x6d, 0xc4, 0x31, 0x46, 0xc1, 0x8a, 0x6a, 0xd3, 0xf1, 0x75, 0x89, 0x79, 0x33, 0xd2, + 0x59, 0x44, 0xc3, 0xc6, 0x43, 0xf5, 0x03, 0x32, 0xf1, 0xcc, 0x4f, 0x6a, 0x97, 0x07, + 0xa3, 0x87, 0xb5, 0xc4, 0x06, 0x61, 0xec, 0x41, 0xb3, 0x6d, 0x2b, 0xbc, 0x45, 0x07, + 0x75, 0x83, 0x87, 0x67, 0x2f, 0xb4, 0xa1, 0xc1, 0x19, 0x6e, 0xaa, 0x81, 0xb0, 0x1b, + 0xe2, 0x86, 0x4c, 0xc9, 0x58, 0xa0, 0x64, 0x24, 0x96, 0xf2, 0x64, 0xb4, 0x04, 0x2e, + 0xc5, 0xf7, 0xb2, 0x5a, 0x52, 0x20, 0xa8, 0xa9, 0xc9, 0x63, 0x30, 0x81, 0xae, 0xf1, + 0x04, 0xef, 0x9a, 0xbd, 0x4d, 0xa0, 0xaf, 0x06, 0x8a, 0x84, 0xe7, 0xb0, 0x3f, 0x21, + 0xe6, 0xb6, 0x02, 0x12, 0xa0, 0x2d, 0xc4, 0x8b, 0xa7, 0x86, 0x58, 0x77, 0x08, 0x4a, + 0x1b, 0x02, 0x54, 0x43, 0xe3, 0x8d, 0x60, 0xbb, 0x6f, 0xae, 0x8b, 0xa8, 0x8e, 0xa4, + 0x53, 0x8d, 0x08, 0x8b, 0xea, 0x75, 0x8f, 0x6f, 0x9a, 0x5c, 0x26, 0xa9, 0xc4, 0x46, + 0x99, 0xad, 0x43, 0x08, 0x0d, 0x3f, 0xdc, 0xc2, 0xd9, 0x10, 0xb1, 0x6b, 0x29, 0x7b, + 0xb8, 0x64, 0x36, 0xe3, 0xd5, 0xb7, 0x9d, 0xc0, 0x12, 0x30, 0x12, 0x48, 0x67, 0xc1, + 0xbe, 0x64, 0xa9, 0xca, 0xb7, 0xaa, 0xb9, 0xfd, 0xb4, 0x7e, 0xad, 0xd1, 0x5d, 0x00, + 0xed, 0x84, 0xac, 0x9a, 0x37, 0x40, 0x6a, 0x36, 0x65, 0xd7, 0xcb, 0xdd, 0x10, 0x6d, + 0x1e, 0x6a, 0x29, 0xa8, 0x1c, 0x94, 0xe3, 0xc8, 0x41, 0xfe, 0x9c, 0xb5, 0x83, 0x00, + 0x4a, 0xa4, 0x71, 0xad, 0x2e, 0xb4, 0x77, 0x62, 0x34, 0x01, 0xe6, 0x95, 0x9a, 0x04, + 0x43, 0x9b, 0xae, 0x06, 0xa0, 0x70, 0x58, 0xcf, 0x2e, 0xd9, 0x4b, 0xce, 0x18, 0x39, + 0xe6, 0x36, 0xa8, 0xc0, 0xb2, 0x2f, 0x78, 0x24, 0x83, 0xce, 0x79, 0x8e, 0x60, 0x9b, + 0xcd, 0x78, 0x46, 0x05, 0xea, 0xdc, 0x0a, 0x06, 0xc7, 0x69, 0x9b, 0x1b, 0x9e, 0xce, + 0x55, 0x04, 0x84, 0x12, 0x40, 0x95, 0xa1, 0x33, 0x71, 0x02, 0x81, 0x01, 0xc9, 0x57, + 0x21, 0xc2, 0xc7, 0x1b, 0x09, 0x8b, 0x15, 0xf3, 0x99, 0x87, 0x85, 0xb3, 0x61, 0x92, + 0x4f, 0x89, 0xdb, 0xa9, 0xf2, 0x92, 0xb9, 0xb1, 0x8c, 0xbe, 0x23, 0x2c, 0xb7, 0x6e, + 0x41, 0xbb, 0x5b, 0x35, 0xca, 0xd9, 0x76, 0x96, 0x2f, 0xca, 0x29, 0x57, 0xeb, 0x8e, + 0x06, 0x35, 0x6c, 0x25, 0x05, 0x25, 0xe8, 0x82, 0x5d, 0xce, 0x66, 0x47, 0x8f, 0xa5, + 0x87, 0xab, 0x6b, 0x42, 0x9b, 0xb2, 0x87, 0xaa, 0xf2, 0x1a, 0x58, 0xc9, 0x00, 0xde, + 0x09, 0x46, 0xeb, 0xc2, 0x84, 0x87, 0x34, 0x50, 0xc7, 0xe7, 0xa0, 0xe0, 0x8c, 0x85, + 0x6d, 0xca, 0x21, 0x91, 0x19, 0x5f, 0x73, 0xb3, 0xae, 0xcc, 0xe1, 0xb1, 0xc1, 0xc2, + 0x9c, 0xb2, 0x4a, 0x6c, 0x2f, 0xc3, 0xc1, 0x4c, 0xa1, 0x49, 0x51, 0x82, 0x64, 0x5c, + 0xf8, 0x48, 0x6c, 0xb8, 0x77, 0xd0, 0x67, 0x44, 0x0f, 0x11, 0x8b, 0x80, 0x71, 0x37, + 0x84, 0x47, 0x4b, 0xd0, 0x21, 0x4f, 0x23, 0xfc, 0x09, 0xe2, 0xc8, 0xb5, 0xdf, 0x35, + 0x7b, 0x37, 0x33, 0xc1, 0x35, 0x45, 0xc9, 0x49, 0x03, 0x78, 0x29, 0x16, 0x46, 0xfb, + 0xdb, 0x84, 0x03, 0x81, 0x8f, 0x7d, 0x57, 0x1a, 0x40, 0xba, 0x7f, 0x5c, 0xea, 0x48, + 0x0f, 0xa0, 0x0b, 0xa1, 0x53, 0x73, 0xc6, 0x02, 0x55, 0xe5, 0x43, 0x84, 0xe9, 0x6c, + 0x45, 0x5d, 0xa1, 0x3f, 0xd7, 0xdb, 0xcb, 0xc1, 0xe7, 0xa5, 0xe9, 0xd6, 0x55, 0xb0, + 0x14, 0x59, 0x76, 0xe1, 0x90, 0x78, 0x0b, 0x55, 0xc9, 0xc8, 0x6c, 0xa6, 0xc9, 0x88, + 0xd1, 0x23, 0x0a, 0xab, 0xc8, 0x55, 0x8c, 0xec, 0xa8, 0xd5, 0xcb, 0xb8, 0x44, 0xca, + 0x8d, 0x95, 0xb3, 0x0b, 0x64, 0xc0, 0x24, 0x40, 0x52, 0x26, 0x61, 0xc9, 0xb0, 0x7c, + 0x86, 0x6e, 0x49, 0x7b, 0x5a, 0x7d, 0xaa, 0x23, 0x98, 0xa5, 0xa8, 0x88, 0xa4, 0x24, + 0x4d, 0x90, 0x21, 0x01, 0x05, 0x46, 0x0f, 0xab, 0x31, 0xc6, 0xdb, 0x3f, 0xd5, 0x79, + 0x41, 0xb8, 0x69, 0xc2, 0x42, 0x18, 0xb2, 0xeb, 0xd7, 0xae, 0x67, 0x88, 0x5e, 0x1f, + 0xd6, 0x91, 0xa3, 0xdc, 0x43, 0x88, 0xb8, 0x72, 0xf4, 0xca, 0xb5, 0xfc, 0xd9, 0x40, + 0x67, 0xea, 0x95, 0x3d, 0x73, 0xac, 0xf1, 0xf4, 0xc7, 0x52, 0x77, 0x63, 0x57, 0x97, + 0x4b, 0x0a, 0xd7, 0x87, 0x2a, 0xd6, 0x03, 0xc3, 0x0a, 0x17, 0x4f, 0x96, 0x39, 0x83, + 0x73, 0x9e, 0x5f, 0xa5, 0x30, 0x4d, 0x17, 0x05, 0xc6, 0x79, 0x1e, 0x9c, 0x90, 0x34, + 0x26, 0x83, 0xa3, 0xb1, 0x76, 0xa2, 0x89, 0x7a, 0xb9, 0x14, 0x21, 0x90, 0xb3, 0x90, + 0x0d, 0x08, 0x9c, 0x77, 0xec, 0xe4, 0x13, 0x16, 0xb4, 0x06, 0x11, 0xfc, 0x6b, 0xf7, + 0xc8, 0x1e, 0xb7, 0xb5, 0x89, 0xd6, 0x55, 0x24, 0xf9, 0xc6, 0x88, 0x8f, 0xd7, 0xc5, + 0x3b, 0xa8, 0x10, 0xb0, 0xc7, 0x07, 0x66, 0x43, 0x06, 0x38, 0x59, 0x5d, 0xc3, 0x13, + 0x4e, 0xf5, 0xda, 0x09, 0xc6, 0x68, 0xa8, 0x04, 0xea, 0x1e, 0x2f, 0x14, 0x69, 0xed, + 0xba, 0x0d, 0x45, 0x7a, 0xcd, 0x82, 0x81, 0x82, 0x8d, 0x02, 0xa9, 0x15, 0xbc, 0xbc, + 0x05, 0x94, 0x9d, 0x2e, 0xdc, 0x5c, 0x1c, 0x58, 0x56, 0xfa, 0x79, 0x8e, 0x5c, 0xd3, + 0x58, 0x74, 0x72, 0x90, 0x3c, 0x6c, 0xc2, 0xbb, 0x43, 0xb0, 0x32, 0x29, 0x35, 0x25, + 0x87, 0xcd, 0xe9, 0x88, 0xab, 0x60, 0x04, 0x9b, 0x6f, 0x87, 0x2a, 0x9a, 0xa8, 0x2f, + 0x25, 0xb5, 0x34, 0x6f, 0xc5, 0x6f, 0xe8, 0x68, 0x64, 0x23, 0xb2, 0x7e, 0x0f, 0x36, + 0x8a, 0x43, 0xd3, 0x6a, 0x21, 0x60, 0x2b, 0x40, 0x56, 0x02, 0x2d, 0x25, 0x21, 0x7d, + 0xf4, 0x4a, 0x1f, 0xa3, 0x30, 0x12, 0x21, 0x52, 0xcd, 0x2a, 0x58, 0x1c, 0xa0, 0x5d, + 0x38, 0x01, 0xbf, 0x9f, 0x0a, 0x31, 0xbf, 0x79, 0xb8, 0xa7, 0x39, 0x4f, 0xb8, 0xc9, + 0xbc, 0x16, 0x52, 0xcf, 0xea, 0x9c, 0x38, 0x6c, 0xa7, 0xc7, 0x03, 0xb5, 0x75, 0x4c, + 0x82, 0x43, 0xf7, 0xb0, 0xa3, 0x6b, 0xc2, 0x90, 0xe0, 0x73, 0x3a, 0x17, 0xa9, 0x44, + 0x31, 0xd7, 0xb0, 0x5e, 0x0b, 0x42, 0x98, 0xa8, 0xb2, 0x87, 0xfb, 0x1a, 0xd3, 0xb3, + 0x2a, 0x57, 0x69, 0x3a, 0x1e, 0x78, 0x67, 0xb0, 0xf3, 0xc4, 0x83, 0xc0, 0xab, 0xdd, + 0x2c, 0x05, 0xc8, 0x1c, 0x26, 0xa6, 0x03, 0x20, 0xd9, 0x12, 0x07, 0xf2, 0x04, 0xc2, + 0xe8, 0x39, 0x3a, 0x78, 0xe7, 0x57, 0x2c, 0x8c, 0x29, 0x62, 0x60, 0x35, 0x1e, 0xb6, + 0x29, 0x40, 0xc3, 0x94, 0x94, 0x3c, 0x6a, 0x62, 0x2a, 0x87, 0x10, 0xaa, 0x09, 0xa0, + 0x76, 0xb5, 0x13, 0xdb, 0xbf, 0xdd, 0xfc, 0x31, 0x05, 0x37, 0x9d, 0xa0, 0x8b, 0x97, + 0xa6, 0xfc, 0x68, 0xf2, 0x10, 0x50, 0x88, 0xcb, 0x35, 0xf9, 0x68, 0x31, 0x44, 0xba, + 0x24, 0x67, 0x35, 0x13, 0xf0, 0xb6, 0xaa, 0xca, 0x32, 0xc0, 0xe7, 0x71, 0x73, 0xd7, + 0x38, 0x72, 0x94, 0xa9, 0xb9, 0x6a, 0x08, 0xa0, 0x14, 0xac, 0x88, 0xaf, 0xac, 0xa9, + 0x49, 0xc2, 0xc3, 0x76, 0x0b, 0x46, 0x1d, 0xfc, 0x1b, 0xa5, 0xc0, 0x1a, 0x95, 0x6c, + 0xac, 0x46, 0xa0, 0x1d, 0xc7, 0xd9, 0xa9, 0x92, 0xe1, 0xaa, 0x70, 0x4a, 0xa1, 0x5a, + 0xf5, 0x25, 0x91, 0x18, 0x57, 0xd4, 0x66, 0x82, 0xb1, 0x37, 0xa3, 0x71, 0x9a, 0xaa, + 0x71, 0xf7, 0xa8, 0xba, 0x88, 0xaf, 0xd6, 0xd4, 0x3b, 0x12, 0x78, 0x05, 0xf6, 0xc2, + 0xcb, 0x55, 0xf8, 0x8d, 0x6c, 0x59, 0x07, 0x75, 0x57, 0x73, 0x73, 0xac, 0x87, 0x35, + 0x6a, 0x56, 0xb8, 0x93, 0x41, 0xd0, 0xe8, 0x65, 0x77, 0x37, 0x24, 0x9b, 0xca, 0x66, + 0xb0, 0xb4, 0x19, 0x4a, 0x5c, 0x13, 0xdc, 0xe0, 0x45, 0x03, 0x91, 0x64, 0xfe, 0x15, + 0x30, 0xe3, 0x89, 0x81, 0xf0, 0x8c, 0x66, 0xad, 0x2b, 0xb0, 0x53, 0x1c, 0x36, 0x31, + 0xa8, 0x6f, 0x6c, 0xfa, 0x71, 0x57, 0x1b, 0x77, 0x7b, 0x24, 0x61, 0x60, 0x1b, 0xc7, + 0xa1, 0x46, 0xc3, 0x58, 0x95, 0x5a, 0x5b, 0x44, 0x13, 0x0d, 0x26, 0xb5, 0xc3, 0x53, + 0x22, 0x13, 0x81, 0x33, 0xc0, 0x83, 0xab, 0xa3, 0x00, 0xa5, 0xde, 0xf2, 0xc4, 0xf0, + 0xd9, 0x4d, 0x42, 0x67, 0xa2, 0xad, 0x23, 0x42, 0x0b, 0x76, 0x8c, 0x77, 0xd8, 0xa1, + 0xf0, 0x42, 0x85, 0x36, 0x66, 0x7d, 0x2d, 0xf4, 0x21, 0x27, 0x01, 0x22, 0x91, 0x51, + 0x1a, 0x8c, 0x72, 0x73, 0x8b, 0x82, 0xf0, 0xcf, 0xf8, 0x3b, 0x93, 0x15, 0x33, 0x08, + 0x86, 0xd6, 0x11, 0x18, 0x0d, 0x23, 0x83, 0xcf, 0x55, 0x1a, 0xfe, 0xc4, 0xaa, 0x75, + 0x15, 0xeb, 0x13, 0x8a, 0x39, 0x8e, 0xb4, 0x4c, 0x04, 0x99, 0x86, 0x3a, 0x8f, 0xd0, + 0xda, 0x25, 0x30, 0xb7, 0xde, 0xef, 0xd5, 0xf1, 0x18, 0x36, 0x46, 0x01, 0x05, 0x55, + 0x33, 0x3a, 0x6c, 0xd0, 0xe6, 0xad, 0x0d, 0x6b, 0xf9, 0x19, 0x67, 0x82, 0x52, 0xc4, + 0x93, 0x58, 0xa3, 0x53, 0x22, 0xa4, 0x58, 0x53, 0x0b, 0x7c, 0x2b, 0x60, 0xf3, 0xb1, + 0x70, 0xd5, 0x0a, 0x58, 0x92, 0xe0, 0x6a, 0x9f, 0x82, 0xee, 0x0e, 0x34, 0xd5, 0x6c, + 0x99, 0x31, 0x2b, + ], + dk: [0x04; 32], + dk_pq: [ + 0x79, 0xf1, 0xb2, 0xce, 0x3b, 0x60, 0x1e, 0xbf, 0x5b, 0xa3, 0x10, 0x06, 0xe5, 0xa8, + 0xe4, 0xc8, 0x6c, 0xd5, 0x81, 0x48, 0xc7, 0x5a, 0x89, 0x17, 0x37, 0x11, 0xae, 0xad, + 0x9a, 0xcc, 0xf0, 0x9f, 0x15, 0x8d, 0x0f, 0xac, 0xb0, 0x85, 0xbf, 0x62, 0x4b, 0x4d, + 0xe5, 0xa3, 0x88, 0xfa, 0xb8, 0xe6, 0x04, 0x19, 0xb0, 0x47, 0x10, 0x47, 0x53, 0x67, + 0xa0, 0xfa, 0x9c, 0x13, 0x97, 0xc9, 0x6d, 0x61, + ], + dk_t: [ + 0x43, 0x2e, 0xab, 0x0f, 0x3a, 0x8e, 0xeb, 0x77, 0xc6, 0xb0, 0x00, 0x0b, 0x92, 0x92, + 0xc6, 0xe1, 0x63, 0x91, 0x40, 0x78, 0xc9, 0x4a, 0x16, 0x18, 0x29, 0xfc, 0xfb, 0x9b, + 0xb3, 0x44, 0x73, 0x93, + ], + ct: &[ + 0xcf, 0xe3, 0x18, 0x62, 0x85, 0x31, 0x64, 0x95, 0x01, 0x23, 0xba, 0xa7, 0x55, 0x49, + 0x41, 0x8c, 0x7a, 0x40, 0x6c, 0xfb, 0x60, 0x00, 0x3b, 0x82, 0x5e, 0xb2, 0x92, 0xf1, + 0xba, 0x1f, 0x25, 0xc3, 0xb5, 0xb0, 0x44, 0xdc, 0xe0, 0xb8, 0xb1, 0x6c, 0xb2, 0x54, + 0xd6, 0x96, 0x58, 0xd5, 0x16, 0xcd, 0x34, 0x45, 0xe3, 0xf1, 0x8b, 0xcd, 0xe3, 0x2c, + 0x4f, 0x46, 0xb4, 0xac, 0x25, 0xdc, 0xa4, 0xc4, 0x57, 0x36, 0x47, 0xab, 0x7c, 0xef, + 0xd7, 0xfc, 0xbb, 0x7c, 0x19, 0x2d, 0x99, 0x71, 0x94, 0x65, 0x4a, 0xea, 0xc0, 0xf5, + 0x93, 0xed, 0xdc, 0x44, 0x64, 0xe7, 0xe1, 0x25, 0x67, 0x2f, 0xc7, 0x26, 0x5f, 0x16, + 0x64, 0xb3, 0x21, 0x99, 0xca, 0xd4, 0x50, 0x95, 0x35, 0x9a, 0x4d, 0xd8, 0x0e, 0x96, + 0x37, 0xf0, 0x14, 0x05, 0x04, 0xa7, 0xb1, 0x30, 0x3f, 0xa6, 0x9d, 0x12, 0x1d, 0x2d, + 0x21, 0x4d, 0x5e, 0xa4, 0x4e, 0x00, 0x46, 0xa1, 0x20, 0xfe, 0xf7, 0xd5, 0x73, 0x01, + 0x6d, 0x8e, 0xdf, 0x0c, 0x20, 0x74, 0x9f, 0x05, 0xed, 0xcc, 0xca, 0x4a, 0x30, 0x56, + 0x5d, 0xf6, 0xe7, 0x90, 0x15, 0xf0, 0x4b, 0x03, 0x62, 0x3d, 0x3a, 0xa2, 0x5c, 0xdb, + 0xaf, 0xf3, 0x30, 0x63, 0x34, 0x70, 0xc0, 0x28, 0x96, 0x89, 0x98, 0x8c, 0x27, 0xfe, + 0x49, 0xac, 0xc9, 0x57, 0xd3, 0xbe, 0x72, 0xc4, 0xbc, 0xe0, 0x5f, 0x1c, 0x80, 0xf3, + 0xc2, 0xad, 0x5b, 0x4e, 0x8a, 0x27, 0x14, 0xc1, 0xd1, 0xea, 0x51, 0x8f, 0x43, 0x1f, + 0x97, 0xf6, 0xd6, 0x8e, 0xaf, 0xb0, 0x6a, 0xd7, 0x22, 0x6a, 0x29, 0xa2, 0xb3, 0xa9, + 0xe5, 0x40, 0x3c, 0xdd, 0x92, 0x34, 0x00, 0xa4, 0x30, 0x30, 0x54, 0x87, 0x69, 0x86, + 0xf8, 0x34, 0x84, 0x8a, 0x49, 0x02, 0x65, 0x9b, 0x28, 0x8d, 0x5e, 0x3e, 0xf2, 0x6a, + 0x9e, 0xcb, 0x3f, 0x1b, 0xe3, 0x63, 0x00, 0x37, 0xd1, 0x47, 0x30, 0x14, 0x98, 0xbf, + 0xe1, 0x98, 0xb8, 0x11, 0x6f, 0x24, 0x4a, 0x12, 0x54, 0x7f, 0xfe, 0x6a, 0x50, 0x06, + 0xf7, 0x48, 0xc0, 0x48, 0x5f, 0xd7, 0x22, 0x32, 0xe0, 0xc5, 0x5d, 0xf0, 0x90, 0x01, + 0x19, 0x46, 0xc8, 0xb4, 0x93, 0xf8, 0xaa, 0xf9, 0x2d, 0xe0, 0x73, 0x96, 0xe9, 0x01, + 0xfb, 0x4d, 0xd8, 0xa4, 0xf2, 0x91, 0x64, 0x52, 0x67, 0xe7, 0xec, 0x03, 0x35, 0xea, + 0xed, 0xec, 0xa2, 0x8a, 0xb4, 0xc3, 0x63, 0x28, 0xc7, 0x32, 0x03, 0xdb, 0xca, 0x87, + 0xe4, 0x0d, 0xcf, 0x00, 0x7b, 0xf8, 0x68, 0x7d, 0xd4, 0xa7, 0x76, 0x15, 0x1e, 0x9d, + 0x23, 0x4f, 0x52, 0x44, 0x2a, 0x33, 0xc7, 0x56, 0x6b, 0x00, 0x7f, 0x65, 0x37, 0x83, + 0x7c, 0xf7, 0x52, 0x60, 0x26, 0x24, 0x03, 0x06, 0x15, 0xd0, 0xcb, 0x88, 0x23, 0x8b, + 0x91, 0xf5, 0x78, 0xe0, 0x72, 0x8b, 0x32, 0x73, 0x43, 0x63, 0x94, 0x4b, 0xbf, 0xce, + 0x58, 0x84, 0xdc, 0x3c, 0x77, 0x7e, 0x0b, 0x3f, 0x1e, 0xe4, 0x02, 0x92, 0x98, 0x89, + 0x5e, 0x6b, 0x82, 0xf6, 0xf2, 0x30, 0x7d, 0xfc, 0x26, 0x7e, 0x27, 0xca, 0x8d, 0x7d, + 0x9b, 0x49, 0xb9, 0x07, 0x86, 0xb7, 0xf3, 0x9d, 0x90, 0x6c, 0xa7, 0xb6, 0x52, 0x7d, + 0x5e, 0x31, 0x31, 0x6f, 0xce, 0x02, 0x14, 0x41, 0x8f, 0x95, 0xab, 0x95, 0x04, 0xc9, + 0x8b, 0xa9, 0xe8, 0x68, 0x75, 0x4c, 0xb8, 0x13, 0x01, 0x4c, 0xbb, 0x19, 0x6e, 0xac, + 0x15, 0x28, 0x61, 0xaf, 0x71, 0x9c, 0x76, 0x32, 0x71, 0x07, 0x54, 0xcd, 0x2c, 0x72, + 0x54, 0x4c, 0x25, 0xb6, 0x6d, 0x1d, 0x01, 0x6f, 0x97, 0xa4, 0x09, 0xec, 0xd1, 0x15, + 0x77, 0xa3, 0x58, 0x64, 0x7e, 0x17, 0x26, 0xda, 0x16, 0xd0, 0xa0, 0xe2, 0x59, 0x1e, + 0xb3, 0xb7, 0xca, 0xc7, 0xfe, 0x47, 0xfb, 0xee, 0xf1, 0x0c, 0x6e, 0xeb, 0x92, 0x89, + 0xaa, 0x41, 0x54, 0xd4, 0x2e, 0xa7, 0x5b, 0x86, 0x4e, 0x0a, 0x12, 0x15, 0xae, 0x35, + 0xdd, 0x0d, 0xb3, 0xfb, 0xbe, 0xf3, 0x9a, 0xd3, 0x99, 0xc3, 0xd0, 0x4d, 0x0d, 0x4a, + 0xd9, 0xf2, 0xce, 0x44, 0x2b, 0xc0, 0x7d, 0xab, 0xd3, 0x66, 0x30, 0x7e, 0xef, 0xcb, + 0x2a, 0xb4, 0x83, 0xdb, 0xe8, 0x0b, 0x3e, 0xb4, 0xfe, 0x96, 0x61, 0x31, 0xa5, 0x87, + 0xff, 0xb2, 0xe3, 0x66, 0x4d, 0x31, 0xe2, 0xc5, 0x20, 0x72, 0x2d, 0xc1, 0xa1, 0xf5, + 0xd2, 0x7e, 0xd0, 0xe9, 0x37, 0xc4, 0xc8, 0x99, 0x63, 0x57, 0x6c, 0xdc, 0xa0, 0x01, + 0x36, 0x1f, 0x11, 0xbd, 0x39, 0xe2, 0xe2, 0xb3, 0x67, 0x94, 0x33, 0x05, 0xfc, 0xdd, + 0xcb, 0xce, 0x64, 0x60, 0xa8, 0xba, 0xfe, 0xff, 0x83, 0x94, 0xbe, 0xba, 0x9b, 0xb8, + 0x93, 0xf1, 0xa7, 0xab, 0xfd, 0x2e, 0x80, 0xbf, 0x10, 0xf0, 0x54, 0x6e, 0x72, 0xa4, + 0x05, 0x18, 0x83, 0xe1, 0xf7, 0xed, 0xfe, 0x12, 0xee, 0x15, 0x05, 0xd9, 0x50, 0x3a, + 0x83, 0xdd, 0xb2, 0xb9, 0x98, 0xcb, 0x24, 0x75, 0xb8, 0x8d, 0x28, 0x0f, 0x1d, 0xf6, + 0x88, 0xf4, 0x72, 0x96, 0x8f, 0x8c, 0x71, 0x8f, 0x1f, 0x9f, 0xbd, 0x39, 0xfb, 0x30, + 0x73, 0x31, 0x2b, 0xc5, 0x4c, 0x75, 0x52, 0x10, 0xd0, 0xef, 0x49, 0xf9, 0xf2, 0xbc, + 0xf0, 0x6a, 0x10, 0x99, 0x13, 0x2a, 0x1e, 0x08, 0xd8, 0x4b, 0x68, 0x54, 0x38, 0x48, + 0xe1, 0x53, 0x8e, 0xdd, 0x88, 0x16, 0x20, 0x56, 0x0e, 0x54, 0xd8, 0xd6, 0xf9, 0xa7, + 0x1c, 0xa2, 0xfd, 0x44, 0xf8, 0xfa, 0xb9, 0xd0, 0x94, 0xf1, 0xdc, 0xe5, 0x2f, 0x40, + 0xc5, 0xaa, 0xfe, 0x1f, 0x73, 0xe9, 0x8a, 0x2a, 0x39, 0x5f, 0x48, 0xd5, 0xda, 0x98, + 0xfa, 0x5c, 0x95, 0xe4, 0xaf, 0xaf, 0x84, 0xe7, 0xa1, 0x38, 0x80, 0x7f, 0x71, 0xeb, + 0x64, 0xfc, 0xb3, 0xb5, 0x16, 0x9e, 0x8b, 0xed, 0xae, 0x1d, 0xff, 0xd7, 0x25, 0xad, + 0x6f, 0xba, 0x9f, 0xd5, 0x0f, 0x39, 0xdb, 0x94, 0x32, 0xcd, 0x5f, 0x37, 0x9b, 0x68, + 0x0c, 0x09, 0xc5, 0x31, 0x3e, 0xa7, 0x35, 0x17, 0xf0, 0x17, 0xdd, 0xcc, 0xa3, 0x3a, + 0x40, 0x5c, 0x0c, 0xa2, 0x93, 0xd8, 0xc3, 0x47, 0x14, 0xae, 0xc2, 0x41, 0xb9, 0xa6, + 0x34, 0xec, 0x65, 0xc8, 0xc0, 0xb5, 0x6e, 0x59, 0xdf, 0x8e, 0x66, 0x8e, 0x74, 0xd2, + 0x49, 0x4b, 0xca, 0x14, 0xd8, 0x10, 0x2d, 0xc0, 0x59, 0x2d, 0xbf, 0x93, 0xc0, 0xad, + 0x5f, 0x9d, 0xc8, 0x9a, 0xc2, 0x4a, 0x7e, 0x98, 0x1f, 0xec, 0xa0, 0x46, 0x1d, 0x3f, + 0xce, 0x1e, 0xec, 0x98, 0xa4, 0xaf, 0xbb, 0x0b, 0x7e, 0x6c, 0x46, 0xae, 0xc3, 0x85, + 0xc9, 0xc0, 0xfb, 0xc2, 0x03, 0x26, 0x4a, 0xa6, 0xaa, 0x71, 0xc6, 0x7f, 0xff, 0x15, + 0x9c, 0xcb, 0xac, 0x01, 0xcd, 0xd8, 0x5c, 0x28, 0x83, 0x5a, 0x98, 0xe9, 0xb7, 0xd0, + 0xcd, 0x4c, 0x43, 0x30, 0xa0, 0xa5, 0x33, 0x4b, 0x58, 0x38, 0xc0, 0x72, 0xdf, 0x4b, + 0xd7, 0x29, 0x72, 0x51, 0xcb, 0xf8, 0x5d, 0xd8, 0x30, 0x6e, 0x1a, 0x8e, 0xc8, 0x93, + 0xf4, 0xb9, 0x55, 0x81, 0x33, 0xe2, 0x0e, 0x0c, 0x95, 0x98, 0xf0, 0x54, 0xe2, 0xb0, + 0xb7, 0x7d, 0x44, 0x94, 0xc3, 0x93, 0xc5, 0xdd, 0x0e, 0x83, 0xa6, 0x52, 0x02, 0x43, + 0xed, 0xc5, 0x62, 0x00, 0xf1, 0xcd, 0x34, 0xb8, 0xf6, 0x9d, 0x53, 0xe4, 0xa8, 0x23, + 0xa4, 0x68, 0x52, 0xe6, 0x16, 0x72, 0xba, 0x69, 0x44, 0x7e, 0xe4, 0x95, 0x22, 0x97, + 0x8c, 0x64, 0x61, 0x6e, 0xa4, 0x2a, 0x0b, 0x0c, 0x6c, 0xc9, 0x53, 0xc7, 0x48, 0xa5, + 0x50, 0xdb, 0xab, 0xd7, 0x40, 0x10, 0xcd, 0xb8, 0xfd, 0x19, 0xc8, 0x86, 0x24, 0x73, + 0xf8, 0x26, 0x26, 0x7c, 0x8c, 0xf4, 0x1c, 0xfc, 0x36, 0x10, 0x06, 0x65, 0xeb, 0xd7, + 0x66, 0x39, 0x0d, 0x83, 0xc1, 0xb2, 0xf7, 0x95, 0xcb, 0x6d, 0x3c, 0x38, 0xdc, 0xb8, + 0xe9, 0x8c, 0x6e, 0xc0, 0xcd, 0x51, 0x11, 0x10, 0x8a, 0x07, 0x9d, 0x57, 0xf9, 0xb1, + 0x69, 0x60, 0xd9, 0x4a, 0x4f, 0x23, 0x8a, 0x6d, 0x7a, 0x25, 0xb6, 0x25, 0x3b, 0x0a, + 0xe0, 0x08, 0x8c, 0xe4, 0x14, 0x40, 0x6f, 0xa7, 0xd0, 0x20, 0x04, 0x69, 0x26, 0x81, + 0xe4, 0xd9, 0x57, 0x78, 0x6b, 0xe9, 0xfb, 0x7f, 0x06, 0x41, 0x13, 0x52, 0x63, 0x89, + 0xda, 0xb6, 0xff, 0x0a, 0x2d, 0xd6, 0xdd, 0xe4, 0x2c, 0x5e, 0x57, 0x9b, 0xf9, 0x96, + 0xd6, 0xea, 0x33, 0xdc, 0x52, 0xc8, 0xb1, 0x5c, 0x92, 0xb6, 0x17, 0x2b, 0xe0, 0x78, + 0x1e, 0x33, 0x96, 0x00, 0x66, 0x65, 0x00, 0x88, 0x27, 0x4a, 0xe5, 0x77, 0xe6, 0x46, + 0x5e, 0x8f, 0xcf, 0xca, 0xe7, + ], + ss: [ + 0x79, 0x4e, 0x2f, 0x99, 0xd9, 0xa8, 0x90, 0xc3, 0x38, 0xc2, 0x4a, 0x01, 0x80, 0x35, + 0xf8, 0xf5, 0x1d, 0xb5, 0x76, 0xfa, 0xf0, 0xcd, 0xe9, 0x6c, 0xf7, 0x77, 0xa8, 0x1b, + 0xdc, 0xcc, 0xe8, 0x64, + ], + }, + TestVector { + seed: [0x05; 32], + randomness: [0x69; 128], + ek: &[ + 0x33, 0x39, 0x34, 0x46, 0xa7, 0x6c, 0x2c, 0x01, 0xb4, 0x4d, 0xa5, 0x69, 0x6d, 0x84, + 0x52, 0xb2, 0x9a, 0xb7, 0xb9, 0x17, 0x87, 0x76, 0x53, 0x66, 0xbc, 0x1a, 0x15, 0xb1, + 0x49, 0x79, 0x24, 0x27, 0x84, 0x4f, 0xf6, 0x87, 0x53, 0xf9, 0x57, 0x18, 0x7c, 0x10, + 0x2d, 0x09, 0x40, 0xc4, 0x98, 0xb6, 0x73, 0x32, 0xa7, 0xf9, 0xcb, 0xb8, 0x2f, 0xd3, + 0xbe, 0xc9, 0x91, 0x4e, 0x05, 0xa9, 0x55, 0x03, 0x53, 0x62, 0xdc, 0x74, 0x62, 0x07, + 0x1c, 0x19, 0xe2, 0x25, 0xac, 0x96, 0xc1, 0x2f, 0xa3, 0x4a, 0x2e, 0x86, 0xe0, 0xa8, + 0x4a, 0x0c, 0x63, 0x3e, 0x04, 0x4b, 0x3d, 0x93, 0x96, 0x97, 0x05, 0x83, 0x3a, 0x53, + 0xa4, 0x25, 0x7b, 0x7f, 0x4c, 0x15, 0x15, 0xce, 0xaa, 0x8a, 0xf9, 0xeb, 0x7f, 0x53, + 0xca, 0x7c, 0xb4, 0x02, 0xa4, 0xab, 0xa1, 0x1c, 0x9d, 0x32, 0x06, 0xf8, 0x20, 0x9c, + 0x43, 0x6b, 0xc3, 0xea, 0x04, 0x87, 0xc4, 0x56, 0xa7, 0x9e, 0x24, 0x0f, 0xc4, 0xf5, + 0x82, 0x9e, 0x49, 0x77, 0x81, 0x7a, 0xac, 0x9d, 0xe9, 0xa0, 0xcf, 0x6c, 0xc2, 0x81, + 0x31, 0xbe, 0x92, 0xc2, 0xa6, 0xec, 0x67, 0x2b, 0xca, 0x1a, 0x8b, 0x37, 0x58, 0x09, + 0x2f, 0x8b, 0x87, 0xa1, 0x15, 0x65, 0xc0, 0x31, 0x2e, 0x82, 0x93, 0x9f, 0x8f, 0xd1, + 0x80, 0x24, 0xa7, 0x1b, 0xb9, 0x8a, 0x88, 0x5c, 0x6a, 0xb9, 0x92, 0x99, 0xcd, 0x43, + 0xa6, 0x20, 0x8d, 0x21, 0x98, 0xa4, 0x5b, 0xcd, 0xbe, 0xc5, 0x90, 0x15, 0x73, 0x75, + 0xc1, 0x6a, 0x45, 0x63, 0x27, 0xbb, 0xd4, 0x40, 0x11, 0xb6, 0x35, 0xcd, 0x1f, 0x67, + 0x82, 0x77, 0x34, 0x7a, 0xa5, 0xa7, 0x65, 0xb7, 0x20, 0x8a, 0xca, 0xa4, 0x31, 0x6e, + 0xa5, 0x23, 0xf5, 0x9a, 0x06, 0x71, 0x59, 0x4e, 0x56, 0x12, 0x16, 0x54, 0xf3, 0x58, + 0x1e, 0x88, 0x20, 0x72, 0x39, 0x69, 0x32, 0xda, 0x2e, 0x2e, 0xa0, 0x2b, 0xf5, 0x48, + 0x9e, 0x54, 0x6c, 0x45, 0x2b, 0x7c, 0x6f, 0x60, 0xe8, 0xa4, 0xc6, 0x11, 0x2f, 0x6c, + 0xcc, 0x7e, 0x3a, 0x7a, 0x44, 0x74, 0x8a, 0xa1, 0x30, 0x88, 0x07, 0xa0, 0x8c, 0x15, + 0xd7, 0x8a, 0x2e, 0x19, 0xa2, 0x75, 0x0a, 0x91, 0x6b, 0x8c, 0x46, 0x84, 0x4b, 0x25, + 0x7c, 0x26, 0x63, 0xa8, 0x89, 0x5b, 0x3d, 0xf8, 0xc4, 0x09, 0x60, 0xe6, 0xb9, 0x12, + 0x62, 0x3c, 0x8a, 0x92, 0xc9, 0xfb, 0x43, 0x5d, 0x20, 0xe6, 0xcd, 0xa9, 0xfb, 0x45, + 0x6e, 0x55, 0xc1, 0xdd, 0x90, 0xa5, 0xf6, 0x4a, 0x5a, 0xc2, 0xc6, 0x12, 0x50, 0x46, + 0x17, 0x57, 0x51, 0xaa, 0x74, 0x29, 0x71, 0xf1, 0x72, 0x83, 0x28, 0xc3, 0x53, 0xf4, + 0xa7, 0xa0, 0x8f, 0xf1, 0x6b, 0x8f, 0x97, 0x8a, 0xe4, 0x17, 0x24, 0x49, 0x4c, 0x43, + 0x64, 0x71, 0x50, 0x5e, 0x2c, 0x17, 0xba, 0x95, 0x8a, 0xde, 0x7b, 0x2a, 0xfb, 0xf9, + 0xcc, 0x26, 0x65, 0x51, 0x89, 0x49, 0x75, 0x5f, 0xd5, 0xbb, 0x8b, 0x15, 0xac, 0x9b, + 0x80, 0xb7, 0x8f, 0xa6, 0x15, 0xa9, 0x18, 0xc4, 0xa9, 0x95, 0x49, 0xc3, 0x7c, 0x6a, + 0xd0, 0x01, 0x7c, 0x51, 0xc3, 0x96, 0x3e, 0x34, 0x08, 0xb1, 0x18, 0x48, 0xdd, 0xd4, + 0xaf, 0xe9, 0x6b, 0x67, 0xcd, 0x66, 0xc7, 0x6e, 0x81, 0x7d, 0x4c, 0x15, 0x0d, 0xe5, + 0x2a, 0x72, 0x05, 0x05, 0xb9, 0xa4, 0xb0, 0x90, 0x08, 0x24, 0x3c, 0x0f, 0xb0, 0x5e, + 0xf0, 0x04, 0xb9, 0xc2, 0xc2, 0x23, 0xf9, 0x23, 0x0d, 0xc5, 0x7b, 0x1d, 0xd3, 0xd1, + 0x87, 0x34, 0x57, 0x84, 0x2b, 0x47, 0xc5, 0x9b, 0x9a, 0x6b, 0x39, 0xd7, 0xb6, 0x17, + 0x87, 0xb4, 0x2a, 0x50, 0x0c, 0x9f, 0x57, 0x11, 0x4e, 0xc7, 0x37, 0xbf, 0x7c, 0x45, + 0x30, 0x3b, 0x8a, 0x3f, 0xa7, 0x8b, 0x3c, 0x64, 0x9c, 0xfb, 0xd1, 0x66, 0xc6, 0x0c, + 0x37, 0xde, 0xa8, 0x9e, 0x2d, 0xf7, 0x1c, 0xe4, 0xc6, 0x05, 0xfe, 0x45, 0xab, 0xca, + 0xf3, 0xa6, 0x04, 0xf5, 0x48, 0xee, 0x50, 0x30, 0xfd, 0xf4, 0x9a, 0xd4, 0x12, 0x9b, + 0x94, 0x51, 0x6a, 0x22, 0xa8, 0xb7, 0x28, 0x11, 0x2b, 0xfd, 0x20, 0x9e, 0x5a, 0x5b, + 0x56, 0x5e, 0x20, 0xa8, 0xdc, 0xe9, 0x77, 0x48, 0xa7, 0x90, 0x63, 0x79, 0x0b, 0xec, + 0x93, 0xbc, 0x89, 0x10, 0x3c, 0x32, 0x41, 0x9b, 0xba, 0xdc, 0x1f, 0xfc, 0x67, 0x9e, + 0x48, 0x13, 0x9a, 0x0c, 0x88, 0x56, 0x3f, 0x17, 0x0d, 0x16, 0x57, 0x29, 0xe3, 0xd7, + 0x10, 0x36, 0x5c, 0x40, 0x4d, 0xfc, 0x87, 0xd7, 0xc3, 0x1e, 0xfd, 0x24, 0x78, 0x5a, + 0x92, 0x65, 0xe5, 0x5c, 0x4a, 0x62, 0x43, 0x15, 0xdb, 0x40, 0x05, 0x01, 0x98, 0x18, + 0xa1, 0xe7, 0xc0, 0x36, 0x7a, 0x70, 0xfb, 0xd1, 0x60, 0x98, 0xe2, 0x7a, 0x64, 0x0b, + 0x0f, 0x3d, 0xd9, 0x51, 0x5d, 0x82, 0xbe, 0x06, 0x37, 0x50, 0x6f, 0xf1, 0x71, 0xc6, + 0xa3, 0x1e, 0xdf, 0x45, 0x3b, 0x40, 0xa6, 0x16, 0x2f, 0xeb, 0x7c, 0x35, 0x43, 0x50, + 0x6b, 0xc1, 0x10, 0x5c, 0xe1, 0x96, 0xe4, 0x60, 0x97, 0xdb, 0x74, 0x9b, 0x48, 0x58, + 0x08, 0xdc, 0xc3, 0xb4, 0x22, 0x14, 0x70, 0xac, 0x21, 0x88, 0x0b, 0xc2, 0x3c, 0x7e, + 0xf4, 0xb3, 0x15, 0xf4, 0x0d, 0xf4, 0x08, 0x02, 0xf7, 0x32, 0x49, 0x57, 0xb4, 0x50, + 0x03, 0x2c, 0x31, 0x04, 0xf8, 0x71, 0x25, 0x05, 0x90, 0xa4, 0xc9, 0xa2, 0x96, 0x87, + 0xc7, 0x0e, 0x02, 0xb4, 0x63, 0x50, 0x78, 0x1a, 0xbc, 0x7c, 0x2b, 0x25, 0x6c, 0x54, + 0xbb, 0xc9, 0x6e, 0xb2, 0x0b, 0x89, 0x18, 0x77, 0xc3, 0xa6, 0x73, 0xf6, 0x7c, 0x18, + 0x19, 0x7a, 0x0e, 0x3d, 0x65, 0x71, 0x96, 0xd5, 0x67, 0x3e, 0xfb, 0x19, 0xeb, 0xf9, + 0xb3, 0xe4, 0x96, 0x91, 0x61, 0x28, 0x34, 0xcb, 0x66, 0x2d, 0x28, 0x28, 0x93, 0x8b, + 0x1a, 0xc1, 0xa4, 0x58, 0x81, 0xb9, 0xe5, 0x1c, 0x78, 0x6c, 0x1a, 0x32, 0x18, 0x14, + 0xa8, 0xc3, 0x96, 0x42, 0x1b, 0x7f, 0x31, 0x3c, 0xc2, 0xe4, 0x44, 0x7e, 0x6e, 0x87, + 0x97, 0x1e, 0x16, 0x60, 0xd9, 0x4a, 0xad, 0x5f, 0x13, 0xb2, 0x6b, 0xf4, 0x9f, 0xa4, + 0x99, 0x82, 0x2b, 0x19, 0x59, 0xf4, 0x8a, 0xa8, 0x8d, 0xfa, 0x51, 0x01, 0xf4, 0x63, + 0xd5, 0xbb, 0xc8, 0xca, 0x21, 0xb9, 0xd0, 0x85, 0x7f, 0xd2, 0xe4, 0x2d, 0x5c, 0x1c, + 0x7a, 0x91, 0x92, 0x76, 0x5a, 0x30, 0x13, 0xee, 0xf5, 0x4c, 0xa9, 0xe4, 0x3f, 0xa9, + 0x9a, 0xbf, 0xd8, 0x05, 0x3e, 0x90, 0x59, 0x65, 0x0b, 0x96, 0x4d, 0x6a, 0xea, 0x8c, + 0x26, 0xc1, 0x3a, 0xdc, 0x0a, 0x6d, 0x91, 0x20, 0x8f, 0x2d, 0xea, 0x0d, 0xa4, 0xd5, + 0x7a, 0x3a, 0x8a, 0x6b, 0xe9, 0x15, 0x6a, 0x40, 0x65, 0x05, 0x8c, 0xf9, 0x65, 0xda, + 0x10, 0x58, 0x6b, 0x09, 0x45, 0xc3, 0x09, 0x65, 0xbf, 0x8a, 0x43, 0x6a, 0xaa, 0x11, + 0x5a, 0xb1, 0x70, 0x07, 0x1c, 0x30, 0x80, 0xf5, 0xc7, 0x23, 0xc1, 0x0d, 0x05, 0x96, + 0x3a, 0x16, 0x26, 0x22, 0x43, 0x86, 0x82, 0xfe, 0xe1, 0xb6, 0x19, 0xc2, 0xb1, 0x0c, + 0x20, 0x7a, 0xd7, 0xd3, 0x8a, 0xb1, 0xea, 0x7e, 0xda, 0x09, 0x24, 0xd9, 0xab, 0x6b, + 0x44, 0x33, 0x86, 0xaf, 0x7b, 0x07, 0xfe, 0x26, 0xb8, 0xfc, 0x69, 0x11, 0x78, 0x96, + 0x66, 0xbc, 0x14, 0x61, 0x9a, 0x38, 0x1e, 0xba, 0x79, 0x66, 0xe0, 0xb4, 0xab, 0x0e, + 0x52, 0x80, 0x83, 0x80, 0x6f, 0x46, 0x45, 0x6f, 0x97, 0xe5, 0x92, 0x76, 0xd5, 0xa6, + 0x11, 0x9b, 0x76, 0x6b, 0x18, 0x47, 0xd3, 0xa1, 0xad, 0x3c, 0x40, 0x22, 0xcd, 0x06, + 0x16, 0xbb, 0xc3, 0x48, 0xd4, 0xe0, 0x72, 0xf7, 0xd6, 0x82, 0x72, 0x61, 0x7b, 0x03, + 0xbc, 0x9b, 0x25, 0xf5, 0x69, 0xd0, 0xb1, 0x1d, 0xab, 0x8c, 0x5a, 0x7e, 0xe1, 0x1e, + 0xe6, 0xc7, 0x61, 0xee, 0x68, 0x46, 0x25, 0x32, 0x2c, 0x6c, 0xdc, 0x81, 0x5e, 0xe1, + 0xc0, 0xac, 0xd2, 0x9a, 0x8e, 0x1c, 0x82, 0x6c, 0xf8, 0x9f, 0x25, 0x94, 0x45, 0x93, + 0x33, 0x66, 0x43, 0xa4, 0x64, 0x83, 0xdc, 0xac, 0xa9, 0xe1, 0xba, 0xe9, 0xa1, 0x96, + 0xf6, 0x92, 0xac, 0x05, 0x32, 0xcd, 0x91, 0x11, 0x3d, 0x5d, 0x97, 0x49, 0x63, 0xa5, + 0x24, 0xbf, 0x70, 0x8c, 0x44, 0xe1, 0x98, 0xdd, 0x21, 0x2d, 0xfc, 0xf6, 0x92, 0x13, + 0xa4, 0x2e, 0x32, 0xe6, 0xb7, 0xc8, 0x60, 0x14, 0x8e, 0xd3, 0x8c, 0x51, 0x00, 0x2b, + 0x83, 0xb0, 0xc4, 0xb9, 0x79, 0xb5, 0x2a, 0x75, 0x3b, 0xf2, 0xc3, 0x38, 0x1c, 0x02, + 0x76, 0x23, 0xb8, 0xa8, 0x25, 0x1e, 0x60, 0xf5, 0x55, 0x24, 0xb5, 0x6b, 0x95, 0x9a, + 0x14, 0xd8, 0x46, 0x37, 0x08, 0x6a, 0x15, 0x56, 0x77, 0x17, 0xdb, 0xda, 0x7a, 0xff, + 0x9f, 0xd6, 0x1d, 0x09, 0x58, 0x9a, 0xc8, 0xc0, 0x04, 0x45, 0x38, 0xba, 0xfe, 0xa1, + 0x20, 0x05, 0x48, 0x04, 0x6b, 0x8f, 0xe3, 0x68, 0x1c, 0xfc, 0xb4, 0x3a, 0x8a, 0x1b, + 0x5d, 0xf7, 0x85, 0xf3, 0xb0, 0xcc, 0x71, 0x3c, 0x0b, 0xbb, 0xff, 0xd9, 0xfd, 0x69, + 0x1d, 0xf9, 0xac, 0xd2, 0x25, 0x8c, 0x96, 0x71, 0xa1, 0x4b, 0x4c, 0xee, 0x57, 0x3e, + 0x71, 0x1c, 0xf6, 0xd8, 0xeb, 0x9e, 0xe0, 0x1f, 0x95, 0x63, 0xde, 0xa7, 0x43, 0x8d, + 0x48, 0x4b, 0x5d, + ], + dk: [0x05; 32], + dk_pq: [ + 0x74, 0x9f, 0xe3, 0xa6, 0xfc, 0x42, 0x9b, 0x23, 0x69, 0xd9, 0xe8, 0x19, 0x1f, 0x72, + 0xd4, 0xfd, 0x3b, 0x29, 0x2f, 0x2f, 0x12, 0x23, 0x12, 0xbf, 0xaf, 0x4b, 0x6a, 0x90, + 0xf1, 0x60, 0x0c, 0x46, 0x70, 0xeb, 0xea, 0x7a, 0xec, 0x85, 0x1d, 0x89, 0xf0, 0x09, + 0x5c, 0x61, 0xa2, 0xca, 0xff, 0xb3, 0x7f, 0x1b, 0xa7, 0xf2, 0x1d, 0xd5, 0x14, 0xb0, + 0xe2, 0x00, 0x06, 0x96, 0x9d, 0x48, 0x5c, 0xa9, + ], + dk_t: [ + 0x73, 0x0d, 0xef, 0x4e, 0x09, 0x0b, 0x60, 0xc0, 0x56, 0xe1, 0xa9, 0xb6, 0x53, 0xf4, + 0x79, 0xaf, 0x73, 0x98, 0xbe, 0xa9, 0x57, 0x71, 0x05, 0x4a, 0xb4, 0xf4, 0x55, 0xc9, + 0xa8, 0x6d, 0x7e, 0x49, + ], + ct: &[ + 0x6d, 0xc4, 0x76, 0xcb, 0xc9, 0x1f, 0xa3, 0x89, 0x5c, 0xfd, 0x69, 0xbd, 0xa5, 0x79, + 0x9b, 0x95, 0xb7, 0xc0, 0xdc, 0x87, 0xe5, 0xc7, 0x8d, 0xec, 0x9b, 0x36, 0x7d, 0xf5, + 0x8a, 0xbf, 0x3e, 0x78, 0x52, 0xaf, 0xb7, 0xb3, 0x1c, 0xaf, 0xf8, 0x56, 0xe5, 0xe4, + 0x13, 0x6a, 0x23, 0xa2, 0x4f, 0x30, 0x3c, 0x61, 0x00, 0xd9, 0xa0, 0xa6, 0x67, 0x31, + 0x64, 0xf6, 0xf4, 0x4e, 0xa4, 0x72, 0xf4, 0x61, 0x4c, 0x2b, 0x42, 0x49, 0x6d, 0x00, + 0x49, 0xa2, 0x7e, 0x02, 0xf1, 0xaa, 0x45, 0xba, 0x04, 0x44, 0x2a, 0x74, 0xb5, 0xe0, + 0x03, 0x5d, 0xf3, 0xd8, 0x87, 0x72, 0x66, 0xa4, 0x24, 0x1e, 0x65, 0x0a, 0x86, 0xcc, + 0xdf, 0xb0, 0xc6, 0xce, 0xf2, 0x2c, 0x62, 0xf3, 0x76, 0x54, 0x3b, 0xd5, 0x74, 0x93, + 0x53, 0xf8, 0x08, 0x30, 0x8e, 0xb7, 0x4e, 0xd0, 0x31, 0xe7, 0x3c, 0x9f, 0x42, 0xeb, + 0xdc, 0x8a, 0x48, 0x4b, 0x30, 0x76, 0x9a, 0x17, 0x90, 0x6e, 0x39, 0xfe, 0x8f, 0xa6, + 0x5c, 0x0f, 0x88, 0xfc, 0xc3, 0x43, 0x6c, 0x0b, 0xfe, 0x26, 0xa4, 0x99, 0x5d, 0x82, + 0xa4, 0x1c, 0x6a, 0x99, 0x14, 0x0a, 0x36, 0xd1, 0x66, 0xcb, 0xa6, 0xad, 0x2d, 0xd0, + 0x65, 0xac, 0x19, 0xce, 0xba, 0xdf, 0xd4, 0x55, 0xc9, 0xfd, 0x5d, 0x15, 0xab, 0x2f, + 0xac, 0xaf, 0x9f, 0x5c, 0x79, 0xbc, 0xd1, 0x2d, 0x31, 0xef, 0x88, 0x84, 0x24, 0x03, + 0xeb, 0xfe, 0xf2, 0x26, 0xf9, 0xa1, 0xde, 0x78, 0xd1, 0x8d, 0x2a, 0x0a, 0x57, 0xa7, + 0x80, 0x8e, 0x5c, 0x4d, 0x9c, 0x7c, 0x51, 0x0b, 0xd1, 0x81, 0x3d, 0xb6, 0x0a, 0x2e, + 0x01, 0x21, 0xe7, 0x2c, 0x52, 0xed, 0xf7, 0x70, 0x84, 0x22, 0x2d, 0xbc, 0xd9, 0x4a, + 0x10, 0xcd, 0x4d, 0xc3, 0xb0, 0x90, 0x80, 0xe8, 0xe5, 0xa8, 0x97, 0x17, 0x61, 0xcd, + 0x46, 0xde, 0xd6, 0x5c, 0x78, 0xac, 0x4d, 0x89, 0x6d, 0x81, 0x8a, 0x40, 0x0e, 0xd8, + 0x32, 0x83, 0x05, 0x70, 0xd4, 0x92, 0x66, 0x5d, 0xec, 0x3f, 0x8c, 0x11, 0x16, 0x8e, + 0xee, 0x66, 0xf3, 0x3d, 0x0c, 0x13, 0xce, 0x30, 0x62, 0x25, 0x2f, 0x10, 0x7a, 0x37, + 0x77, 0xd1, 0xd9, 0x12, 0x34, 0xf5, 0x85, 0x98, 0x18, 0x4f, 0xf8, 0x27, 0xf6, 0xb2, + 0xe7, 0x36, 0x38, 0xfc, 0xe0, 0xe4, 0xe5, 0x1e, 0xf7, 0x04, 0xe1, 0xd3, 0xf8, 0xdd, + 0x53, 0x12, 0x19, 0x1e, 0x36, 0xdb, 0x31, 0xd8, 0x2b, 0x2b, 0x76, 0x86, 0x9d, 0x7e, + 0xb0, 0x34, 0x74, 0xff, 0x61, 0x60, 0x08, 0x15, 0x8f, 0x3b, 0xf9, 0x66, 0xa2, 0x36, + 0xcb, 0x3e, 0x8c, 0x52, 0xde, 0x4d, 0x01, 0x0c, 0xc7, 0x12, 0xab, 0xc2, 0x3d, 0xff, + 0x6f, 0x5c, 0xe0, 0x06, 0x31, 0xfd, 0x3d, 0xba, 0xce, 0xba, 0x03, 0x0c, 0x2e, 0xc1, + 0x8f, 0xd0, 0xc3, 0x9c, 0x9c, 0x60, 0x13, 0x4a, 0x4d, 0xfc, 0xa5, 0x21, 0xdc, 0xd7, + 0x1c, 0xda, 0x11, 0x79, 0xd8, 0xef, 0x08, 0xf0, 0x6a, 0x42, 0x68, 0x6c, 0x36, 0x0c, + 0x92, 0x72, 0xf1, 0x5b, 0x42, 0x58, 0xe7, 0x85, 0x14, 0xc8, 0x81, 0x4a, 0xd7, 0x0a, + 0x10, 0x92, 0xd2, 0x65, 0x57, 0xa4, 0x57, 0x64, 0x04, 0x1b, 0x83, 0x24, 0xbb, 0xcd, + 0x69, 0xb5, 0xd2, 0x86, 0x8a, 0x6f, 0xd9, 0x6c, 0x87, 0x1c, 0xf8, 0x34, 0x13, 0x11, + 0x3c, 0x89, 0x8e, 0x4b, 0xb9, 0x83, 0x18, 0x7f, 0xa4, 0xc1, 0xcb, 0xb7, 0x3c, 0xd4, + 0x1d, 0x3d, 0x4f, 0x4d, 0xb1, 0x85, 0x04, 0x7a, 0xfd, 0xd2, 0x41, 0xf1, 0xb7, 0xe7, + 0x00, 0x7c, 0x00, 0xb0, 0x3a, 0xa8, 0xab, 0x83, 0x6c, 0xed, 0xad, 0x61, 0x27, 0x93, + 0x8f, 0x87, 0x86, 0x11, 0x08, 0x04, 0x72, 0x98, 0xd3, 0xd9, 0x45, 0xb3, 0x43, 0xc6, + 0x2e, 0x2f, 0xe8, 0x52, 0xa0, 0x35, 0x4f, 0xf3, 0x1d, 0xad, 0xc1, 0xed, 0x08, 0xa4, + 0xdd, 0xab, 0x41, 0xd9, 0x1c, 0x02, 0x62, 0x28, 0x3b, 0x11, 0xfc, 0xbb, 0x1d, 0xdb, + 0x4e, 0x9f, 0xdd, 0xd7, 0xcc, 0x33, 0x8e, 0x92, 0x5c, 0xed, 0xfa, 0xdf, 0x4e, 0x30, + 0x6f, 0x84, 0x86, 0x3f, 0xd4, 0x5a, 0x70, 0xf5, 0x7d, 0xf0, 0x38, 0x4e, 0x12, 0x34, + 0x22, 0x01, 0x03, 0xb0, 0xf6, 0x93, 0x14, 0x4a, 0x5e, 0xcc, 0x9d, 0x99, 0xab, 0x1d, + 0x6f, 0x72, 0x57, 0x40, 0xd1, 0xbb, 0x09, 0xc3, 0xa4, 0xb4, 0xea, 0x61, 0x4a, 0xc0, + 0x1b, 0xfb, 0x12, 0x88, 0xbb, 0xf1, 0x4d, 0xcd, 0x57, 0x2e, 0xcb, 0xb6, 0xc8, 0x22, + 0xfe, 0x54, 0x1b, 0x04, 0xa0, 0xd6, 0x49, 0x8b, 0x5a, 0x14, 0x72, 0x7c, 0x2d, 0x54, + 0x3c, 0x96, 0x47, 0x27, 0x7b, 0xd6, 0x78, 0x22, 0xa5, 0xfa, 0xbd, 0xa4, 0xa9, 0x8f, + 0x23, 0xef, 0x50, 0xad, 0x12, 0xb3, 0x21, 0x37, 0x7f, 0xd4, 0xee, 0x24, 0xb2, 0x34, + 0xb0, 0xf2, 0x96, 0x04, 0x99, 0x06, 0xac, 0xed, 0x9d, 0x08, 0x67, 0x1d, 0xe9, 0x94, + 0x95, 0x6a, 0x21, 0x79, 0x39, 0x4d, 0x37, 0xb5, 0x85, 0xa3, 0x1e, 0x40, 0x53, 0x25, + 0xef, 0x88, 0x0a, 0x10, 0x8e, 0xc4, 0x92, 0xc1, 0xc8, 0x7d, 0xa9, 0x0a, 0xdb, 0xa7, + 0x2d, 0x8b, 0xe4, 0x64, 0x3c, 0xcf, 0x29, 0x43, 0x1c, 0xae, 0x05, 0x3f, 0x9c, 0xf5, + 0x27, 0x1f, 0x7e, 0x1c, 0x7a, 0x4d, 0xe0, 0x93, 0xce, 0xb0, 0x53, 0x35, 0x18, 0x73, + 0xd6, 0x57, 0x73, 0x7e, 0xbb, 0xef, 0x08, 0x66, 0x40, 0xd4, 0x17, 0xc6, 0xa0, 0x5a, + 0xe7, 0xfa, 0x9e, 0x30, 0xb1, 0x12, 0x92, 0x13, 0x59, 0x52, 0x90, 0x42, 0x70, 0x32, + 0xf2, 0x6e, 0xbc, 0xd1, 0x54, 0x6b, 0x9c, 0x9c, 0x1b, 0xcf, 0x01, 0xff, 0x3d, 0x18, + 0xfb, 0x1e, 0xbd, 0xbe, 0x0f, 0xee, 0x54, 0x0f, 0x4b, 0x53, 0x18, 0xba, 0x65, 0x87, + 0x7f, 0x45, 0x77, 0x36, 0xd3, 0x0c, 0x75, 0x0e, 0x42, 0xe0, 0xe7, 0x73, 0xaa, 0xa6, + 0xe5, 0x26, 0xbc, 0x61, 0x43, 0xef, 0x63, 0x1f, 0x6b, 0x3f, 0x88, 0x11, 0xa0, 0x26, + 0x37, 0x4d, 0xc2, 0x8e, 0x06, 0xc9, 0x2a, 0xcd, 0x09, 0xe1, 0xf3, 0xf9, 0x7c, 0x12, + 0xe5, 0x12, 0xb7, 0x78, 0x03, 0x85, 0x63, 0xb6, 0x7d, 0xe0, 0xd6, 0xb3, 0x4a, 0x48, + 0x15, 0x7f, 0x1b, 0x93, 0x6a, 0xbb, 0x8b, 0x9f, 0x3d, 0xa3, 0xad, 0xb8, 0x8b, 0x5f, + 0x36, 0xd0, 0xda, 0xe4, 0x86, 0x27, 0xcd, 0xc1, 0xa4, 0x03, 0x81, 0x0c, 0x81, 0x6e, + 0x32, 0xe0, 0xd1, 0x11, 0x25, 0x94, 0xa4, 0xf3, 0x72, 0xe9, 0xab, 0xe4, 0xe6, 0x72, + 0x1f, 0xf8, 0x3f, 0x48, 0x84, 0x21, 0x02, 0x21, 0x89, 0xb8, 0x2e, 0x1f, 0x7f, 0x27, + 0xa3, 0x3e, 0x4d, 0x11, 0x96, 0x95, 0x22, 0xe9, 0x1d, 0x19, 0xfb, 0xe1, 0xa3, 0xb9, + 0xeb, 0x6e, 0xb3, 0xdb, 0xdc, 0x2b, 0x19, 0x9d, 0xb9, 0xe8, 0x6e, 0x56, 0xbf, 0x69, + 0x5d, 0x0e, 0x6e, 0x79, 0x45, 0x72, 0x26, 0xb2, 0xb3, 0xce, 0xfd, 0xd2, 0xee, 0x37, + 0x75, 0xda, 0xe2, 0x68, 0x02, 0x03, 0x92, 0xf0, 0x33, 0x6c, 0x6f, 0xcb, 0x39, 0x28, + 0xbd, 0xfd, 0xea, 0xc7, 0x12, 0x46, 0x34, 0x3c, 0x08, 0xf2, 0xbe, 0x39, 0x7d, 0xaa, + 0x1f, 0xb9, 0xc2, 0x52, 0x65, 0x33, 0x07, 0xd0, 0xf7, 0xbc, 0x24, 0x11, 0x1b, 0xa8, + 0xdf, 0x6a, 0xb2, 0x99, 0x23, 0xb4, 0xe7, 0xf3, 0x47, 0x1b, 0xe2, 0x92, 0x3f, 0x46, + 0xdc, 0xca, 0xbb, 0x20, 0x63, 0x42, 0x7f, 0x3d, 0x4e, 0x53, 0xba, 0xf6, 0xa9, 0xec, + 0xb8, 0x8c, 0x12, 0xd9, 0xc2, 0x33, 0xff, 0x14, 0xf6, 0x3c, 0xcf, 0xd7, 0x6a, 0x8f, + 0x04, 0x6c, 0xc2, 0xd9, 0x67, 0x33, 0xe7, 0x2d, 0x56, 0xc8, 0x35, 0xdb, 0xc9, 0xa1, + 0xaa, 0x2a, 0x5b, 0xde, 0xe9, 0x15, 0xae, 0x7e, 0xb3, 0xe5, 0xdb, 0xbc, 0x8b, 0xa2, + 0x4d, 0xf6, 0xe6, 0x34, 0xbf, 0xfb, 0x43, 0x64, 0xa8, 0x10, 0x39, 0xb0, 0x6a, 0x2c, + 0x5c, 0xb3, 0x1c, 0x9c, 0xd8, 0x98, 0x5e, 0x7f, 0xe2, 0x98, 0x5c, 0x3e, 0x0a, 0x8f, + 0x1d, 0x52, 0xfe, 0xb2, 0xbf, 0xc3, 0x54, 0x9c, 0x38, 0x17, 0x98, 0x9c, 0xc1, 0x74, + 0x6f, 0xcf, 0xe8, 0x93, 0x88, 0x88, 0xe1, 0x22, 0x74, 0x48, 0x04, 0x91, 0xe5, 0x60, + 0x68, 0x00, 0x96, 0x1d, 0xc7, 0xae, 0xa8, 0x2d, 0x79, 0x3c, 0x00, 0x28, 0x1a, 0xdd, + 0x57, 0x9d, 0x5b, 0x67, 0x24, 0xed, 0xf7, 0xa5, 0xba, 0xae, 0x28, 0x5f, 0xbc, 0x7a, + 0xeb, 0xfd, 0x9c, 0x93, 0x04, 0xf9, 0x62, 0xb1, 0x45, 0x57, 0x3b, 0x14, 0x19, 0x1f, + 0xae, 0x24, 0xfe, 0x3a, 0x91, 0x29, 0x20, 0x59, 0x3f, 0xbb, 0x7c, 0xc1, 0x41, 0x86, + 0xb3, 0x37, 0x48, 0x49, 0xb7, + ], + ss: [ + 0x6f, 0x1c, 0x31, 0x7d, 0x16, 0x60, 0x8f, 0x30, 0x9e, 0x6b, 0x59, 0xa4, 0x8b, 0xe6, + 0x27, 0x22, 0x08, 0x1f, 0x4e, 0x2d, 0xe9, 0xe2, 0x74, 0x2a, 0x6d, 0x0e, 0x94, 0x67, + 0x9b, 0xa8, 0x56, 0xf7, + ], + }, + TestVector { + seed: [0x06; 32], + randomness: [0x6a; 128], + ek: &[ + 0xc3, 0xf9, 0xa6, 0x30, 0x52, 0x22, 0x86, 0x2c, 0x2c, 0x89, 0xec, 0x0d, 0xbd, 0x80, + 0x5c, 0x54, 0x7b, 0x21, 0x20, 0x40, 0x5b, 0xa8, 0xe9, 0x94, 0x94, 0x7b, 0x1d, 0x74, + 0xea, 0xcc, 0x58, 0x27, 0x72, 0x60, 0xba, 0x83, 0x7d, 0xe2, 0x9a, 0x0a, 0x2b, 0x84, + 0xa7, 0xfc, 0x80, 0x58, 0x93, 0x34, 0xfb, 0x26, 0x26, 0xc9, 0xf6, 0x1c, 0x01, 0xc8, + 0x8d, 0x60, 0xb2, 0x0b, 0x07, 0x28, 0x11, 0x0f, 0x08, 0x40, 0xfc, 0x01, 0xa6, 0x18, + 0x7a, 0x50, 0x6a, 0xb2, 0x3d, 0x2b, 0x45, 0x9f, 0xe0, 0x85, 0x3c, 0x44, 0xf8, 0x6a, + 0x69, 0x95, 0x33, 0x28, 0x45, 0x77, 0xf7, 0x91, 0x3b, 0x69, 0x89, 0x83, 0x61, 0xbb, + 0x67, 0xd3, 0x71, 0x16, 0x80, 0xc6, 0xc2, 0x5f, 0x25, 0x24, 0xc5, 0x60, 0x22, 0x22, + 0x74, 0x77, 0xf2, 0x8a, 0x19, 0x4e, 0x90, 0xb4, 0x70, 0x29, 0x01, 0xb0, 0x04, 0x6b, + 0xa7, 0x98, 0xcd, 0x1b, 0x84, 0x31, 0x92, 0xf3, 0xbc, 0x84, 0x1c, 0x8f, 0x97, 0x48, + 0xa1, 0xab, 0x34, 0xb5, 0x33, 0x6b, 0x12, 0xc5, 0x85, 0x85, 0xfc, 0xd0, 0x10, 0xbf, + 0xd6, 0xc4, 0x8e, 0x77, 0x5e, 0x76, 0x15, 0x25, 0xb2, 0x60, 0xc7, 0xf6, 0xe6, 0x46, + 0xe8, 0xf1, 0x76, 0x90, 0xaa, 0xb5, 0x1b, 0xab, 0x30, 0xc9, 0x76, 0x3f, 0xc5, 0x3b, + 0x85, 0x47, 0xd0, 0xb5, 0x6b, 0x0c, 0x82, 0xc4, 0x58, 0xc6, 0x1d, 0x84, 0x58, 0x7d, + 0x98, 0x97, 0x85, 0x60, 0x0b, 0x8e, 0x98, 0x7a, 0x36, 0x42, 0x3d, 0x38, 0x8c, 0xa1, + 0x1d, 0x61, 0x76, 0x5a, 0x01, 0xa4, 0xa7, 0x9c, 0xa2, 0x0a, 0x92, 0x59, 0x08, 0x49, + 0x4e, 0xae, 0x0a, 0x3b, 0x6d, 0xb1, 0xb0, 0x8c, 0xbb, 0xb7, 0xa4, 0xab, 0x5e, 0xdc, + 0xd9, 0x6b, 0xd7, 0x67, 0x25, 0xe9, 0x28, 0x05, 0x5b, 0x0c, 0x28, 0x83, 0xeb, 0xce, + 0x0a, 0x59, 0xbc, 0x9e, 0xc2, 0x82, 0xcf, 0x30, 0x0b, 0xa6, 0xc5, 0x38, 0x0d, 0x1b, + 0x70, 0xf1, 0x3b, 0x2d, 0xc6, 0xf6, 0x16, 0xc7, 0x60, 0x87, 0xa7, 0x3a, 0x70, 0xda, + 0xab, 0x7a, 0x6f, 0x97, 0x17, 0x1c, 0xa5, 0x99, 0x7b, 0xf4, 0x0e, 0x87, 0xb9, 0x5f, + 0x33, 0xa5, 0x33, 0x47, 0xba, 0x6c, 0x7b, 0xa8, 0x9b, 0xce, 0xc9, 0x04, 0x17, 0x01, + 0x22, 0x6f, 0xda, 0x12, 0x43, 0xf4, 0xb1, 0xfa, 0x04, 0x77, 0x40, 0xc7, 0xb7, 0x53, + 0xd6, 0x30, 0xfe, 0x38, 0x6f, 0x09, 0xe2, 0xa2, 0xf9, 0x65, 0x59, 0xae, 0x97, 0x9e, + 0xd9, 0xfa, 0x5a, 0x78, 0xd1, 0x31, 0x0e, 0xf3, 0x11, 0xf9, 0x7c, 0xc3, 0xb6, 0xa7, + 0x38, 0xbe, 0xe4, 0x5b, 0x75, 0xe3, 0xa0, 0xcc, 0x71, 0x4c, 0x81, 0xf7, 0x21, 0x87, + 0xb1, 0x05, 0xa2, 0x12, 0x0b, 0x9b, 0xea, 0xaa, 0xc1, 0x16, 0xbf, 0x98, 0x35, 0xc5, + 0x04, 0x71, 0x3f, 0x22, 0x18, 0xb5, 0x26, 0xf1, 0x3d, 0x8a, 0x8c, 0x02, 0xc9, 0x5a, + 0xa0, 0xf2, 0x92, 0x7c, 0x27, 0xe9, 0x96, 0xe4, 0x56, 0x45, 0x78, 0xe0, 0x56, 0x22, + 0x7b, 0x07, 0xbb, 0xda, 0x8a, 0xf0, 0xcc, 0x5d, 0x99, 0xf5, 0x5e, 0xab, 0x98, 0x68, + 0xb8, 0xeb, 0x4d, 0x1b, 0x14, 0x06, 0x58, 0x43, 0xb2, 0x29, 0xea, 0x3e, 0x2a, 0x0a, + 0x74, 0x8d, 0x89, 0xc4, 0xc3, 0x04, 0x19, 0x8c, 0xd4, 0x4c, 0xf7, 0x71, 0x80, 0xbb, + 0x86, 0x64, 0xf9, 0xaa, 0x1a, 0x95, 0x11, 0x52, 0x72, 0x33, 0xcd, 0xb6, 0x82, 0x69, + 0x76, 0xd3, 0x42, 0x76, 0xf6, 0x22, 0x57, 0xec, 0x38, 0x21, 0x72, 0xbf, 0x97, 0xb3, + 0x10, 0xbd, 0xd3, 0x40, 0x56, 0xea, 0x61, 0xf2, 0xd7, 0x4c, 0xe1, 0xcc, 0x95, 0x44, + 0xb0, 0x22, 0x63, 0xcc, 0x3d, 0x31, 0x33, 0xa3, 0x08, 0x91, 0x15, 0x56, 0x34, 0x5a, + 0x17, 0xc3, 0x2a, 0xcb, 0x47, 0x04, 0x44, 0xf5, 0x53, 0x6f, 0xd2, 0x1f, 0x81, 0xcc, + 0x3c, 0x96, 0x8a, 0xb7, 0xe4, 0xdb, 0x9c, 0xea, 0x56, 0x4c, 0x55, 0xd3, 0xa6, 0x01, + 0x06, 0x63, 0x75, 0xf6, 0x41, 0x76, 0x91, 0xc0, 0xee, 0x3b, 0x39, 0x22, 0x88, 0x60, + 0xf1, 0xbc, 0x00, 0x69, 0x32, 0x93, 0xc4, 0xbc, 0xa3, 0x27, 0x17, 0x6d, 0xa5, 0x2b, + 0x72, 0x82, 0x49, 0x5b, 0xaf, 0xc2, 0x93, 0x2d, 0x11, 0x54, 0xc0, 0x36, 0x72, 0xf4, + 0xdb, 0x49, 0xbd, 0x40, 0x96, 0x7c, 0xa4, 0x1f, 0xb8, 0xf8, 0x69, 0x63, 0x82, 0xa5, + 0x20, 0x8c, 0x55, 0x47, 0x64, 0x0e, 0x51, 0x93, 0x45, 0x9b, 0x35, 0x07, 0xf4, 0x81, + 0x7a, 0xe3, 0x70, 0x79, 0x30, 0x50, 0x89, 0x69, 0xa1, 0x8b, 0x1d, 0x16, 0x8e, 0x67, + 0xb5, 0x93, 0x95, 0x32, 0x16, 0x0b, 0x50, 0xa5, 0x38, 0xec, 0x90, 0x74, 0xe7, 0x33, + 0xdf, 0xaa, 0x4a, 0xf0, 0x97, 0x55, 0xf8, 0x31, 0x72, 0x0c, 0xec, 0x85, 0x19, 0xf3, + 0xbd, 0x74, 0x80, 0x95, 0x39, 0x34, 0x7b, 0x87, 0x86, 0x86, 0x8f, 0xb2, 0xab, 0x9a, + 0xb7, 0x42, 0xfe, 0x02, 0x0c, 0x87, 0x93, 0x0d, 0x37, 0xc4, 0x5a, 0xa9, 0xb8, 0x36, + 0xc9, 0x86, 0xba, 0x01, 0x80, 0x4a, 0x5d, 0xe2, 0x69, 0x74, 0xac, 0x64, 0x7d, 0x8b, + 0x92, 0x14, 0x84, 0xb7, 0x48, 0xd9, 0x99, 0x94, 0x47, 0x87, 0x5f, 0xe2, 0x74, 0x6a, + 0xd1, 0x11, 0x2f, 0xc5, 0x7e, 0xa3, 0x99, 0x9f, 0x58, 0x99, 0x37, 0x4c, 0xe2, 0x53, + 0x6c, 0x58, 0x31, 0x00, 0x33, 0xcc, 0xda, 0xbc, 0x75, 0xd6, 0x3a, 0x64, 0x1a, 0x56, + 0x51, 0xbd, 0x08, 0x07, 0x9a, 0x41, 0xc1, 0xe5, 0x98, 0x94, 0xcb, 0x3a, 0x1c, 0x8b, + 0xac, 0x76, 0x14, 0xe9, 0x60, 0x58, 0x1a, 0x1d, 0x19, 0x1a, 0x3a, 0x38, 0x62, 0x09, + 0xb6, 0xe8, 0x2e, 0xfc, 0x92, 0xb6, 0x55, 0xc5, 0x1d, 0x91, 0xe1, 0x1e, 0x8d, 0x39, + 0x19, 0x08, 0x63, 0x90, 0x9a, 0x97, 0xcc, 0x60, 0x17, 0xaf, 0x2c, 0x35, 0x50, 0x0b, + 0x86, 0x0a, 0x21, 0xc9, 0xc4, 0x8d, 0x48, 0x83, 0x4e, 0xb5, 0x61, 0xf5, 0x8c, 0x68, + 0x33, 0x72, 0x96, 0x8f, 0xd8, 0x9b, 0xe5, 0x2a, 0x26, 0x99, 0x53, 0x17, 0x85, 0x5b, + 0x31, 0x23, 0xac, 0xc2, 0x07, 0x16, 0x83, 0xca, 0x66, 0x9d, 0x78, 0xc3, 0xcc, 0xe5, + 0xbb, 0x9c, 0x9f, 0x94, 0x29, 0xa6, 0x43, 0xbb, 0xb1, 0x40, 0x1d, 0x1d, 0x66, 0x5d, + 0xbf, 0x45, 0xac, 0xe6, 0x52, 0x4c, 0xba, 0x3b, 0x0d, 0x33, 0x58, 0x21, 0x05, 0xdc, + 0x7c, 0x38, 0x16, 0x5f, 0xf0, 0x95, 0x9d, 0x32, 0x59, 0x14, 0xf4, 0x37, 0xa4, 0x00, + 0x8c, 0xa7, 0x51, 0x87, 0x8b, 0xb8, 0x28, 0x7e, 0xea, 0xf0, 0x92, 0x02, 0x1b, 0x1b, + 0x36, 0x47, 0xbb, 0x4a, 0x9b, 0x56, 0x2a, 0x7a, 0xae, 0x80, 0x62, 0x57, 0x39, 0xf6, + 0x6b, 0x63, 0x6c, 0x30, 0x9a, 0x09, 0x37, 0x6a, 0xc4, 0xce, 0xc6, 0xd7, 0x6c, 0xe4, + 0x62, 0x9a, 0xef, 0x46, 0xae, 0x48, 0x8b, 0x4c, 0x69, 0x61, 0x06, 0x95, 0x27, 0x59, + 0x4e, 0x0c, 0x22, 0xec, 0x55, 0x22, 0x6f, 0x47, 0x08, 0x5b, 0xec, 0x5e, 0x03, 0x43, + 0xcb, 0xfb, 0x42, 0x1f, 0xfc, 0x83, 0x8b, 0x56, 0xe9, 0x55, 0x3e, 0x41, 0x1c, 0xe3, + 0x9c, 0x81, 0x1a, 0x1b, 0x4a, 0x53, 0xb0, 0x51, 0xb4, 0x04, 0xaf, 0x3b, 0x58, 0xbf, + 0x65, 0x13, 0x76, 0x36, 0x0c, 0x04, 0x0a, 0x60, 0x7f, 0x94, 0x6c, 0x63, 0x57, 0x02, + 0x0b, 0xa1, 0xfa, 0x99, 0xda, 0xf1, 0x9a, 0xd3, 0xf0, 0x20, 0x43, 0x1a, 0x98, 0xb1, + 0x64, 0x70, 0x40, 0x03, 0x83, 0x83, 0x71, 0x9f, 0xf9, 0xfc, 0x7d, 0x4c, 0xc7, 0x5d, + 0x6b, 0xcb, 0x6d, 0x4f, 0x00, 0xc8, 0x34, 0x87, 0x4b, 0x01, 0xb9, 0xa8, 0x5e, 0x0c, + 0x0f, 0x5c, 0x63, 0x27, 0x34, 0xa3, 0x26, 0x4d, 0x15, 0x6c, 0x97, 0x3c, 0x14, 0xca, + 0xe9, 0x20, 0xbf, 0x09, 0x17, 0xcc, 0xcc, 0x92, 0x4b, 0xa9, 0x0f, 0xef, 0x18, 0x7f, + 0x97, 0x83, 0x11, 0x9a, 0x7a, 0x26, 0x86, 0x21, 0xc7, 0xf2, 0x9b, 0xbb, 0x28, 0xda, + 0x1c, 0xce, 0xab, 0x36, 0x96, 0x09, 0xc6, 0x4e, 0xfc, 0x5e, 0x91, 0xa7, 0x94, 0x51, + 0xbc, 0x81, 0x00, 0xea, 0xbc, 0x85, 0x54, 0x1d, 0x1f, 0x24, 0x35, 0xb9, 0x6b, 0x53, + 0x2f, 0xa1, 0x4c, 0x1c, 0xb7, 0x6b, 0x99, 0x90, 0x8c, 0x41, 0x81, 0x18, 0xe2, 0x47, + 0x2c, 0x66, 0x51, 0x1a, 0xb5, 0x58, 0xaa, 0x06, 0xf0, 0x3f, 0xd8, 0xfc, 0x15, 0xf1, + 0x0a, 0x20, 0x99, 0xdc, 0x4d, 0xf1, 0x36, 0x0d, 0x15, 0x91, 0x0d, 0x2a, 0x77, 0x47, + 0xd8, 0xab, 0xab, 0x40, 0xfa, 0x3d, 0x77, 0xb7, 0x47, 0x0d, 0x84, 0x77, 0xcd, 0x63, + 0x02, 0x4a, 0xa4, 0x02, 0x68, 0xf5, 0x51, 0x39, 0xd3, 0x75, 0x48, 0x22, 0x3e, 0xd5, + 0x82, 0x3f, 0x13, 0x68, 0x05, 0x75, 0x2c, 0x0b, 0x5f, 0x7f, 0x23, 0xed, 0xfd, 0x90, + 0xa8, 0x9d, 0xd1, 0xf9, 0x0e, 0xe3, 0x44, 0xdf, 0x04, 0x63, 0x6c, 0xb9, 0x7b, 0xe2, + 0x40, 0x6e, 0x55, 0x15, 0x64, 0x1b, 0x4c, 0x5a, 0xd1, 0x86, 0xa0, 0x78, 0x9e, 0x8b, + 0xa4, 0x8a, 0xb8, 0x30, 0xd4, 0xf5, 0x70, 0xcf, 0xd1, 0x58, 0xfd, 0xd6, 0x3d, 0x38, + 0xde, 0x1e, 0x92, 0x52, 0xba, 0xec, 0xa9, 0xa7, 0x6c, 0x4a, 0xfc, 0x77, 0x68, 0x26, + 0x64, 0x28, 0xca, 0xae, 0x91, 0x3d, 0x20, 0x3f, 0x47, 0x09, 0xef, 0x6d, 0xd7, 0xe6, + 0x75, 0x44, 0xa9, + ], + dk: [0x06; 32], + dk_pq: [ + 0xf7, 0xd6, 0xc6, 0xa4, 0x6a, 0x9c, 0x53, 0x4d, 0x6e, 0xe0, 0x53, 0x29, 0x38, 0xa9, + 0x9f, 0x0c, 0x45, 0x0d, 0xa4, 0x93, 0x5e, 0x29, 0x53, 0xc4, 0xda, 0xea, 0x5d, 0x5b, + 0x0a, 0x59, 0xea, 0x69, 0xc7, 0x00, 0xa4, 0x08, 0x17, 0xfd, 0xf4, 0x45, 0xdd, 0x5b, + 0x73, 0xed, 0x69, 0xa5, 0x57, 0xaf, 0xa2, 0x78, 0x39, 0x19, 0x1b, 0x8e, 0x71, 0x21, + 0x4e, 0xf9, 0xef, 0x97, 0xe9, 0xd9, 0xbb, 0x99, + ], + dk_t: [ + 0x0a, 0x92, 0x5a, 0x53, 0xf7, 0xce, 0xaa, 0xa3, 0x73, 0xf3, 0xf8, 0xec, 0xf9, 0xc2, + 0xd9, 0xea, 0xeb, 0x35, 0x1e, 0xaa, 0xe4, 0xdd, 0xde, 0xcb, 0xd7, 0xeb, 0x18, 0x0b, + 0x54, 0x32, 0x30, 0x6e, + ], + ct: &[ + 0x56, 0xa0, 0x6e, 0x64, 0x43, 0xb5, 0x3c, 0x24, 0xf6, 0x47, 0xcb, 0x67, 0x98, 0x25, + 0x78, 0x99, 0xea, 0x1c, 0x49, 0xcb, 0xfd, 0x4c, 0x4e, 0x3e, 0x54, 0xdd, 0x73, 0xa1, + 0x13, 0x9d, 0xc4, 0xdf, 0x51, 0x90, 0x67, 0xa5, 0x93, 0x47, 0x33, 0xa3, 0x45, 0x38, + 0xf9, 0x41, 0xcd, 0x9a, 0x2d, 0x9d, 0xe3, 0x71, 0x62, 0x32, 0x47, 0xf1, 0xbb, 0xcb, + 0x72, 0x8d, 0x8c, 0xfd, 0x59, 0xb5, 0x9d, 0x69, 0x95, 0xa2, 0x43, 0x0a, 0xb1, 0x44, + 0x90, 0xb3, 0x36, 0xac, 0x50, 0x2c, 0xd2, 0x1d, 0xea, 0x47, 0xdc, 0x7c, 0x89, 0xfa, + 0x02, 0x63, 0x10, 0xec, 0x05, 0xfb, 0xbe, 0x50, 0x17, 0x9b, 0x45, 0xe4, 0xb6, 0x8c, + 0x50, 0x7f, 0xd9, 0x0f, 0xab, 0x06, 0xe3, 0x6f, 0xb1, 0xc9, 0xb2, 0x1c, 0x06, 0x11, + 0x5f, 0xe4, 0x2b, 0xeb, 0xa1, 0x50, 0x83, 0x38, 0x57, 0x64, 0xcd, 0xe8, 0xc5, 0x27, + 0xc3, 0x66, 0x95, 0x07, 0xbc, 0xad, 0xed, 0x45, 0xf7, 0x0a, 0x8c, 0xca, 0x78, 0x9a, + 0xd7, 0x1e, 0x90, 0x87, 0x94, 0x8e, 0x4f, 0x1d, 0x68, 0x2c, 0x4a, 0x77, 0xad, 0x30, + 0x6c, 0x25, 0xb1, 0xe6, 0x36, 0x4f, 0x43, 0xfb, 0x51, 0xc0, 0xc5, 0xd7, 0x2f, 0x45, + 0x5d, 0xa7, 0x2f, 0x46, 0x04, 0x1f, 0x8f, 0xcb, 0x14, 0x3f, 0x67, 0xc7, 0x51, 0x7b, + 0x42, 0x5e, 0x24, 0xcd, 0x80, 0x30, 0x32, 0x64, 0x5c, 0xfe, 0xba, 0x77, 0xe0, 0xd8, + 0xd2, 0xd0, 0xcf, 0xb5, 0x77, 0x68, 0xb8, 0xfa, 0x32, 0x38, 0xc1, 0x0e, 0xbb, 0x99, + 0x47, 0x17, 0x10, 0x97, 0x3b, 0xf9, 0xd2, 0x2f, 0xea, 0x51, 0x47, 0x13, 0x54, 0xe5, + 0x3f, 0x15, 0x3d, 0xfb, 0xac, 0x69, 0x5a, 0x6f, 0x8c, 0xcb, 0x10, 0x52, 0x4a, 0x04, + 0x53, 0xe8, 0x04, 0xbb, 0x01, 0x3b, 0x45, 0x0f, 0x38, 0x00, 0x7f, 0xe2, 0x1c, 0xe8, + 0x98, 0xc0, 0x52, 0xa1, 0x32, 0xea, 0x74, 0xc9, 0xe6, 0x95, 0x12, 0xca, 0x4c, 0x18, + 0xc3, 0x2a, 0xe3, 0x78, 0x84, 0xdf, 0x52, 0x0d, 0x12, 0x72, 0x1b, 0x95, 0xac, 0xb5, + 0x15, 0x06, 0x7f, 0x35, 0x16, 0xce, 0xd7, 0x3c, 0x93, 0x07, 0x86, 0xd6, 0x92, 0x4c, + 0xc7, 0xdc, 0xc0, 0x8b, 0x50, 0xa3, 0xab, 0xef, 0x4e, 0x0d, 0xf8, 0x2a, 0xa0, 0xb9, + 0xc7, 0xbc, 0x19, 0x9c, 0xb2, 0xdc, 0xbc, 0x7c, 0xba, 0xa3, 0x8f, 0xfb, 0xee, 0xa6, + 0x0e, 0x41, 0xae, 0x20, 0xe8, 0x40, 0x07, 0x30, 0x13, 0x2f, 0x36, 0x27, 0xe1, 0xf6, + 0x2f, 0xc7, 0x84, 0xf2, 0x22, 0x21, 0x3c, 0x2c, 0x47, 0x9c, 0x4e, 0xd1, 0xf2, 0x15, + 0x9f, 0x72, 0x4e, 0xdd, 0xff, 0x87, 0xe6, 0xa4, 0xb5, 0xb3, 0x44, 0x5e, 0x18, 0x95, + 0x90, 0xde, 0x4b, 0xb6, 0x2b, 0xf6, 0x6e, 0x93, 0x05, 0x50, 0x14, 0x4b, 0x44, 0xe2, + 0x3d, 0x6c, 0x04, 0x5d, 0x77, 0x9a, 0xce, 0x9f, 0x94, 0xc0, 0xa6, 0x88, 0xf7, 0x29, + 0xa0, 0xb9, 0x48, 0x21, 0xb6, 0x69, 0xb5, 0xec, 0x49, 0x65, 0x2e, 0x55, 0xa8, 0xc1, + 0x9c, 0xfc, 0xb4, 0xd3, 0x89, 0x06, 0x6b, 0xb3, 0xaa, 0x4d, 0x9d, 0x71, 0x95, 0xd3, + 0x0c, 0x49, 0x6e, 0xc4, 0x25, 0x01, 0x38, 0xea, 0x1c, 0x33, 0x5d, 0x61, 0x81, 0xb2, + 0x57, 0x93, 0xff, 0x5d, 0x0f, 0xea, 0xf9, 0x1b, 0x7d, 0x27, 0xc8, 0x26, 0xec, 0xda, + 0x49, 0xa9, 0xb9, 0xc8, 0xff, 0x88, 0x00, 0x91, 0x96, 0x3a, 0x2c, 0xcb, 0xdb, 0x5c, + 0xb4, 0x5e, 0xaa, 0xfb, 0xfc, 0x8b, 0x93, 0xe7, 0x53, 0xbf, 0x32, 0x3e, 0x2f, 0x76, + 0xb0, 0xa6, 0x1a, 0xf9, 0x69, 0x97, 0xd9, 0x7f, 0x42, 0x9d, 0xb9, 0x08, 0x98, 0xfb, + 0xcc, 0x2d, 0xdd, 0xce, 0xbf, 0x04, 0xd0, 0xe2, 0xa3, 0xd6, 0x88, 0xfa, 0x56, 0x65, + 0x5b, 0x41, 0xb0, 0xa6, 0x28, 0xe4, 0x16, 0x4a, 0x31, 0x30, 0x87, 0x99, 0xea, 0x58, + 0x98, 0x4d, 0x44, 0x73, 0x9d, 0x97, 0x20, 0xdc, 0xfd, 0xf4, 0xbc, 0xf2, 0x80, 0x82, + 0x17, 0x40, 0x8c, 0x43, 0x3d, 0x26, 0x37, 0x87, 0x40, 0x5d, 0x11, 0xdc, 0xe0, 0x85, + 0x4f, 0xba, 0xfe, 0x59, 0xf5, 0x8d, 0x39, 0xa2, 0x99, 0x5b, 0x99, 0x11, 0x87, 0xff, + 0x86, 0xd3, 0x90, 0x6e, 0x1e, 0x27, 0x81, 0x2d, 0x5a, 0xcd, 0x2a, 0x8d, 0x11, 0xb9, + 0x5e, 0xa2, 0x0c, 0x7b, 0xf1, 0xe8, 0xca, 0x91, 0x46, 0xcd, 0x9b, 0xdd, 0x10, 0xf8, + 0x99, 0xe3, 0x28, 0x9b, 0xb1, 0x83, 0x81, 0x91, 0xfe, 0xab, 0x93, 0x7a, 0x67, 0x49, + 0xc9, 0x65, 0xc0, 0x1b, 0x41, 0xe6, 0xfe, 0xbb, 0x62, 0xb5, 0x15, 0xef, 0xc4, 0x16, + 0xb9, 0x47, 0x02, 0x14, 0xd7, 0x8d, 0x4a, 0x47, 0xbd, 0xe4, 0x6b, 0x0c, 0x8a, 0x5f, + 0x8c, 0x46, 0x72, 0xe8, 0xd9, 0x5d, 0xff, 0x71, 0xb9, 0xd7, 0xbc, 0xd2, 0xf9, 0x4c, + 0x1d, 0x11, 0x54, 0x61, 0xc5, 0xa8, 0x47, 0xba, 0xa8, 0xee, 0x4a, 0x8a, 0x67, 0xde, + 0xde, 0xf4, 0xea, 0x40, 0x40, 0x33, 0x26, 0x71, 0x0c, 0x23, 0x39, 0x4b, 0x7b, 0x38, + 0xe1, 0x93, 0xb0, 0x16, 0x70, 0x66, 0x9f, 0x2c, 0x6e, 0x06, 0xc7, 0x96, 0x3d, 0xa8, + 0xde, 0xbe, 0x10, 0x3a, 0x33, 0xb4, 0x95, 0x41, 0xfd, 0x5e, 0x0b, 0xc7, 0x7b, 0x91, + 0x6d, 0xae, 0x22, 0x44, 0xd3, 0x6b, 0xfc, 0x3d, 0x53, 0xf0, 0xf1, 0xba, 0x51, 0xee, + 0xc5, 0xa1, 0x8c, 0x2f, 0x25, 0x8e, 0xde, 0xfa, 0x29, 0x46, 0xf7, 0x99, 0xb8, 0x8e, + 0x17, 0xea, 0x47, 0x5e, 0x8b, 0xda, 0x8c, 0xff, 0xa3, 0x53, 0x1e, 0xd2, 0x46, 0x82, + 0x08, 0x82, 0xe3, 0x2f, 0x7a, 0xe0, 0x42, 0x5b, 0x12, 0x9a, 0x8b, 0x0d, 0x20, 0xe6, + 0x20, 0x5d, 0x1a, 0x7f, 0x85, 0xbd, 0x8e, 0xfd, 0x9f, 0xbc, 0x7d, 0xab, 0x57, 0xeb, + 0x45, 0xd1, 0x87, 0xa2, 0x5d, 0x29, 0xb7, 0x1d, 0x69, 0x25, 0x4a, 0x36, 0xa5, 0x12, + 0x5b, 0x6a, 0xf9, 0xdb, 0x41, 0xca, 0xf3, 0x69, 0x18, 0x39, 0x87, 0xe0, 0xf7, 0x07, + 0x72, 0x53, 0x96, 0x9d, 0x9d, 0x1c, 0x08, 0x87, 0xa3, 0x5f, 0xd2, 0xea, 0x34, 0xee, + 0xa8, 0x1f, 0xc9, 0x30, 0xb1, 0xa1, 0xaa, 0x11, 0xdb, 0x1e, 0x99, 0x6a, 0x11, 0xc4, + 0x9c, 0x39, 0xf5, 0x70, 0xd0, 0xe3, 0xcf, 0xb3, 0xef, 0x58, 0x11, 0xa6, 0x78, 0xdc, + 0x44, 0x51, 0xc5, 0xcf, 0x64, 0x89, 0x8a, 0xe3, 0xb5, 0x3e, 0x41, 0x7c, 0x69, 0xf0, + 0x94, 0x38, 0xc9, 0x97, 0xfb, 0xb4, 0x53, 0xb9, 0xd8, 0x8a, 0x1c, 0xb6, 0x03, 0xe2, + 0x01, 0x6c, 0x1e, 0xe7, 0x9a, 0x36, 0xf2, 0xe9, 0xdf, 0x75, 0xf6, 0x5e, 0xaf, 0xa3, + 0xdb, 0x33, 0xf0, 0xf3, 0x77, 0xc7, 0x1e, 0x72, 0xf7, 0x7a, 0xf8, 0x5a, 0x01, 0x14, + 0x30, 0x6e, 0x1b, 0x21, 0x92, 0x1d, 0x53, 0x2b, 0x6d, 0x14, 0x0e, 0x3a, 0x2c, 0x5a, + 0x47, 0x9f, 0x33, 0xc1, 0x58, 0x23, 0x86, 0xc7, 0x0c, 0x75, 0xe8, 0x47, 0x65, 0x73, + 0x5b, 0x61, 0x05, 0x59, 0xe8, 0xaa, 0xc6, 0x14, 0x9a, 0xd1, 0x74, 0x21, 0x3f, 0x2a, + 0x15, 0x95, 0x47, 0x6b, 0x29, 0x07, 0x5b, 0x71, 0xa0, 0x25, 0xf0, 0x5f, 0xec, 0x67, + 0xfe, 0xd0, 0x5e, 0x5f, 0x19, 0x3f, 0x2b, 0x71, 0xe0, 0x35, 0x27, 0x55, 0xff, 0x4a, + 0xa6, 0x1b, 0xc6, 0x3f, 0x02, 0x40, 0x57, 0x60, 0x33, 0x35, 0x16, 0x76, 0x69, 0x06, + 0x15, 0x8a, 0x2c, 0xf8, 0x12, 0xfd, 0xd5, 0xd1, 0x1e, 0xed, 0x2c, 0xa3, 0xe4, 0x40, + 0x45, 0x8a, 0xe1, 0xbf, 0x76, 0xcb, 0x64, 0x2d, 0xb5, 0x77, 0x2d, 0x67, 0x2d, 0x93, + 0x2a, 0x33, 0x6c, 0xd8, 0x38, 0x33, 0x9d, 0x9d, 0xf2, 0xdc, 0x24, 0x59, 0xa1, 0x5c, + 0x17, 0x3b, 0x9e, 0x80, 0x3a, 0x53, 0x11, 0x2a, 0x08, 0x1e, 0x7c, 0x2c, 0x94, 0x57, + 0x86, 0xb2, 0x4e, 0x6d, 0x22, 0x6a, 0xef, 0xbe, 0x7c, 0xb1, 0x84, 0xa2, 0x3d, 0xd5, + 0x04, 0x81, 0x39, 0x75, 0xe2, 0x50, 0x67, 0xf3, 0x3b, 0xc9, 0x0e, 0x13, 0xec, 0xd4, + 0x85, 0x74, 0x73, 0xe0, 0xbb, 0x0f, 0xa3, 0x3b, 0x3f, 0x5f, 0x02, 0x55, 0xeb, 0x51, + 0xda, 0x21, 0x47, 0x17, 0x51, 0x13, 0x78, 0x92, 0x7c, 0x0d, 0x04, 0xd1, 0xbd, 0x41, + 0x43, 0xe8, 0x15, 0xd8, 0x32, 0xd6, 0x9a, 0xf2, 0xab, 0x20, 0x8a, 0x19, 0x24, 0x3a, + 0x03, 0x71, 0xc1, 0xc7, 0x0a, 0xd3, 0x82, 0x18, 0x63, 0xaa, 0x85, 0x1b, 0x54, 0x47, + 0xc5, 0x3c, 0x39, 0x14, 0x17, 0xdc, 0xf8, 0xe0, 0x50, 0x6a, 0xab, 0x61, 0x77, 0x92, + 0xf2, 0x4c, 0x80, 0xe4, 0x12, 0x2f, 0x99, 0xeb, 0xb2, 0x53, 0x41, 0x89, 0x8e, 0x30, + 0xd8, 0xdb, 0xda, 0x4d, 0xef, + ], + ss: [ + 0xe3, 0x24, 0xb3, 0xae, 0x97, 0x80, 0xcc, 0x6d, 0x0a, 0x54, 0xaa, 0x42, 0x62, 0xdb, + 0x9c, 0x9c, 0x59, 0x48, 0xeb, 0xd4, 0x5d, 0xf2, 0xf3, 0xd1, 0x0e, 0xb2, 0x2e, 0xe2, + 0x3b, 0xda, 0xdd, 0xea, + ], + }, + TestVector { + seed: [0x07; 32], + randomness: [0x6b; 128], + ek: &[ + 0x0e, 0x12, 0x76, 0x0b, 0x95, 0x26, 0x6a, 0x50, 0xa5, 0x2b, 0xc6, 0xba, 0x3d, 0xf6, + 0x97, 0xc1, 0x26, 0x1d, 0x3b, 0xa5, 0x10, 0x98, 0x7a, 0x29, 0x9a, 0x83, 0xcc, 0x0b, + 0x91, 0x34, 0xc2, 0xea, 0x4d, 0xdc, 0x47, 0x88, 0x9b, 0x72, 0xc6, 0xde, 0xa6, 0x5b, + 0x49, 0xe0, 0x66, 0xb1, 0xa2, 0x82, 0x2f, 0x26, 0x9e, 0x8e, 0xa9, 0x04, 0xa6, 0x67, + 0xcf, 0xe6, 0xf7, 0x03, 0x5a, 0xa8, 0x3c, 0xd9, 0xc0, 0x41, 0xef, 0xc3, 0x8d, 0x23, + 0x05, 0x3e, 0xa6, 0xd7, 0x54, 0xc5, 0x50, 0xcd, 0x5d, 0x19, 0x36, 0xd4, 0xe7, 0x4e, + 0xa0, 0x47, 0xc4, 0xdc, 0xf7, 0x57, 0xde, 0x95, 0x50, 0x97, 0x2c, 0x82, 0xab, 0xcb, + 0xad, 0x83, 0xc3, 0x28, 0x38, 0xc1, 0x84, 0x51, 0x24, 0x0c, 0x09, 0x07, 0xa5, 0x73, + 0x45, 0x1d, 0xc7, 0x46, 0xbc, 0x49, 0x1c, 0x14, 0x3d, 0x14, 0x83, 0x7a, 0xf8, 0x3c, + 0x4f, 0x4b, 0x1f, 0x5a, 0xaa, 0x59, 0xbd, 0x5a, 0x2b, 0x03, 0xc1, 0x44, 0xba, 0x6c, + 0xcb, 0x44, 0x5b, 0xce, 0x2d, 0x38, 0x4a, 0xb4, 0x08, 0x23, 0x27, 0x13, 0x42, 0x12, + 0x8a, 0x2b, 0x7e, 0xb6, 0x86, 0x24, 0xeb, 0xa5, 0x9b, 0x3b, 0x2b, 0x57, 0xd9, 0xa4, + 0xac, 0x7b, 0x63, 0x0d, 0x06, 0x34, 0x00, 0xa2, 0x75, 0xad, 0x71, 0xb6, 0xb0, 0x8a, + 0x8c, 0xfe, 0x93, 0xa6, 0x4d, 0x36, 0x8c, 0xef, 0x66, 0x6a, 0x4d, 0x20, 0x8b, 0x8f, + 0x39, 0xc4, 0x42, 0x40, 0x0c, 0x1a, 0x7c, 0x46, 0x77, 0x65, 0x85, 0x76, 0x41, 0x7b, + 0x5b, 0x02, 0x6d, 0x99, 0xcb, 0x80, 0xe0, 0x14, 0x28, 0xbe, 0x00, 0xc7, 0x20, 0xe2, + 0x20, 0xa2, 0x70, 0x59, 0x36, 0xa6, 0x2d, 0x6e, 0x73, 0x79, 0x00, 0xbd, 0x8c, 0x3d, + 0x0b, 0x46, 0x4e, 0xd7, 0x65, 0x0d, 0xd7, 0xc8, 0x4c, 0x25, 0x0d, 0xd7, 0x3c, 0x75, + 0x36, 0xab, 0xbb, 0x40, 0x13, 0x80, 0x99, 0x27, 0xcc, 0xff, 0xa5, 0x39, 0x1b, 0xb2, + 0x54, 0x29, 0x4c, 0x7b, 0xe0, 0x59, 0x6d, 0xd2, 0x9a, 0xa3, 0x74, 0x45, 0x95, 0x7b, + 0x2a, 0xa8, 0x8d, 0xfc, 0x54, 0x44, 0x78, 0x94, 0x77, 0x3a, 0x34, 0xe8, 0xe8, 0x7b, + 0x05, 0x52, 0x0c, 0x9c, 0x2a, 0xb4, 0xdf, 0xd6, 0x9c, 0xdd, 0x9a, 0x52, 0xc7, 0xe9, + 0x35, 0x2a, 0x3a, 0xb9, 0x4c, 0x07, 0xa2, 0x6d, 0x46, 0x8f, 0x10, 0xb2, 0x63, 0x2a, + 0x6a, 0x52, 0x4e, 0x06, 0x23, 0x4f, 0xbb, 0x20, 0x08, 0xf1, 0x7c, 0xee, 0x6a, 0x59, + 0xef, 0xc5, 0x1b, 0x4c, 0x48, 0x3f, 0xa5, 0x26, 0x4c, 0x9f, 0xb3, 0x25, 0xe9, 0xd7, + 0xb9, 0xb6, 0x6c, 0x6a, 0xae, 0x91, 0xba, 0x9f, 0x9a, 0x29, 0x74, 0x39, 0x68, 0xc5, + 0x53, 0x3a, 0x37, 0x50, 0xbb, 0x95, 0x54, 0x22, 0x3b, 0x60, 0xc8, 0xb9, 0x64, 0xcf, + 0xa7, 0x34, 0x69, 0x48, 0xca, 0xc1, 0x00, 0x0d, 0x84, 0x04, 0x88, 0xc3, 0xd2, 0x11, + 0xb4, 0xe7, 0xd4, 0x63, 0xdd, 0xb1, 0x55, 0x51, 0x86, 0x2f, 0x01, 0xd7, 0x7e, 0x87, + 0xb6, 0x08, 0x99, 0xe2, 0x51, 0x64, 0xcc, 0xcc, 0x81, 0x4c, 0xaa, 0x5c, 0x05, 0x55, + 0xf5, 0x41, 0x3f, 0xfb, 0xdc, 0xb5, 0x10, 0x14, 0x58, 0xa2, 0x60, 0x61, 0x56, 0x04, + 0x63, 0xab, 0x33, 0xcc, 0x21, 0x74, 0xc6, 0x1f, 0x58, 0x61, 0x98, 0x6b, 0x55, 0xd6, + 0x20, 0x66, 0x12, 0xf3, 0x86, 0xc9, 0x96, 0x56, 0x1b, 0x51, 0xb6, 0x3a, 0x11, 0xbe, + 0x96, 0x5a, 0x1f, 0xae, 0x45, 0xb2, 0x51, 0x47, 0x6e, 0x96, 0xc3, 0x86, 0x49, 0x25, + 0x64, 0x6b, 0x62, 0x46, 0x93, 0x5b, 0xbf, 0xa9, 0xf4, 0xbb, 0x39, 0x43, 0x71, 0x95, + 0xc6, 0xb9, 0x8c, 0xf8, 0x1a, 0x07, 0x1a, 0x70, 0xf2, 0x6b, 0x0e, 0xa6, 0x16, 0x28, + 0xfd, 0xbc, 0x91, 0xed, 0x29, 0x9b, 0x63, 0x26, 0xce, 0x7f, 0x22, 0x0a, 0xab, 0x69, + 0x65, 0xbe, 0x64, 0x5f, 0xf7, 0xc5, 0x12, 0x48, 0xe4, 0x56, 0xad, 0xb3, 0x43, 0xf1, + 0x09, 0x90, 0x24, 0x34, 0x01, 0xd8, 0xe0, 0x5e, 0xbc, 0x48, 0xb5, 0x8d, 0x2a, 0x77, + 0xb2, 0x13, 0x41, 0xef, 0x51, 0x3e, 0x66, 0x15, 0x7b, 0x83, 0x59, 0x6f, 0x1f, 0x44, + 0x76, 0x95, 0xe8, 0xc8, 0x22, 0x79, 0x92, 0x2e, 0x15, 0x98, 0x7a, 0xb1, 0x42, 0x59, + 0x15, 0x7e, 0xe6, 0xe0, 0x7b, 0x5e, 0xe2, 0x8d, 0xc4, 0x1c, 0x68, 0xdb, 0xc1, 0x4c, + 0x39, 0x13, 0x1f, 0xc7, 0xa4, 0xcc, 0xf6, 0x42, 0x0f, 0x65, 0x47, 0x97, 0x01, 0x41, + 0x3d, 0x0e, 0xab, 0x48, 0x4b, 0xd5, 0x5d, 0xc1, 0x66, 0x9e, 0x4e, 0x3a, 0x3e, 0xeb, + 0xcb, 0x11, 0x8c, 0x89, 0x9b, 0x2c, 0xca, 0x6c, 0xb2, 0xdb, 0xac, 0xf6, 0xf5, 0xa7, + 0x17, 0xab, 0x0b, 0xba, 0xf0, 0x21, 0x41, 0x29, 0x9d, 0x32, 0xc8, 0x84, 0x26, 0xaa, + 0x48, 0x66, 0x17, 0x3c, 0xc1, 0x23, 0x13, 0xf2, 0xc5, 0x26, 0x24, 0x00, 0x5e, 0x6f, + 0xe1, 0x76, 0xac, 0x02, 0xbf, 0x45, 0xa9, 0x96, 0x46, 0x59, 0x02, 0x0b, 0xd0, 0x3b, + 0x9d, 0xdb, 0x8a, 0x99, 0x32, 0x2b, 0x04, 0x52, 0xa2, 0xed, 0xdc, 0x6e, 0xa7, 0x52, + 0x47, 0x3f, 0x1c, 0x1c, 0x9a, 0xb0, 0x51, 0xdc, 0x19, 0x73, 0xe8, 0x1b, 0x1e, 0x8d, + 0x74, 0x64, 0x06, 0x14, 0x8a, 0x86, 0x21, 0x57, 0x5f, 0x7c, 0x71, 0xcd, 0x28, 0x79, + 0x35, 0x0a, 0x29, 0x70, 0x74, 0x01, 0x56, 0xc6, 0x9c, 0x9f, 0xf4, 0xcf, 0xe9, 0x7a, + 0x3f, 0xf0, 0xa9, 0x0f, 0x16, 0xe9, 0x03, 0x36, 0xf6, 0x82, 0x5b, 0xdb, 0x8b, 0xa0, + 0xa3, 0xcc, 0xb2, 0xf1, 0x81, 0xd2, 0x6c, 0xc8, 0x86, 0x05, 0x49, 0x3b, 0x44, 0x2a, + 0x9d, 0x5a, 0x9f, 0x78, 0x88, 0x95, 0xb7, 0x20, 0x51, 0x6c, 0x86, 0x5d, 0x57, 0x5c, + 0x75, 0x27, 0x6c, 0x93, 0x7e, 0x22, 0x52, 0xa4, 0x86, 0xc9, 0x0e, 0x64, 0xb1, 0xc1, + 0x15, 0x06, 0x0d, 0xac, 0xac, 0xcc, 0x33, 0x72, 0xd1, 0x47, 0x5c, 0x33, 0x81, 0x09, + 0x82, 0x75, 0xbd, 0xa2, 0x3a, 0x52, 0x08, 0x3c, 0x6e, 0x67, 0x18, 0x25, 0xe5, 0x7b, + 0x40, 0x60, 0x62, 0x26, 0x24, 0x74, 0x32, 0x21, 0x39, 0x88, 0xa7, 0x67, 0x2d, 0x80, + 0xca, 0x32, 0xa2, 0x35, 0x6e, 0x16, 0x1b, 0x5a, 0x3d, 0x5a, 0x21, 0x8c, 0xf0, 0xc6, + 0x78, 0x8c, 0x62, 0xb7, 0x86, 0x00, 0x31, 0x54, 0xc9, 0x03, 0x12, 0x00, 0x1e, 0x73, + 0xbc, 0xfd, 0xd3, 0x31, 0x25, 0x73, 0x50, 0x4a, 0x0c, 0x40, 0x26, 0x66, 0x62, 0x0b, + 0x31, 0x60, 0x68, 0x83, 0x58, 0x0e, 0xa0, 0x9f, 0x69, 0x0c, 0x0c, 0xdd, 0x94, 0x85, + 0x20, 0xb1, 0x9b, 0xab, 0x2b, 0x30, 0xfd, 0xa6, 0x0d, 0xd9, 0x03, 0xc8, 0xb4, 0xf0, + 0x1a, 0x83, 0x23, 0x8e, 0xbd, 0xa1, 0x63, 0x6c, 0x91, 0x18, 0x95, 0x48, 0x0a, 0x8e, + 0x54, 0x30, 0xda, 0x58, 0x46, 0x24, 0x55, 0x48, 0x8b, 0x71, 0xa7, 0x35, 0xca, 0x62, + 0xc1, 0x92, 0x87, 0x22, 0xd5, 0x7c, 0x3d, 0x86, 0xce, 0x66, 0x76, 0x04, 0x33, 0xc1, + 0x53, 0x57, 0xeb, 0xa5, 0x56, 0xdb, 0x67, 0xad, 0xb1, 0x6f, 0x8a, 0x02, 0xcd, 0x99, + 0x5c, 0x25, 0x25, 0xd2, 0x1b, 0x49, 0xa0, 0x60, 0x20, 0xda, 0xaa, 0xea, 0xea, 0x50, + 0xd3, 0x32, 0x95, 0x2f, 0x39, 0x9b, 0xdc, 0x85, 0x95, 0x74, 0xc9, 0xc9, 0xc6, 0x05, + 0x67, 0x65, 0xd1, 0xc2, 0x57, 0xe5, 0xa6, 0x55, 0xc9, 0xa6, 0xc6, 0x19, 0x16, 0x79, + 0x63, 0xaf, 0xc8, 0x50, 0x02, 0x7a, 0x00, 0x73, 0x0d, 0x60, 0xb3, 0x3e, 0x2b, 0x89, + 0x7e, 0x71, 0xb5, 0x64, 0x66, 0xbe, 0x0f, 0xc9, 0x8a, 0x1c, 0x31, 0x4b, 0x67, 0xb3, + 0xba, 0xe7, 0x80, 0xa6, 0x22, 0xc5, 0x8e, 0xb0, 0x55, 0x70, 0x02, 0x4c, 0x98, 0x9b, + 0x28, 0x67, 0x63, 0xba, 0x42, 0x0e, 0xf2, 0x34, 0x47, 0x7c, 0x2d, 0xd8, 0xbc, 0x86, + 0xb9, 0xc9, 0xad, 0xfe, 0xd5, 0xa8, 0xc7, 0xb9, 0x48, 0xb6, 0x73, 0x5b, 0xad, 0x75, + 0x8c, 0x04, 0xf0, 0x80, 0x25, 0xeb, 0x01, 0xd2, 0x17, 0xab, 0x94, 0x07, 0x88, 0x18, + 0x78, 0x46, 0x69, 0x04, 0xb2, 0xe4, 0x96, 0x5b, 0x22, 0x75, 0x15, 0x5f, 0xd1, 0xb8, + 0x00, 0x0c, 0x7b, 0x29, 0x83, 0xa9, 0xe8, 0xf8, 0x72, 0x43, 0x55, 0x1d, 0xc3, 0x1b, + 0x88, 0x48, 0x67, 0xb3, 0xe9, 0x41, 0x8c, 0x1d, 0x51, 0x96, 0xf8, 0x3b, 0x2e, 0x7e, + 0xdc, 0xa5, 0x5c, 0xb2, 0x1d, 0xce, 0xe4, 0x30, 0x96, 0x93, 0x66, 0xfd, 0x02, 0xa8, + 0x5d, 0xeb, 0xbd, 0x75, 0x97, 0x63, 0x01, 0x0c, 0xb9, 0x18, 0xb1, 0x34, 0x60, 0xc3, + 0x3b, 0xda, 0x4b, 0x43, 0xc2, 0xaa, 0xec, 0x2b, 0x4d, 0x19, 0x80, 0x0e, 0xb4, 0x5b, + 0x65, 0xc9, 0x15, 0xf8, 0xb9, 0x69, 0xef, 0xf9, 0xe9, 0xe3, 0x56, 0xfa, 0xea, 0x1c, + 0x9c, 0xf6, 0x96, 0x59, 0x59, 0x9b, 0x22, 0xf5, 0x04, 0x36, 0xea, 0x13, 0xcf, 0x2f, + 0x1f, 0x0e, 0xc8, 0x71, 0xc3, 0xa1, 0x0a, 0xc0, 0xb3, 0x6d, 0x87, 0x7f, 0x20, 0x0b, + 0xfb, 0x72, 0x8d, 0x9f, 0x3f, 0x8f, 0x5f, 0x01, 0x4f, 0x21, 0x19, 0x38, 0xc6, 0x15, + 0xf1, 0xf1, 0x0e, 0x50, 0x00, 0xeb, 0x9d, 0x22, 0x43, 0xdf, 0x6e, 0x9c, 0x8d, 0xa3, + 0xaa, 0x6f, 0x2f, 0x41, 0xbe, 0x8f, 0x46, 0x29, 0x4d, 0x2e, 0x49, 0xc4, 0xb7, 0x84, + 0x09, 0x10, 0x1c, + ], + dk: [0x07; 32], + dk_pq: [ + 0xd7, 0xb4, 0xcf, 0x68, 0xd3, 0xf1, 0xb7, 0x11, 0x92, 0x4c, 0xcd, 0xed, 0x71, 0xa2, + 0x41, 0xfa, 0xf8, 0x16, 0x2f, 0x7e, 0xf6, 0xce, 0x74, 0x83, 0x70, 0xa1, 0x0e, 0x86, + 0xb9, 0x4b, 0xef, 0xc1, 0x98, 0x68, 0x33, 0x77, 0x94, 0x6e, 0xb9, 0x66, 0x41, 0xee, + 0xbf, 0x10, 0x06, 0x2c, 0x6d, 0xde, 0x3a, 0x01, 0x0a, 0x09, 0xb2, 0xce, 0xb1, 0x14, + 0x52, 0x10, 0xa9, 0xc1, 0x7e, 0xef, 0xc5, 0xb7, + ], + dk_t: [ + 0x19, 0xd6, 0x26, 0x50, 0x37, 0x2c, 0xc1, 0x8f, 0xd0, 0x10, 0x9c, 0xd6, 0x39, 0x4d, + 0x63, 0x8e, 0xbe, 0xb5, 0xf4, 0xca, 0xe8, 0x36, 0xca, 0x4a, 0xa5, 0x68, 0x25, 0xe9, + 0x05, 0x6e, 0x3a, 0xd5, + ], + ct: &[ + 0x89, 0x2f, 0x7a, 0x79, 0x85, 0xca, 0xf0, 0xc2, 0x31, 0xb2, 0xb3, 0x5e, 0x3b, 0xc7, + 0xde, 0x3e, 0x5a, 0x47, 0x39, 0xb7, 0x2d, 0x3f, 0x9b, 0xe3, 0x42, 0xe3, 0x26, 0xc0, + 0x17, 0x3d, 0x55, 0xa5, 0x08, 0x9e, 0xbe, 0x98, 0x26, 0xc8, 0x34, 0x79, 0x2a, 0x32, + 0x36, 0x80, 0x0e, 0xec, 0xc2, 0x61, 0x2b, 0x4d, 0x92, 0xec, 0xfd, 0xbe, 0xd0, 0x13, + 0xa6, 0xbf, 0xcd, 0x4d, 0x1f, 0xfe, 0x5c, 0x41, 0x50, 0xe7, 0x25, 0x7a, 0x9e, 0x7c, + 0x0b, 0x2e, 0x0c, 0xbe, 0xe7, 0x57, 0xfc, 0x86, 0xb5, 0xde, 0xbe, 0x03, 0xaa, 0xf7, + 0x96, 0xc7, 0x6a, 0x58, 0x25, 0xcc, 0x78, 0x66, 0x71, 0x89, 0xe0, 0xe3, 0x7f, 0x4a, + 0x1c, 0x3d, 0xda, 0x77, 0x0e, 0xb8, 0xe6, 0xb9, 0x78, 0xc8, 0x91, 0x81, 0xf4, 0x87, + 0x1b, 0xe9, 0xa2, 0x95, 0x83, 0x23, 0x34, 0xdc, 0x3a, 0x7f, 0x2b, 0x95, 0x3f, 0x7d, + 0xf4, 0x3f, 0x32, 0x11, 0x37, 0xa9, 0xad, 0x5b, 0x27, 0xe3, 0x44, 0x67, 0x8a, 0x79, + 0xe3, 0x86, 0xe4, 0x02, 0x23, 0x61, 0x24, 0x75, 0x3e, 0x6d, 0xfc, 0xba, 0x0d, 0xd0, + 0xdd, 0x97, 0x01, 0x74, 0x61, 0xc2, 0xfe, 0x03, 0x9c, 0x72, 0xe9, 0xd0, 0x07, 0x36, + 0x76, 0xf0, 0x74, 0x9d, 0x8c, 0xc9, 0xbc, 0xd6, 0xae, 0x0f, 0xa6, 0xf1, 0x4d, 0xb0, + 0xb5, 0x25, 0x75, 0x84, 0x5c, 0x5b, 0x59, 0xb8, 0x2a, 0xea, 0xe9, 0x3c, 0x8f, 0xa1, + 0xbc, 0xec, 0x6e, 0xdd, 0x08, 0x15, 0x17, 0xd6, 0xf2, 0xd3, 0xed, 0x91, 0x57, 0x5b, + 0x2d, 0xd7, 0xb5, 0x89, 0x3f, 0x3d, 0xd7, 0x55, 0xd8, 0x42, 0xbc, 0xf3, 0xe8, 0xd1, + 0x4a, 0xfc, 0x5c, 0x23, 0x6e, 0xc6, 0x62, 0x36, 0xb3, 0x3b, 0xa8, 0x75, 0x95, 0x36, + 0x33, 0xea, 0xa2, 0x3a, 0xfe, 0x29, 0x74, 0xd0, 0x01, 0x79, 0xb7, 0x2d, 0x11, 0x7d, + 0x9b, 0x8d, 0xee, 0x51, 0x10, 0x03, 0x6f, 0x41, 0x8b, 0xaa, 0x0b, 0xe0, 0x52, 0xec, + 0x09, 0xd7, 0x0f, 0xa3, 0x6c, 0x94, 0x3b, 0xb6, 0x50, 0x50, 0x46, 0x8b, 0xdf, 0xd6, + 0x34, 0x35, 0xf2, 0xed, 0xd7, 0x96, 0x2c, 0xc9, 0x8a, 0x0f, 0xc6, 0xb1, 0xd2, 0xa2, + 0xc3, 0x1a, 0x35, 0x81, 0xc3, 0x17, 0x41, 0x79, 0x0e, 0x4f, 0x7a, 0xcb, 0x16, 0x2a, + 0x71, 0x46, 0xf3, 0x99, 0x60, 0x5a, 0x08, 0xcc, 0x99, 0xb4, 0x8a, 0x96, 0xca, 0xcc, + 0xc3, 0x11, 0x8a, 0xd9, 0xfb, 0xfb, 0xba, 0x58, 0xf2, 0x9a, 0x12, 0x1c, 0xcc, 0x60, + 0x4e, 0x9c, 0x09, 0x87, 0xf2, 0x25, 0x0b, 0xe2, 0x07, 0x21, 0x89, 0xd8, 0xb0, 0x1d, + 0x59, 0x4e, 0x94, 0x6f, 0x0e, 0x5b, 0xb1, 0xb4, 0xe0, 0x45, 0xac, 0x5e, 0x56, 0x08, + 0x73, 0x64, 0x72, 0x38, 0x65, 0x84, 0xf4, 0x55, 0xbe, 0x6e, 0x74, 0xb9, 0xcb, 0x31, + 0xd6, 0xff, 0xce, 0x00, 0x8c, 0xe2, 0x83, 0xb3, 0xf8, 0x34, 0xc5, 0x6f, 0x64, 0xef, + 0x82, 0x9d, 0xd4, 0x92, 0xeb, 0x70, 0xf6, 0x81, 0x5c, 0x45, 0x12, 0x8c, 0x66, 0xe7, + 0x73, 0x24, 0xbb, 0x03, 0xf7, 0x1b, 0xaf, 0x57, 0xbf, 0x0e, 0x20, 0x0b, 0x5a, 0x59, + 0xbf, 0xb1, 0x62, 0x8e, 0x2b, 0xf2, 0x09, 0xe8, 0xd3, 0xd3, 0x9a, 0x2f, 0xdc, 0xc9, + 0xc3, 0xcc, 0x76, 0x55, 0x22, 0x4e, 0xfa, 0x1e, 0xfa, 0x86, 0xf5, 0x50, 0xe7, 0x2c, + 0x11, 0xb5, 0xeb, 0xaa, 0x0b, 0x37, 0x5e, 0x11, 0xd7, 0x7d, 0x0a, 0x4c, 0xfe, 0x4f, + 0x1f, 0x5e, 0xb0, 0x48, 0xf0, 0xcf, 0xf1, 0xc2, 0x88, 0x2f, 0xbe, 0x01, 0xd1, 0x4f, + 0xcd, 0x97, 0xcb, 0x2e, 0xd5, 0xa4, 0x0a, 0xa9, 0x7c, 0x12, 0x5f, 0x81, 0xc8, 0xc9, + 0x11, 0x64, 0xcb, 0xe8, 0x47, 0x70, 0x58, 0xff, 0x9e, 0x38, 0x06, 0x04, 0xda, 0x9c, + 0x2a, 0xc1, 0xb0, 0x61, 0x85, 0x3c, 0x2e, 0x4e, 0x97, 0x98, 0x11, 0xbe, 0xbb, 0x99, + 0x94, 0x89, 0x11, 0xda, 0xb9, 0xcb, 0x03, 0xd7, 0xc4, 0x97, 0x54, 0x61, 0xd8, 0xe7, + 0x23, 0xbc, 0x41, 0x5a, 0x39, 0x12, 0xfe, 0x11, 0x08, 0xde, 0x37, 0xb3, 0x2b, 0x49, + 0x17, 0x4b, 0x72, 0x20, 0x22, 0xc8, 0x0d, 0xfa, 0xd2, 0x88, 0x1a, 0xd1, 0xdb, 0x9f, + 0x1d, 0x6d, 0x06, 0x09, 0x0c, 0xb1, 0x42, 0x1d, 0x37, 0x98, 0xfa, 0xb2, 0xdf, 0x0f, + 0x44, 0x08, 0xc1, 0x1d, 0x07, 0xbe, 0x12, 0x1b, 0xa6, 0x6b, 0x40, 0x6a, 0x6b, 0xcd, + 0x89, 0x2c, 0xd4, 0x99, 0xe3, 0x5e, 0x1c, 0x2c, 0x20, 0xc1, 0x5c, 0x87, 0xee, 0x0e, + 0x79, 0x61, 0x2c, 0xbd, 0xd0, 0x45, 0x76, 0x95, 0x5b, 0xf6, 0x11, 0x53, 0xee, 0xe2, + 0x79, 0x8c, 0x26, 0xe4, 0xd6, 0xd3, 0x05, 0x0f, 0x3d, 0xe5, 0xf6, 0x77, 0x1a, 0xdd, + 0x04, 0x95, 0x45, 0x9e, 0x53, 0x00, 0xbb, 0x4e, 0x13, 0x98, 0x39, 0xbf, 0x6a, 0x42, + 0x06, 0xd7, 0x86, 0x5c, 0x15, 0x9d, 0x1b, 0xa9, 0xbd, 0x56, 0x6e, 0x73, 0xd9, 0xa0, + 0x85, 0x00, 0x76, 0x81, 0xd3, 0x30, 0x70, 0x40, 0xc5, 0x86, 0x16, 0xf3, 0x69, 0xc6, + 0xf2, 0xba, 0xa5, 0x4f, 0xd5, 0x9b, 0x4e, 0x27, 0xb8, 0x06, 0x51, 0x3f, 0xf6, 0x78, + 0xc2, 0xc6, 0xbd, 0xcd, 0x42, 0x3e, 0x67, 0x04, 0x74, 0x60, 0xa3, 0xa3, 0x9c, 0xb0, + 0x4e, 0xad, 0x7b, 0x09, 0x53, 0x17, 0xf0, 0x99, 0x3f, 0x3e, 0xd7, 0x5b, 0x5f, 0xc8, + 0xb7, 0x4c, 0x45, 0x8a, 0x3b, 0xd6, 0x34, 0x7c, 0x6a, 0x82, 0x64, 0x0f, 0x40, 0x41, + 0xf0, 0x16, 0x86, 0x90, 0xf8, 0xf6, 0x8f, 0x2c, 0xfa, 0xa4, 0x20, 0x59, 0x69, 0xfb, + 0x4d, 0xc9, 0xad, 0x42, 0xd2, 0x6b, 0x3f, 0xc2, 0xba, 0x5b, 0xb0, 0x8b, 0x32, 0x2d, + 0x02, 0x03, 0x11, 0x86, 0x66, 0xb6, 0x65, 0xe2, 0x04, 0x1f, 0xbe, 0xf0, 0xee, 0x95, + 0x7f, 0x73, 0xf6, 0x0f, 0xec, 0x89, 0x2a, 0x65, 0x31, 0x6d, 0x3f, 0x73, 0x31, 0x12, + 0xef, 0x2a, 0x19, 0xc7, 0x9c, 0x25, 0x95, 0xad, 0x99, 0xa4, 0xd0, 0xc9, 0x8c, 0xd1, + 0x48, 0x32, 0x6e, 0xe8, 0xf2, 0xf7, 0xb7, 0x9a, 0x16, 0x13, 0x33, 0x30, 0x22, 0x68, + 0xc4, 0x27, 0x0a, 0x96, 0xd5, 0xd6, 0x7e, 0x35, 0x03, 0xb6, 0x88, 0xa3, 0x32, 0xf2, + 0x65, 0x43, 0xce, 0x54, 0xc3, 0xdc, 0x38, 0x17, 0xdd, 0xd6, 0x16, 0x62, 0x4e, 0xf7, + 0x15, 0xa4, 0x1f, 0x1a, 0x80, 0xf4, 0x51, 0x0f, 0xc7, 0x69, 0x89, 0x21, 0x96, 0xac, + 0x3f, 0x4c, 0x62, 0xdd, 0x03, 0x91, 0xd4, 0xc5, 0xf2, 0x15, 0xab, 0x44, 0x72, 0x99, + 0xc7, 0xbb, 0xd0, 0xea, 0x1a, 0xf7, 0xd6, 0x21, 0xad, 0x9d, 0x66, 0x2a, 0xbd, 0x35, + 0xef, 0x65, 0xf9, 0x00, 0xa4, 0x0b, 0x36, 0xf3, 0x2f, 0x03, 0x52, 0xc9, 0x7a, 0x90, + 0xe7, 0x62, 0x17, 0xc3, 0x17, 0xf1, 0x89, 0x0d, 0xe7, 0x70, 0x3d, 0x60, 0x09, 0xa2, + 0x18, 0xe7, 0x50, 0x37, 0xb6, 0x8c, 0x6d, 0x34, 0xf0, 0xf8, 0xca, 0x6b, 0xef, 0x01, + 0xaf, 0x78, 0x94, 0x88, 0x34, 0x93, 0xda, 0x5c, 0x47, 0xd0, 0xfa, 0x11, 0x6a, 0xf9, + 0x4f, 0x94, 0x87, 0x47, 0xc9, 0x69, 0xb9, 0x77, 0x9b, 0xae, 0xb8, 0xb2, 0x79, 0x91, + 0x6b, 0x6a, 0xd0, 0xee, 0xa9, 0xff, 0xc4, 0xaf, 0xc1, 0xbd, 0x90, 0x76, 0x73, 0x20, + 0x34, 0x13, 0xb6, 0x09, 0xb4, 0x7e, 0xe0, 0xfd, 0xce, 0x78, 0x0e, 0x82, 0xa6, 0x98, + 0x7d, 0x63, 0x88, 0x7c, 0x28, 0x5d, 0xa9, 0x76, 0x09, 0x73, 0x6c, 0xed, 0x5f, 0xad, + 0x8f, 0xae, 0xef, 0x14, 0x1d, 0x8d, 0x03, 0x44, 0xd7, 0x0a, 0xb0, 0x79, 0x5a, 0x66, + 0x68, 0xfa, 0xe5, 0x9a, 0xa6, 0x5d, 0x41, 0x11, 0x07, 0x63, 0x14, 0x15, 0x11, 0x22, + 0x88, 0xc7, 0xe3, 0x28, 0x4e, 0x26, 0xb5, 0xdc, 0xda, 0xbf, 0x69, 0x60, 0x82, 0x1b, + 0xb7, 0x4c, 0x79, 0xfb, 0xc6, 0xfa, 0x73, 0xda, 0x77, 0xa4, 0x22, 0x09, 0x43, 0xe8, + 0x6c, 0xda, 0xf4, 0xa7, 0x3e, 0x1c, 0x5b, 0xd9, 0x18, 0xea, 0xcd, 0x53, 0xf6, 0xe0, + 0x85, 0xa6, 0x94, 0xb9, 0x33, 0x73, 0x85, 0xb4, 0x09, 0xbb, 0x1f, 0x86, 0x04, 0xab, + 0x2b, 0x9b, 0xbd, 0x39, 0x0f, 0x69, 0xcd, 0xf5, 0x0e, 0xc2, 0x04, 0x9f, 0x2e, 0x27, + 0x9a, 0x3a, 0xec, 0x28, 0x26, 0x21, 0x15, 0xbb, 0x6d, 0xfa, 0x32, 0x36, 0xbd, 0x67, + 0xd6, 0x32, 0x4c, 0x60, 0xdf, 0x93, 0x97, 0x4d, 0x6e, 0x02, 0xc4, 0x63, 0x3c, 0xbf, + 0xb8, 0x21, 0x20, 0x0c, 0xe8, 0xb4, 0x39, 0x77, 0x99, 0x2a, 0x98, 0xe1, 0xc7, 0x12, + 0xfd, 0x81, 0x87, 0xea, 0xf9, 0x54, 0x2d, 0xb5, 0xf0, 0x52, 0x67, 0xf6, 0xfc, 0xc0, + 0x9d, 0xc5, 0x23, 0xc9, 0x60, + ], + ss: [ + 0x5f, 0x8d, 0xea, 0xb6, 0xc1, 0x1f, 0x05, 0xee, 0x20, 0x8b, 0xa9, 0x68, 0xd2, 0x89, + 0x17, 0xf8, 0x21, 0x9b, 0xa2, 0xc0, 0xc3, 0x0d, 0x41, 0x65, 0x1c, 0x33, 0x82, 0xf4, + 0xd5, 0x64, 0x83, 0xc6, + ], + }, + TestVector { + seed: [0x08; 32], + randomness: [0x6c; 128], + ek: &[ + 0x00, 0x31, 0x80, 0x28, 0x22, 0x64, 0xd1, 0x42, 0x06, 0x36, 0x7c, 0x68, 0x2c, 0x2a, + 0x28, 0x2a, 0x58, 0xc1, 0x14, 0x67, 0x55, 0x07, 0x95, 0x80, 0x1e, 0x36, 0x39, 0x3c, + 0xc1, 0x6e, 0x49, 0xf5, 0x65, 0xba, 0xc9, 0x95, 0xab, 0x50, 0x44, 0x48, 0xd4, 0x84, + 0x0b, 0x85, 0x52, 0x6e, 0x83, 0x6c, 0xa6, 0xd6, 0x41, 0xf1, 0x51, 0xbd, 0x50, 0x89, + 0x7e, 0x1f, 0x9a, 0x5f, 0x6c, 0x71, 0x8a, 0x61, 0xf9, 0x7f, 0x86, 0x6b, 0x36, 0x4a, + 0x21, 0x7c, 0x87, 0xe5, 0x2c, 0xd2, 0x87, 0x65, 0xab, 0x18, 0xbf, 0x3c, 0x93, 0x1a, + 0x35, 0x15, 0x0d, 0x1c, 0x0c, 0x32, 0xc6, 0xb8, 0x63, 0x87, 0x2a, 0x23, 0x37, 0x30, + 0x57, 0xbe, 0xc8, 0x2e, 0x67, 0x19, 0x86, 0xfa, 0xd2, 0xcb, 0x15, 0xa0, 0x6a, 0x96, + 0x87, 0xa0, 0xce, 0x92, 0x37, 0x54, 0x13, 0x8b, 0x4c, 0x54, 0xba, 0x93, 0xc0, 0x82, + 0xc1, 0x47, 0xcd, 0xf1, 0x86, 0xc0, 0xd5, 0x74, 0x6c, 0xb6, 0xd5, 0x45, 0x32, 0xa2, + 0xaf, 0xaa, 0xa7, 0x01, 0x22, 0x03, 0x42, 0xf6, 0x30, 0x3e, 0xa7, 0xb6, 0x6d, 0x99, + 0x42, 0x46, 0x07, 0x22, 0x29, 0x8e, 0x3b, 0xc2, 0xf0, 0xa6, 0x12, 0xa2, 0x2a, 0x98, + 0x69, 0x46, 0x73, 0x7d, 0x05, 0x7f, 0xbf, 0x3a, 0xce, 0x20, 0xcb, 0xa6, 0xf9, 0x75, + 0x03, 0xfe, 0x03, 0xca, 0xa5, 0xc3, 0x97, 0x4e, 0x8a, 0xaa, 0xa3, 0xc7, 0xba, 0x62, + 0xbc, 0x70, 0xd1, 0x54, 0x7e, 0xa9, 0x33, 0x6a, 0xd1, 0x53, 0x15, 0xcd, 0x8a, 0x29, + 0x19, 0xb7, 0x68, 0x3b, 0x56, 0x8a, 0xeb, 0xe5, 0x4b, 0x38, 0x56, 0x12, 0xf8, 0x82, + 0x93, 0x99, 0xd8, 0x3a, 0xa3, 0xc2, 0x30, 0x8c, 0x49, 0xa7, 0x33, 0x79, 0x48, 0x1a, + 0x69, 0x0a, 0xfb, 0xa6, 0x36, 0xe1, 0x4c, 0x7e, 0x6f, 0x31, 0x67, 0x8c, 0x02, 0x2b, + 0x55, 0x2b, 0x19, 0xa6, 0xb9, 0x0b, 0x25, 0x2a, 0x71, 0x22, 0x57, 0x5b, 0xa0, 0x41, + 0xc2, 0xda, 0xba, 0x8d, 0xb6, 0xab, 0x6c, 0xb9, 0xd1, 0x3b, 0x5b, 0xb3, 0x91, 0xef, + 0x0b, 0x48, 0xfd, 0x57, 0x8e, 0x67, 0xca, 0xb1, 0xd4, 0xd0, 0x1c, 0xf4, 0xb4, 0x92, + 0xf1, 0x36, 0xc9, 0xc4, 0x80, 0x7b, 0x4a, 0x24, 0x79, 0xf3, 0x5b, 0x25, 0x5f, 0x23, + 0x44, 0x36, 0xd7, 0x1a, 0x12, 0x3b, 0x47, 0x38, 0x4c, 0x1b, 0x69, 0x09, 0xb0, 0xd8, + 0xc5, 0x55, 0x75, 0x61, 0x5a, 0x31, 0x41, 0x78, 0x67, 0x5c, 0xbc, 0x94, 0xe7, 0x46, + 0xa4, 0x15, 0xbb, 0xdc, 0x91, 0x24, 0x74, 0x04, 0x2a, 0x93, 0xd7, 0x76, 0xa8, 0x99, + 0x13, 0xa2, 0x10, 0x2e, 0xfa, 0x93, 0x77, 0xb8, 0x5b, 0x01, 0x49, 0x07, 0x5e, 0xaa, + 0xe7, 0x2c, 0x6a, 0xac, 0x3d, 0x91, 0xc7, 0x4f, 0x71, 0xd3, 0x8c, 0x06, 0x39, 0x63, + 0xd3, 0xfa, 0x0c, 0x4d, 0xa1, 0x3f, 0x52, 0x02, 0x93, 0x1f, 0x06, 0xa4, 0x51, 0x5b, + 0x08, 0xe2, 0x22, 0x60, 0x30, 0x9b, 0x88, 0x22, 0x52, 0xc9, 0x72, 0xea, 0x2e, 0x06, + 0x16, 0x0e, 0x15, 0x37, 0xbb, 0x38, 0xeb, 0x97, 0xe1, 0x99, 0x09, 0xe5, 0x8a, 0x3f, + 0x3a, 0xa0, 0x07, 0xda, 0xba, 0x59, 0x7d, 0x08, 0xae, 0x46, 0x76, 0x7b, 0xeb, 0x51, + 0x7f, 0xab, 0x01, 0x24, 0xbb, 0x39, 0xba, 0x6e, 0xab, 0xaf, 0x13, 0x1b, 0x96, 0x11, + 0xa9, 0xbb, 0xb2, 0x6c, 0x1c, 0x52, 0x55, 0x60, 0x30, 0x59, 0x9b, 0xe5, 0x38, 0x2b, + 0x99, 0xc7, 0x9f, 0x8d, 0x43, 0x56, 0xf3, 0xdc, 0x35, 0xb0, 0x86, 0x78, 0xa2, 0xa1, + 0xb2, 0x4b, 0x3c, 0xbb, 0x6d, 0xa2, 0x9f, 0x03, 0xa1, 0xbc, 0xf1, 0xba, 0xcc, 0x87, + 0xa6, 0x42, 0xd6, 0x76, 0xab, 0xe5, 0x82, 0x6e, 0x38, 0x36, 0xae, 0xcc, 0x87, 0x8d, + 0x2d, 0x67, 0x58, 0x0e, 0x39, 0xb9, 0xc5, 0x5b, 0x7a, 0xc1, 0xe6, 0xb8, 0xa4, 0xca, + 0x6e, 0xc2, 0xe8, 0x93, 0x44, 0x12, 0x25, 0x8c, 0x0a, 0xb6, 0x70, 0x81, 0x35, 0xfd, + 0x03, 0x0c, 0xdb, 0x34, 0x42, 0x9e, 0xe0, 0xa1, 0x9c, 0x78, 0x26, 0x23, 0xf0, 0x81, + 0xc0, 0x56, 0x4b, 0x7d, 0xc0, 0xbd, 0x8c, 0x35, 0xb8, 0x31, 0x67, 0x2a, 0x84, 0x13, + 0x75, 0x41, 0x27, 0xa4, 0x5a, 0xc7, 0x57, 0x21, 0x85, 0x18, 0x5f, 0x44, 0x4f, 0x01, + 0x76, 0x40, 0xb8, 0xa4, 0xc0, 0x81, 0x99, 0x27, 0x86, 0x63, 0x32, 0xc4, 0x53, 0x74, + 0xc6, 0xb2, 0x5b, 0x88, 0x41, 0x6d, 0x40, 0x94, 0x08, 0x1e, 0x83, 0x2f, 0x26, 0xd4, + 0x4f, 0x8c, 0xdb, 0x04, 0xbd, 0xe7, 0x2f, 0x17, 0xe3, 0x89, 0x86, 0xa6, 0xa6, 0x93, + 0x60, 0x4c, 0x63, 0x7c, 0xb7, 0x58, 0x05, 0x09, 0x2c, 0xfa, 0x7b, 0x29, 0x21, 0x66, + 0x5e, 0x08, 0x03, 0xd1, 0x82, 0x60, 0x0e, 0x00, 0x1b, 0x6f, 0x02, 0x3c, 0xc3, 0x93, + 0x96, 0xc2, 0x00, 0x18, 0xcf, 0xdb, 0xc8, 0x5a, 0xc8, 0xbb, 0xe5, 0xcb, 0x6f, 0xc0, + 0x94, 0xbc, 0x55, 0xc8, 0x54, 0xe2, 0x8a, 0xa3, 0xce, 0xab, 0xc7, 0xf4, 0xe1, 0xba, + 0x13, 0x27, 0x76, 0x28, 0xa1, 0x30, 0x4d, 0x6c, 0x45, 0x27, 0x53, 0x3c, 0xf9, 0xd2, + 0xb6, 0xd4, 0x3a, 0x1f, 0x6c, 0x71, 0xc7, 0x15, 0x86, 0x12, 0x1c, 0x32, 0x54, 0x31, + 0x5a, 0x6c, 0xdc, 0x02, 0xb9, 0xaf, 0xa1, 0x21, 0x84, 0xe5, 0x1d, 0x3d, 0xb0, 0x71, + 0xcc, 0x67, 0x18, 0x64, 0xf2, 0xac, 0x51, 0xfc, 0x65, 0x3a, 0x1b, 0x62, 0x81, 0x73, + 0x06, 0x10, 0x68, 0x92, 0x4f, 0x89, 0x0b, 0x18, 0xac, 0xc7, 0x4c, 0x45, 0x24, 0x24, + 0x06, 0x96, 0xbe, 0xe4, 0xc0, 0x99, 0x55, 0x2e, 0xc0, 0x23, 0x54, 0xbf, 0x27, 0x2c, + 0x94, 0xb5, 0x41, 0xb5, 0xf4, 0x49, 0x5e, 0x73, 0xc1, 0x81, 0x82, 0x71, 0x20, 0x87, + 0x2c, 0xb4, 0xa3, 0x63, 0x88, 0x96, 0x6a, 0x08, 0x10, 0x10, 0xb8, 0x0a, 0x9c, 0xf3, + 0x7c, 0x47, 0x15, 0x55, 0x6f, 0x9d, 0x0c, 0x3a, 0x5f, 0x41, 0xc5, 0x87, 0xa7, 0xce, + 0xad, 0x9a, 0xb4, 0x0e, 0x36, 0x6b, 0x53, 0x61, 0x2c, 0x74, 0x56, 0x32, 0xb0, 0x14, + 0x63, 0x68, 0xe0, 0xa5, 0x2f, 0x0b, 0x07, 0x8e, 0xb2, 0x0a, 0x60, 0x06, 0xcb, 0xf5, + 0x59, 0x1e, 0x39, 0x3c, 0x19, 0xec, 0xfb, 0x8e, 0x54, 0x35, 0xa7, 0x3c, 0xc0, 0xc5, + 0xce, 0x3a, 0x00, 0x8f, 0x50, 0x53, 0xdf, 0x16, 0x47, 0x29, 0x32, 0x71, 0xe1, 0x36, + 0x68, 0x67, 0x23, 0x2c, 0xdb, 0xb8, 0xc5, 0x80, 0x66, 0xc1, 0x05, 0x70, 0x17, 0x35, + 0xf9, 0x11, 0xdb, 0x1c, 0xa2, 0xc1, 0xb0, 0x77, 0x37, 0x46, 0x78, 0x05, 0xe3, 0x04, + 0xd2, 0x43, 0xc7, 0x33, 0xa7, 0x7c, 0xe4, 0x48, 0xb6, 0x39, 0xc2, 0x95, 0x39, 0x2b, + 0x14, 0x58, 0xb4, 0xa1, 0xa8, 0x47, 0x4c, 0xa2, 0x96, 0x8e, 0x0c, 0x78, 0x91, 0x7a, + 0x2b, 0x25, 0x5f, 0xc2, 0x47, 0xfe, 0x49, 0x3b, 0xd0, 0xd9, 0xbe, 0xc2, 0x44, 0x35, + 0x18, 0x90, 0xa8, 0x95, 0xe4, 0x70, 0xd2, 0x98, 0x05, 0x27, 0x50, 0x16, 0x6b, 0x75, + 0xa9, 0x8a, 0x85, 0x55, 0x49, 0xc3, 0x86, 0xb1, 0x40, 0xbc, 0x24, 0x32, 0x6b, 0x04, + 0x4a, 0x46, 0x9d, 0xfa, 0x66, 0x0f, 0xe5, 0x1a, 0x92, 0x82, 0x71, 0xd0, 0x11, 0xcd, + 0x54, 0x68, 0x24, 0x33, 0xf5, 0x58, 0x3c, 0x52, 0x05, 0x89, 0x8c, 0x21, 0x6c, 0xf8, + 0x0c, 0xc5, 0x45, 0x6b, 0xce, 0x0a, 0xcc, 0xf8, 0x86, 0x28, 0x00, 0xcd, 0x36, 0x66, + 0x13, 0x32, 0x26, 0x12, 0x97, 0xee, 0x98, 0x54, 0xd2, 0x30, 0xb4, 0x32, 0xd3, 0x9c, + 0x5e, 0xa6, 0x67, 0x26, 0x34, 0xa2, 0x94, 0xc9, 0x29, 0xe0, 0x91, 0x32, 0x9a, 0x37, + 0xbb, 0x5f, 0x34, 0x8f, 0x30, 0xf4, 0x82, 0x69, 0x9a, 0x88, 0xde, 0xba, 0x93, 0xd5, + 0x87, 0x45, 0xf2, 0xb0, 0x13, 0xa9, 0x93, 0x81, 0x6e, 0x4c, 0x1b, 0x90, 0xd2, 0x81, + 0x18, 0xd9, 0xca, 0xfe, 0x2a, 0x48, 0xbd, 0x02, 0x4b, 0xe3, 0x28, 0x49, 0x0b, 0x70, + 0x31, 0x77, 0xb5, 0x0e, 0xd6, 0x19, 0xa9, 0xb2, 0x93, 0x94, 0x4f, 0x30, 0xbd, 0x62, + 0x11, 0x9e, 0xb1, 0x54, 0x86, 0xa6, 0xc3, 0x65, 0x9e, 0xb0, 0xaa, 0x97, 0xe1, 0x83, + 0x2d, 0x82, 0x72, 0x36, 0x27, 0x67, 0x0c, 0x30, 0xb5, 0x46, 0x33, 0x74, 0x28, 0xa7, + 0x36, 0x4e, 0xc4, 0x95, 0x39, 0x70, 0x9d, 0xad, 0x61, 0x94, 0x3a, 0x54, 0x50, 0x88, + 0xc7, 0x54, 0xe2, 0x7c, 0x85, 0x79, 0x10, 0x71, 0x33, 0x76, 0xb8, 0x59, 0xe3, 0x92, + 0xd0, 0x55, 0x4a, 0x09, 0xc0, 0x4d, 0x29, 0xaa, 0x8a, 0xdb, 0x87, 0x54, 0xa4, 0x91, + 0x05, 0x99, 0x03, 0x22, 0x1d, 0x68, 0x9f, 0xba, 0xee, 0x7d, 0x0a, 0x71, 0x44, 0x87, + 0x05, 0x3a, 0x81, 0x2b, 0xf2, 0x2b, 0xd2, 0x0b, 0xcc, 0x6b, 0x3a, 0xba, 0x85, 0x39, + 0x6d, 0xac, 0x33, 0x7a, 0xd4, 0x3e, 0x54, 0x94, 0x04, 0x74, 0x12, 0xcf, 0x9d, 0x1e, + 0x00, 0x99, 0xd8, 0x0d, 0xed, 0xf5, 0xf4, 0x35, 0x39, 0x07, 0x86, 0xc8, 0xa9, 0xc3, + 0x27, 0xe7, 0x63, 0x94, 0xd4, 0x20, 0x37, 0x80, 0x8c, 0x7f, 0x2c, 0x12, 0x25, 0x3e, + 0x45, 0xcb, 0xff, 0x4a, 0x9f, 0x54, 0x4b, 0x17, 0x5d, 0x24, 0xb7, 0x65, 0x5a, 0x9d, + 0x94, 0x6a, 0xb5, 0x33, 0xb0, 0xfa, 0x10, 0xf5, 0x10, 0x8b, 0x17, 0xc3, 0x07, 0x72, + 0xcf, 0x41, 0x72, + ], + dk: [0x08; 32], + dk_pq: [ + 0x08, 0xf6, 0x8b, 0x3e, 0x03, 0x56, 0x8d, 0x1e, 0x99, 0xc5, 0xc2, 0x16, 0x7c, 0xf4, + 0x1d, 0xba, 0x4a, 0x60, 0x77, 0x55, 0x74, 0xd2, 0x1a, 0x9c, 0x79, 0x41, 0x4b, 0xf1, + 0xfb, 0x67, 0xa5, 0x47, 0xe9, 0x1d, 0x5f, 0x36, 0x26, 0x7e, 0xf0, 0x61, 0xcf, 0x68, + 0x1c, 0xbe, 0x41, 0xb9, 0xcb, 0x15, 0xc1, 0x7e, 0xe5, 0x2a, 0x35, 0x79, 0xa5, 0x1c, + 0x20, 0x39, 0x7b, 0xa3, 0xbd, 0xa5, 0xea, 0x72, + ], + dk_t: [ + 0x76, 0xa5, 0x74, 0x36, 0x2e, 0x7f, 0x03, 0xf2, 0x7c, 0xc6, 0xf4, 0x28, 0x8e, 0x04, + 0x6d, 0x75, 0x3d, 0xf4, 0x76, 0x49, 0xc0, 0x07, 0x74, 0x14, 0x68, 0xfc, 0x4d, 0x25, + 0x27, 0x45, 0x15, 0x0b, + ], + ct: &[ + 0xfe, 0xfe, 0xbc, 0x6f, 0x6f, 0x4d, 0xab, 0x06, 0xbd, 0x9b, 0x8d, 0x0a, 0x3a, 0x68, + 0x8b, 0x06, 0xe4, 0xb3, 0xce, 0x99, 0x9c, 0xff, 0x7e, 0xb7, 0x63, 0xd8, 0x0f, 0x6d, + 0x28, 0x8d, 0x9d, 0x8c, 0x58, 0xd2, 0x40, 0xd8, 0xd2, 0x17, 0x06, 0x4c, 0x98, 0x48, + 0xa1, 0x50, 0x87, 0x26, 0x82, 0x9e, 0x17, 0x7a, 0x02, 0xb9, 0x9a, 0xc3, 0x3a, 0xc7, + 0x6e, 0x50, 0xa8, 0x2d, 0x31, 0xe9, 0xf9, 0x52, 0x09, 0x8c, 0x47, 0x31, 0xa0, 0xfc, + 0x35, 0xc9, 0xda, 0x8e, 0x9c, 0x87, 0xaf, 0x73, 0x06, 0xee, 0x71, 0x71, 0xe3, 0xae, + 0xe3, 0xa3, 0xd2, 0xd0, 0x46, 0xbc, 0xcc, 0x15, 0x94, 0xa9, 0x68, 0x6a, 0x77, 0x49, + 0xb9, 0x06, 0x34, 0x6a, 0x7c, 0x86, 0x3d, 0x8d, 0xd3, 0x4a, 0xcc, 0xed, 0x60, 0x1a, + 0x39, 0x53, 0xa0, 0x5e, 0x8c, 0xea, 0xbf, 0x34, 0x79, 0x7b, 0x46, 0x06, 0xef, 0xf6, + 0x3e, 0x66, 0xfb, 0xde, 0xcc, 0xaf, 0x98, 0x1c, 0x13, 0x66, 0x0a, 0x8b, 0x8d, 0xe6, + 0x61, 0xc5, 0xb7, 0x53, 0xf7, 0x3c, 0x7e, 0x2c, 0xbc, 0x73, 0x33, 0x79, 0xc4, 0xd9, + 0xc3, 0x6b, 0x93, 0xb7, 0x56, 0xf5, 0xbe, 0xcb, 0x1e, 0xd5, 0x69, 0xd6, 0xdb, 0x0b, + 0x2d, 0x2b, 0x11, 0x02, 0xe6, 0x06, 0x4c, 0xc4, 0x31, 0x1d, 0xa3, 0x03, 0x0c, 0x3f, + 0x1a, 0x11, 0x26, 0xdf, 0x69, 0xfc, 0xd2, 0xc5, 0xc3, 0x08, 0x4e, 0xe1, 0xcc, 0x75, + 0x76, 0x1e, 0x53, 0x58, 0xac, 0x39, 0xc4, 0xeb, 0xd4, 0x72, 0xca, 0xf4, 0xe5, 0x55, + 0xf8, 0xda, 0x38, 0xdb, 0xa8, 0xef, 0x86, 0x2c, 0x92, 0xea, 0xcd, 0xde, 0xc9, 0xc2, + 0x70, 0xb5, 0xc7, 0x12, 0x74, 0xc1, 0x5f, 0xc3, 0x86, 0x74, 0xbe, 0xba, 0xbd, 0xc7, + 0xca, 0xe2, 0x44, 0x4d, 0xec, 0x1e, 0x79, 0x77, 0x67, 0x95, 0x78, 0xf0, 0x51, 0xfe, + 0x3e, 0xe9, 0xd7, 0xa1, 0x88, 0x56, 0x5d, 0x5f, 0xce, 0x8f, 0xbc, 0xb8, 0x42, 0xb2, + 0x8a, 0x4d, 0x38, 0xd7, 0x7e, 0xb3, 0x7d, 0xac, 0x58, 0x09, 0x96, 0x64, 0xfd, 0x1b, + 0x80, 0x69, 0xce, 0xef, 0x1e, 0x06, 0xba, 0x95, 0xa3, 0x9b, 0xf4, 0x8f, 0x70, 0x98, + 0xa9, 0xbf, 0xf8, 0x4f, 0x6f, 0x2d, 0xf8, 0x66, 0x43, 0xdb, 0x53, 0x45, 0x5b, 0xe4, + 0xbf, 0xa4, 0x84, 0x8d, 0x93, 0xca, 0xa1, 0xfc, 0x13, 0x98, 0xac, 0x24, 0x0d, 0x18, + 0x6b, 0xb3, 0x33, 0x4b, 0xb5, 0x38, 0x1c, 0x9d, 0x08, 0x9a, 0xe3, 0xc8, 0x63, 0x7d, + 0xee, 0xde, 0xaa, 0x57, 0x6e, 0x6b, 0x92, 0xcc, 0x7b, 0x66, 0xbd, 0x3a, 0x31, 0xf3, + 0xc9, 0x56, 0xb4, 0xae, 0xb4, 0xeb, 0x68, 0x8b, 0x24, 0x9c, 0xf9, 0xb5, 0x7a, 0x56, + 0xd3, 0x65, 0x6b, 0x53, 0x74, 0xf8, 0x06, 0xb0, 0x28, 0x75, 0x56, 0x2e, 0xa1, 0x5f, + 0xcb, 0x61, 0x93, 0x95, 0xec, 0x91, 0x30, 0x26, 0xdb, 0xe5, 0xa6, 0xd4, 0x88, 0xcf, + 0x90, 0x77, 0x45, 0xcc, 0x65, 0xdb, 0xc9, 0x27, 0x4c, 0xcb, 0x5e, 0x24, 0x61, 0xb9, + 0xe9, 0x23, 0x86, 0x2a, 0x67, 0x74, 0x4c, 0x8b, 0x8f, 0xf1, 0x9d, 0xda, 0x10, 0x68, + 0xfe, 0x40, 0x88, 0x59, 0xf8, 0x9b, 0x5b, 0x85, 0x50, 0xed, 0x08, 0x95, 0x6c, 0xe2, + 0xb5, 0xc9, 0xa6, 0x17, 0xe7, 0xef, 0x60, 0x22, 0x77, 0x2a, 0x58, 0xb6, 0x3b, 0xbd, + 0xbf, 0x5e, 0xb0, 0x57, 0xc4, 0xbd, 0xf3, 0x00, 0x83, 0xbc, 0x5d, 0xe8, 0xa2, 0x26, + 0x28, 0xfd, 0x84, 0x5b, 0xc6, 0xeb, 0xcf, 0xe2, 0x72, 0x77, 0xd1, 0xd7, 0xf5, 0x7c, + 0xee, 0xb7, 0xbe, 0xb0, 0x7a, 0x20, 0xca, 0x44, 0x6f, 0xc6, 0x5a, 0x37, 0x29, 0x29, + 0x92, 0x07, 0x92, 0xd2, 0xc4, 0x6a, 0xfe, 0x34, 0xbe, 0x5a, 0x05, 0x2a, 0xb4, 0x3d, + 0xb9, 0xe0, 0xb3, 0xc2, 0xd0, 0x24, 0xcb, 0x72, 0x0e, 0x42, 0xbd, 0x20, 0xdb, 0x4a, + 0x53, 0xe5, 0xbb, 0x32, 0xa1, 0x35, 0x69, 0x89, 0xb1, 0xd5, 0x85, 0x06, 0x11, 0x91, + 0x85, 0x49, 0xe9, 0xf5, 0x70, 0x01, 0xc9, 0x48, 0x8b, 0x8e, 0xb1, 0x2a, 0x36, 0xe8, + 0x55, 0x95, 0xca, 0x45, 0x93, 0x4f, 0xea, 0x1d, 0x60, 0x1b, 0x42, 0xc6, 0x70, 0x78, + 0xa4, 0xfb, 0xe7, 0x01, 0x49, 0x6e, 0x44, 0x3b, 0x49, 0xfc, 0x88, 0x22, 0xfa, 0xd0, + 0xc8, 0xfc, 0x3a, 0x25, 0xb3, 0x91, 0x0a, 0x51, 0x58, 0xb3, 0x80, 0xaa, 0x67, 0x8c, + 0xda, 0x32, 0x9e, 0x2c, 0xed, 0xae, 0xc1, 0xc4, 0xa3, 0x2e, 0x51, 0xb4, 0xba, 0xf7, + 0x09, 0x1e, 0xfa, 0x5e, 0xdd, 0x6a, 0xe2, 0xae, 0xc4, 0x50, 0xe1, 0x5c, 0xfe, 0xc1, + 0xce, 0xd9, 0xa1, 0xd1, 0x58, 0xc9, 0xf8, 0xf1, 0x9e, 0x21, 0x15, 0x5e, 0x41, 0x63, + 0xea, 0xec, 0xf7, 0xf0, 0x1d, 0x16, 0xba, 0x49, 0x5f, 0xde, 0x48, 0xf3, 0x96, 0x45, + 0xa4, 0x4d, 0x37, 0x33, 0xea, 0x26, 0x5c, 0xff, 0x5d, 0x4f, 0x21, 0x29, 0xe3, 0xc8, + 0x3a, 0x6c, 0xa3, 0x3a, 0x62, 0x23, 0xf8, 0x55, 0xa9, 0x1a, 0xd4, 0x97, 0x76, 0xd6, + 0x4e, 0xcf, 0xae, 0x68, 0x78, 0x66, 0x8e, 0xfe, 0xea, 0xc9, 0x30, 0xab, 0x6f, 0xe9, + 0x18, 0x33, 0x70, 0xc6, 0x17, 0x27, 0xb4, 0x04, 0x9a, 0x1d, 0xff, 0x85, 0x79, 0x94, + 0x7b, 0xf1, 0x6a, 0xd1, 0xc0, 0xe2, 0x10, 0x52, 0x4c, 0x4f, 0x5a, 0xe7, 0x54, 0x8f, + 0x3d, 0x3e, 0x53, 0x2e, 0x69, 0x4a, 0xbe, 0xd9, 0x30, 0x3f, 0xf2, 0x60, 0x17, 0x85, + 0x05, 0x54, 0x21, 0x41, 0xca, 0x98, 0x0d, 0xe1, 0x20, 0x90, 0xee, 0xc0, 0x1d, 0xa3, + 0x39, 0x9e, 0x8e, 0x45, 0x49, 0x34, 0xbb, 0x15, 0x75, 0x9d, 0x34, 0x84, 0x04, 0xd6, + 0x47, 0xbb, 0x2a, 0x40, 0x9b, 0x9d, 0x8a, 0x95, 0x60, 0x21, 0xbd, 0xb8, 0x5d, 0xdb, + 0xa1, 0x97, 0x85, 0x93, 0xaa, 0x56, 0xd9, 0x61, 0xed, 0xe3, 0xa7, 0x07, 0xe7, 0xb0, + 0xbb, 0x6f, 0x32, 0x52, 0x29, 0xce, 0x75, 0x4c, 0x70, 0x2d, 0x9e, 0xbc, 0x35, 0xa2, + 0x66, 0x3c, 0x0c, 0xee, 0xc6, 0xb3, 0xd0, 0x4e, 0xbd, 0x91, 0xa6, 0x38, 0x54, 0x73, + 0x6e, 0xf4, 0xb6, 0x01, 0x49, 0x5c, 0x26, 0xaa, 0x49, 0x27, 0xb9, 0xcc, 0xba, 0xe3, + 0xad, 0xc8, 0x08, 0xb3, 0x25, 0x71, 0xff, 0x32, 0x28, 0x8d, 0x46, 0xc2, 0x96, 0x7a, + 0x96, 0xb5, 0x3e, 0x75, 0x60, 0x27, 0xd5, 0xea, 0xfe, 0xd7, 0xdc, 0x8d, 0x7d, 0x53, + 0x37, 0xf9, 0x83, 0x09, 0xff, 0xd1, 0xa3, 0x00, 0xeb, 0xa2, 0xc0, 0x22, 0x21, 0xa3, + 0xf1, 0x00, 0xb6, 0x8c, 0xb0, 0x66, 0x86, 0x1f, 0xbc, 0xb3, 0x92, 0x52, 0xac, 0x44, + 0x6c, 0x3e, 0xd3, 0xa9, 0x63, 0x97, 0x08, 0xfd, 0x86, 0x6e, 0x9f, 0xc0, 0xbf, 0xe4, + 0xa7, 0xae, 0xc1, 0x98, 0x69, 0x6a, 0xa1, 0x39, 0x79, 0x28, 0x7d, 0xcf, 0x1f, 0xdc, + 0xd1, 0x43, 0xa4, 0x4a, 0x78, 0xcc, 0x60, 0x06, 0xbe, 0xba, 0x2e, 0x1a, 0xe7, 0x0e, + 0x8e, 0x85, 0x77, 0x64, 0xd2, 0x33, 0xe5, 0x48, 0x30, 0x47, 0x3f, 0xbb, 0xd2, 0xb1, + 0x73, 0xa3, 0x4c, 0x16, 0xc2, 0x03, 0x2d, 0x00, 0x4f, 0xe1, 0x9d, 0x35, 0xd8, 0xa5, + 0x27, 0x78, 0x24, 0x26, 0x0f, 0x32, 0xae, 0x50, 0x1e, 0x24, 0x59, 0x29, 0x16, 0xea, + 0x46, 0xec, 0x14, 0xa9, 0xbc, 0x30, 0x1f, 0xd0, 0xc9, 0x00, 0xe3, 0x3a, 0x1b, 0x24, + 0xcd, 0x15, 0x3a, 0x25, 0xaf, 0xaa, 0x34, 0xee, 0x26, 0xcb, 0xc9, 0x21, 0x5f, 0xc6, + 0xfa, 0x18, 0x97, 0x27, 0x14, 0xaa, 0xb7, 0x9b, 0x72, 0x93, 0x9b, 0x9f, 0x4d, 0x31, + 0x90, 0xb9, 0xbd, 0x64, 0x28, 0x2c, 0x0e, 0x63, 0x0b, 0x6d, 0x8c, 0x67, 0x55, 0xd2, + 0x91, 0xe3, 0x3d, 0xc3, 0xcf, 0x6b, 0x6a, 0x74, 0x0b, 0x56, 0x5b, 0x1c, 0xc2, 0x92, + 0xf2, 0xce, 0xf3, 0xb8, 0xcc, 0x6a, 0x6f, 0x13, 0xa3, 0xc7, 0xb0, 0x65, 0x25, 0xe4, + 0xe7, 0x89, 0x7f, 0x63, 0xc8, 0x25, 0x02, 0xf7, 0xfd, 0x77, 0xba, 0xe5, 0xa8, 0x0a, + 0x63, 0xc7, 0x43, 0x6f, 0xdc, 0x83, 0x87, 0x78, 0x7e, 0xe3, 0x4a, 0x00, 0x0a, 0xc1, + 0x51, 0x2c, 0x5b, 0xb3, 0x82, 0x0d, 0xc6, 0xa9, 0xb4, 0x9e, 0x04, 0x8a, 0xe6, 0x22, + 0x96, 0x28, 0x18, 0x29, 0x4b, 0x82, 0x10, 0xf6, 0xb8, 0x8c, 0x29, 0x73, 0x9e, 0xf9, + 0xe9, 0x2b, 0x39, 0x53, 0xc7, 0xe0, 0x73, 0xae, 0x38, 0xdd, 0xe1, 0x78, 0xf6, 0x03, + 0x20, 0xfc, 0x97, 0x4a, 0x31, 0x1b, 0x78, 0xd6, 0x82, 0x05, 0x93, 0xce, 0x11, 0xcf, + 0xf1, 0xef, 0x14, 0x7d, 0xca, 0x0d, 0x29, 0x11, 0x86, 0xa4, 0x5d, 0x82, 0x3e, 0xe5, + 0x2d, 0x4f, 0xae, 0xb8, 0x61, + ], + ss: [ + 0xf9, 0xd4, 0xfe, 0x89, 0xbe, 0x29, 0xe5, 0x43, 0x8f, 0x8e, 0xd2, 0xee, 0x8d, 0x36, + 0x8c, 0x36, 0x5e, 0x55, 0x0b, 0x63, 0x36, 0xc5, 0x5a, 0x4d, 0x91, 0xf3, 0xd9, 0x6d, + 0xaf, 0xb3, 0x19, 0x1a, + ], + }, + TestVector { + seed: [0x09; 32], + randomness: [0x6d; 128], + ek: &[ + 0x46, 0x03, 0x93, 0xd6, 0x22, 0x24, 0x35, 0xd9, 0x2a, 0x68, 0xeb, 0x6b, 0x23, 0x84, + 0xae, 0x41, 0x4b, 0xa0, 0x41, 0x99, 0xac, 0x14, 0xe5, 0x61, 0xf6, 0x71, 0x1f, 0xac, + 0xf8, 0x71, 0x80, 0xa4, 0xaf, 0x61, 0x56, 0xa5, 0xcf, 0x58, 0x9c, 0x8e, 0xc7, 0x98, + 0x30, 0x54, 0x76, 0x42, 0x31, 0x64, 0x6f, 0x07, 0xc5, 0x7a, 0xe4, 0x24, 0x7d, 0xe3, + 0x7b, 0xb7, 0x37, 0x58, 0xa6, 0x0b, 0x4d, 0x33, 0x34, 0x98, 0x52, 0x38, 0x56, 0x30, + 0x05, 0xab, 0x33, 0x7c, 0x60, 0x75, 0xb8, 0x14, 0x16, 0xc2, 0x41, 0xfc, 0xe7, 0x64, + 0x50, 0x5a, 0xcd, 0x0f, 0xe7, 0xb0, 0xfb, 0xb8, 0x59, 0xe4, 0x17, 0x23, 0x90, 0xe6, + 0x70, 0x08, 0x94, 0x14, 0x10, 0x75, 0x49, 0xed, 0x29, 0x8b, 0xca, 0x65, 0x8a, 0x22, + 0x90, 0x79, 0x86, 0x6b, 0x8b, 0x96, 0x0a, 0x7c, 0x7f, 0xe4, 0x6c, 0xc4, 0x7a, 0x17, + 0x73, 0x01, 0x0f, 0x10, 0x6b, 0x6f, 0x5c, 0xc9, 0xc2, 0xf9, 0x06, 0x46, 0x58, 0x51, + 0xa7, 0x71, 0x66, 0x49, 0xb6, 0xa6, 0x7f, 0xf0, 0x73, 0x80, 0x7c, 0xfc, 0x7b, 0xe4, + 0xca, 0xc4, 0x4c, 0xd1, 0xaf, 0x6a, 0x37, 0x2c, 0xb0, 0x41, 0x61, 0xd4, 0xd3, 0x98, + 0x61, 0x78, 0x0c, 0x6f, 0x62, 0x05, 0x1d, 0xfc, 0xc3, 0x9c, 0x14, 0x3d, 0xcb, 0xe4, + 0x9b, 0xbf, 0x5b, 0x58, 0xa8, 0x76, 0x9b, 0x92, 0x71, 0x73, 0xe4, 0xc7, 0x09, 0x6c, + 0x91, 0x31, 0x0a, 0x91, 0x48, 0x4c, 0xc8, 0x0c, 0x55, 0x21, 0x7b, 0x76, 0x12, 0x4d, + 0x0d, 0xb0, 0x96, 0x5f, 0x84, 0xbe, 0xf0, 0x16, 0x04, 0x0c, 0xf1, 0x99, 0x47, 0xd6, + 0x1e, 0x05, 0xa1, 0x4f, 0x32, 0x2b, 0xbd, 0x91, 0x83, 0x92, 0xf5, 0x08, 0x3b, 0xe5, + 0x40, 0xa1, 0x22, 0xa3, 0xb1, 0xd7, 0xbc, 0x7c, 0x49, 0xa8, 0x68, 0xf6, 0x38, 0x4d, + 0xd5, 0x25, 0x98, 0x50, 0xd4, 0x27, 0x16, 0x67, 0x52, 0xbf, 0x28, 0x6a, 0x3a, 0xe7, + 0x29, 0xe3, 0xa5, 0xa5, 0xe7, 0x62, 0x09, 0xde, 0x5b, 0x9c, 0x07, 0x83, 0xa4, 0xc7, + 0x05, 0x04, 0xa3, 0x38, 0xaf, 0x3d, 0x17, 0x8e, 0xbd, 0x11, 0x4b, 0x7e, 0xf7, 0x00, + 0xcc, 0x17, 0x91, 0x9b, 0x25, 0x86, 0x82, 0xd2, 0x1a, 0x12, 0x44, 0xa0, 0x02, 0xfb, + 0xca, 0x20, 0x9a, 0x80, 0xcb, 0x2a, 0x94, 0xe4, 0x47, 0x6a, 0xae, 0xb7, 0xcd, 0x00, + 0x29, 0x29, 0xef, 0x99, 0x90, 0x95, 0xc8, 0x93, 0x62, 0x46, 0x67, 0xae, 0x2b, 0xc8, + 0x71, 0x2b, 0x20, 0xe3, 0x58, 0x15, 0x59, 0x91, 0x96, 0xde, 0x47, 0x8f, 0x67, 0x4b, + 0x50, 0xe2, 0x83, 0x13, 0xd7, 0x69, 0x5c, 0xe2, 0xba, 0x3d, 0xc0, 0x25, 0x94, 0x17, + 0x1a, 0x1b, 0xa7, 0xa0, 0x95, 0xa4, 0x35, 0x1a, 0x0f, 0x33, 0x06, 0xf5, 0x1b, 0x4c, + 0x09, 0xcc, 0xaf, 0xea, 0x58, 0x76, 0x93, 0xa9, 0x51, 0x9f, 0x4b, 0x49, 0x76, 0x26, + 0x04, 0x45, 0x42, 0x1a, 0x86, 0x5a, 0x40, 0x0a, 0x63, 0xb0, 0xa0, 0x3a, 0x8d, 0x9a, + 0x35, 0xce, 0x33, 0x35, 0xbe, 0xc1, 0x91, 0x24, 0x60, 0xe1, 0xa5, 0xb4, 0x68, 0x5f, + 0x8f, 0xb0, 0x39, 0xa5, 0xcb, 0x44, 0x4c, 0xa2, 0x1f, 0x87, 0xc5, 0x22, 0xc7, 0xe6, + 0x55, 0x4f, 0x29, 0x00, 0x7c, 0x05, 0x62, 0xe5, 0xf0, 0x2e, 0xee, 0x84, 0x9f, 0x29, + 0xd3, 0x9b, 0xc1, 0x5b, 0x58, 0xff, 0x58, 0xb2, 0x52, 0x58, 0x1a, 0xdb, 0xb1, 0x7a, + 0x42, 0xf2, 0x35, 0x7c, 0xe6, 0x27, 0x46, 0xb1, 0x34, 0x7a, 0x41, 0x23, 0xd0, 0x2a, + 0xa5, 0xc3, 0x97, 0x4e, 0xed, 0x86, 0x3e, 0xb4, 0xf3, 0x09, 0xc5, 0xb2, 0x65, 0xd0, + 0x38, 0xaa, 0x6f, 0x99, 0x4e, 0x8d, 0xe9, 0x4d, 0xa3, 0x84, 0x32, 0x1f, 0xc6, 0x5b, + 0xda, 0x70, 0x4a, 0x15, 0x21, 0x64, 0x51, 0x46, 0x5f, 0x9d, 0x44, 0xb7, 0xe8, 0xa9, + 0xb7, 0xe6, 0xd3, 0x56, 0xe8, 0xa3, 0x99, 0xe7, 0xeb, 0x39, 0xd0, 0xb4, 0x6d, 0x85, + 0xec, 0x0c, 0xc9, 0x3c, 0x56, 0xa6, 0xd5, 0x70, 0xc9, 0xa8, 0x86, 0x5a, 0xa6, 0xc7, + 0x4f, 0x35, 0x8f, 0xf1, 0xc0, 0x3b, 0x80, 0x04, 0x25, 0x67, 0x79, 0x6c, 0x41, 0xf4, + 0x18, 0x74, 0x71, 0x26, 0xbb, 0x4a, 0xc2, 0x9d, 0x73, 0x83, 0x72, 0xfc, 0xa1, 0xa9, + 0x64, 0x6a, 0xd6, 0xe7, 0x90, 0x15, 0x81, 0xc6, 0x84, 0x5c, 0x91, 0xc3, 0x98, 0x90, + 0x58, 0xa8, 0x2b, 0xd8, 0x01, 0x17, 0xe7, 0xc7, 0x3b, 0xd2, 0xda, 0x15, 0xcf, 0xf5, + 0x22, 0xfb, 0xf5, 0x99, 0xfa, 0x68, 0x40, 0x31, 0x76, 0x08, 0xe4, 0x10, 0xb5, 0x2b, + 0x4c, 0x47, 0x78, 0x27, 0x87, 0x7f, 0xf6, 0x12, 0xcf, 0x89, 0xcf, 0x6c, 0x87, 0xc8, + 0xa7, 0x2b, 0x17, 0x5b, 0x6c, 0x86, 0x27, 0xe0, 0xa1, 0x0b, 0x93, 0x7c, 0xc6, 0x72, + 0xc1, 0xaf, 0x54, 0xb6, 0x43, 0x28, 0xc7, 0x33, 0xc2, 0x25, 0x85, 0xb8, 0x8c, 0x54, + 0xd3, 0x0c, 0x1a, 0x22, 0xbf, 0xb6, 0xa2, 0x55, 0x9b, 0x17, 0x8d, 0xb7, 0xa0, 0xaa, + 0xb6, 0x00, 0x1d, 0xda, 0xc9, 0x25, 0x04, 0x16, 0xae, 0x5c, 0x11, 0xc0, 0xa5, 0xa2, + 0x6a, 0x09, 0xd3, 0x85, 0x18, 0xb2, 0x8f, 0x8e, 0x3a, 0x7f, 0x2e, 0xb5, 0x1e, 0x0d, + 0x67, 0x9f, 0x1d, 0x92, 0x8b, 0x77, 0xe1, 0x03, 0xf4, 0xfa, 0x62, 0x18, 0xf6, 0x8a, + 0x1d, 0xe0, 0xaf, 0x5e, 0xa0, 0xbd, 0x1a, 0x26, 0xbb, 0x62, 0x48, 0x79, 0xab, 0x47, + 0xa2, 0x8e, 0x9c, 0x40, 0x04, 0x2b, 0x29, 0xcb, 0xd6, 0x78, 0xf7, 0xab, 0x65, 0x35, + 0x38, 0x07, 0xd4, 0x19, 0x93, 0xbf, 0xe1, 0x16, 0x07, 0x31, 0x34, 0x30, 0xe5, 0xaa, + 0x8c, 0x27, 0xb9, 0xaf, 0x3a, 0x5f, 0x10, 0x53, 0x1a, 0xec, 0xb1, 0xa1, 0xc3, 0x71, + 0x0f, 0x2b, 0x99, 0x2c, 0x99, 0xb6, 0x04, 0xf7, 0xb2, 0xa3, 0x26, 0x9a, 0x49, 0x09, + 0x1a, 0x3a, 0x56, 0xdc, 0x8b, 0x78, 0x48, 0x7a, 0xd9, 0xac, 0x24, 0xe3, 0x6c, 0x97, + 0xd3, 0x51, 0x85, 0x5e, 0xe1, 0x71, 0x50, 0x83, 0xa3, 0xe9, 0xc3, 0x2f, 0x52, 0xf7, + 0x35, 0xa7, 0x6c, 0xb0, 0x08, 0x71, 0x4f, 0xa8, 0x3b, 0xc7, 0x0e, 0x4c, 0xaa, 0xb7, + 0x2c, 0x48, 0x5a, 0xc8, 0x43, 0x1c, 0xc9, 0x7c, 0xfb, 0xa7, 0x27, 0xfc, 0xc0, 0xaf, + 0x9c, 0x54, 0x2d, 0x7d, 0x91, 0x99, 0xbc, 0x4b, 0x50, 0xa9, 0xba, 0x83, 0xdb, 0x77, + 0xc7, 0xdc, 0x20, 0x6f, 0xda, 0x05, 0x47, 0xe2, 0x79, 0x5a, 0x8d, 0xc3, 0x6f, 0xd1, + 0xb3, 0x3d, 0x2d, 0xda, 0xb0, 0x89, 0xd9, 0x5e, 0xb1, 0x6b, 0x15, 0xda, 0x94, 0xa7, + 0x4e, 0xd8, 0xb7, 0xe8, 0xda, 0xad, 0xf8, 0x18, 0x07, 0x21, 0xe0, 0xa1, 0xe3, 0x10, + 0x02, 0x49, 0x7c, 0x83, 0xce, 0x17, 0x47, 0xfb, 0xe7, 0x8c, 0xac, 0x29, 0x1f, 0xfd, + 0x96, 0x7f, 0x23, 0xf4, 0x7a, 0x8a, 0x30, 0x48, 0x5a, 0xa3, 0x52, 0xcf, 0xd4, 0xc6, + 0x90, 0x7c, 0xb8, 0xb2, 0x01, 0xbc, 0x3b, 0x92, 0x81, 0xeb, 0x51, 0x98, 0x5e, 0x11, + 0xcb, 0xb4, 0xb5, 0x25, 0x0e, 0xf7, 0xca, 0x13, 0xc7, 0x06, 0x74, 0xf3, 0x95, 0xc5, + 0x2b, 0x17, 0x75, 0x41, 0xb5, 0x7b, 0x3a, 0xac, 0x77, 0xe3, 0x82, 0xd5, 0xbc, 0x6e, + 0x0c, 0x32, 0xaa, 0xde, 0x73, 0xc7, 0x4a, 0x16, 0x3c, 0x0f, 0x43, 0xa5, 0x9c, 0x61, + 0x6d, 0x76, 0x39, 0x3f, 0x39, 0x16, 0x6d, 0xe8, 0x31, 0x8f, 0xef, 0x1b, 0x2c, 0x47, + 0x07, 0x5c, 0x19, 0x88, 0x5e, 0xce, 0xa7, 0xb4, 0xac, 0xc6, 0x74, 0xd1, 0xc7, 0x2a, + 0x2e, 0x4c, 0xa7, 0x0d, 0x28, 0x32, 0x5f, 0x12, 0xcc, 0x33, 0xac, 0x19, 0xaa, 0x9c, + 0x5e, 0x5a, 0xb3, 0x1c, 0x7a, 0xc6, 0x93, 0x3c, 0x1a, 0x0a, 0x79, 0x06, 0x5f, 0xa1, + 0xe0, 0x23, 0x7c, 0xd9, 0x0a, 0x13, 0xc7, 0xb7, 0x59, 0x98, 0x02, 0x62, 0x37, 0x8d, + 0x4a, 0x17, 0xb8, 0x5c, 0x18, 0x4f, 0x84, 0x76, 0x1e, 0x07, 0x1a, 0x97, 0x37, 0x84, + 0xb1, 0xc3, 0x0a, 0x93, 0x58, 0xb7, 0x6a, 0x7a, 0xf1, 0x07, 0x27, 0xf3, 0x69, 0x60, + 0xf2, 0x1c, 0x6e, 0x07, 0x8d, 0x33, 0xfb, 0x52, 0x83, 0x73, 0xa4, 0x36, 0xfb, 0x23, + 0x7f, 0x87, 0x31, 0x7b, 0x81, 0xc0, 0x49, 0x26, 0x24, 0x59, 0x82, 0xae, 0xa0, 0xb3, + 0x9c, 0x24, 0xa6, 0x7e, 0xff, 0xe6, 0x5a, 0x91, 0xb2, 0x11, 0xad, 0x73, 0x34, 0xf8, + 0xe4, 0x85, 0x8a, 0x3b, 0x7d, 0x0e, 0xf2, 0x1b, 0x3e, 0x44, 0x3c, 0x0c, 0xb6, 0x4e, + 0x08, 0x94, 0x08, 0x00, 0x6b, 0x10, 0x3f, 0x38, 0x41, 0xca, 0xb7, 0x0b, 0x04, 0x6b, + 0x98, 0xe2, 0xc8, 0xae, 0xd9, 0x4a, 0xd6, 0x83, 0x20, 0x8e, 0x26, 0x54, 0x24, 0xb0, + 0x77, 0x38, 0x9c, 0x2a, 0xc6, 0x57, 0x1f, 0x21, 0x6f, 0xac, 0x52, 0xe3, 0x5c, 0xd2, + 0x80, 0xe5, 0x1a, 0xaf, 0x66, 0x32, 0x81, 0x62, 0x04, 0xc8, 0x2a, 0x04, 0xf0, 0x9e, + 0x4f, 0xda, 0x88, 0x5d, 0xb3, 0x4f, 0xcc, 0x3b, 0xe3, 0xff, 0x41, 0xf9, 0x57, 0x00, + 0xe4, 0x59, 0x3b, 0xf8, 0x25, 0xf9, 0x3a, 0xb3, 0x04, 0x69, 0x73, 0x3d, 0x37, 0x3e, + 0x45, 0x0b, 0x12, 0x5d, 0xb2, 0x22, 0xab, 0x72, 0xf2, 0xad, 0xe9, 0x6d, 0xb3, 0x1f, + 0xee, 0x09, 0x3f, 0xcf, 0x25, 0x45, 0x11, 0x54, 0x7a, 0xc1, 0xca, 0x7e, 0x92, 0x67, + 0x78, 0xf1, 0x33, + ], + dk: [0x09; 32], + dk_pq: [ + 0xe4, 0xc1, 0x90, 0xb4, 0x1d, 0x18, 0xfe, 0x33, 0xb5, 0x71, 0x08, 0x19, 0xeb, 0x4a, + 0x96, 0x2a, 0x2a, 0x6a, 0xf9, 0xcd, 0x26, 0x63, 0xd9, 0x76, 0x6a, 0x48, 0x96, 0x48, + 0x1d, 0xcf, 0xc8, 0xb8, 0x96, 0x87, 0x08, 0x9a, 0x97, 0x97, 0xcf, 0x2f, 0x69, 0xd0, + 0x58, 0xdf, 0x1f, 0x69, 0x04, 0x41, 0xdb, 0xcc, 0xf3, 0xfa, 0xa9, 0x1e, 0xad, 0x65, + 0xb8, 0xd4, 0xdf, 0xad, 0xd6, 0xaa, 0x49, 0x12, + ], + dk_t: [ + 0x00, 0xee, 0x28, 0xdf, 0x5d, 0x85, 0x44, 0xc9, 0xea, 0x9a, 0x79, 0xba, 0xdc, 0xf9, + 0x95, 0xf4, 0x3a, 0xf9, 0x0e, 0xf2, 0x55, 0xb6, 0x4b, 0x6c, 0xa0, 0xc8, 0xd1, 0x94, + 0x52, 0x8f, 0x71, 0x52, + ], + ct: &[ + 0xa8, 0x57, 0xa7, 0x42, 0x5c, 0x60, 0x77, 0xda, 0xfa, 0xef, 0x13, 0x3c, 0x62, 0x86, + 0x9e, 0x52, 0x3a, 0x4b, 0x41, 0x11, 0x0c, 0xed, 0xed, 0xea, 0x6e, 0xe6, 0x6b, 0x9a, + 0x6b, 0xba, 0x63, 0x4d, 0x92, 0xcb, 0x41, 0xd5, 0xfb, 0xef, 0x2c, 0xcd, 0x6f, 0x5f, + 0x05, 0x79, 0x51, 0xfe, 0x1b, 0x44, 0xe2, 0x24, 0xcd, 0x23, 0x14, 0xc9, 0xff, 0xcd, + 0xf4, 0xc3, 0x58, 0x97, 0x9d, 0x6d, 0x06, 0x5f, 0x1f, 0x12, 0xa5, 0x10, 0x33, 0x64, + 0x0c, 0x07, 0x96, 0x5e, 0x6d, 0x43, 0x42, 0xaf, 0xd7, 0xb5, 0x7d, 0x52, 0x87, 0x86, + 0xb3, 0x98, 0xe1, 0x3b, 0x6e, 0xca, 0x58, 0x1b, 0x96, 0xfe, 0x77, 0x77, 0x8d, 0x73, + 0xbf, 0xa2, 0x42, 0x2e, 0x43, 0x09, 0x3f, 0x7c, 0x96, 0x43, 0x41, 0x03, 0xb1, 0x8c, + 0xbd, 0xf0, 0xaa, 0x65, 0x49, 0xda, 0x8e, 0x16, 0x9b, 0x66, 0xf4, 0x29, 0x21, 0xb8, + 0x9a, 0xc8, 0x26, 0x7d, 0xe3, 0x54, 0x46, 0x00, 0x89, 0x48, 0xd6, 0x02, 0x6a, 0x0b, + 0xcb, 0xe6, 0x13, 0x57, 0xe9, 0x7c, 0x7f, 0xe7, 0xa9, 0x53, 0x37, 0xdf, 0xa3, 0x17, + 0x7c, 0xa6, 0x16, 0x7c, 0x3a, 0x2a, 0xf8, 0xdc, 0x38, 0xe3, 0xd7, 0x08, 0x66, 0x58, + 0x24, 0xac, 0xf9, 0x7d, 0x6d, 0x7b, 0x15, 0x2b, 0xff, 0x78, 0x14, 0x51, 0xc5, 0x87, + 0xa2, 0x82, 0xad, 0xce, 0x03, 0x1b, 0x3e, 0xfa, 0x26, 0xb6, 0xd8, 0xbf, 0x4b, 0x49, + 0x73, 0x3c, 0x03, 0xdc, 0xc4, 0x30, 0x00, 0x76, 0x04, 0x9e, 0x27, 0x8d, 0x3c, 0xd8, + 0x72, 0x17, 0x4b, 0xc3, 0x74, 0xd7, 0x70, 0x38, 0xc7, 0x52, 0x03, 0xba, 0x45, 0xd3, + 0x0b, 0xd4, 0x11, 0x0b, 0x62, 0x34, 0x6c, 0x3f, 0x0b, 0xb1, 0xd8, 0x56, 0x3d, 0x0e, + 0x2d, 0x58, 0xca, 0xc8, 0x39, 0xfa, 0x69, 0x3c, 0xa9, 0x6a, 0x56, 0xee, 0xab, 0x1a, + 0xa4, 0xd2, 0x6c, 0xc9, 0x5e, 0x01, 0x36, 0x74, 0xee, 0xc4, 0xf8, 0xf0, 0x80, 0x95, + 0x05, 0x9f, 0x08, 0x1a, 0x0d, 0x4d, 0xfc, 0x07, 0x35, 0x65, 0x3f, 0x30, 0x97, 0xf1, + 0xa3, 0x7d, 0xa3, 0x34, 0x00, 0x70, 0x82, 0xba, 0x66, 0x19, 0x84, 0x45, 0x47, 0xe0, + 0xd3, 0x29, 0x66, 0x69, 0xee, 0xce, 0xb0, 0x2e, 0xcb, 0xf0, 0xc5, 0xc5, 0xa8, 0x8d, + 0x5d, 0x1c, 0x43, 0x23, 0x98, 0x36, 0x15, 0x29, 0xe0, 0xd9, 0x1a, 0x62, 0x8e, 0x56, + 0x8c, 0xd9, 0xa1, 0x8c, 0xb3, 0xe8, 0xca, 0x41, 0x31, 0x5c, 0xcb, 0xd8, 0xff, 0x9c, + 0xbb, 0xc0, 0x67, 0x71, 0x50, 0xf2, 0xe0, 0x62, 0x74, 0xec, 0x9e, 0x27, 0x33, 0xf3, + 0x11, 0x1c, 0xd4, 0xf1, 0xb9, 0x00, 0xc7, 0xa3, 0xa8, 0x0b, 0x51, 0x7a, 0x7d, 0x69, + 0x17, 0xfd, 0x07, 0x53, 0xf5, 0x9e, 0x8b, 0xf0, 0x32, 0x67, 0xe3, 0xa4, 0x3d, 0x60, + 0xe1, 0x85, 0x7d, 0x49, 0x22, 0xcd, 0x0f, 0x14, 0xb6, 0xd2, 0x86, 0x02, 0x79, 0x2d, + 0xbf, 0xe2, 0xb4, 0x48, 0x8e, 0x80, 0x70, 0x23, 0xff, 0x4a, 0x8b, 0x65, 0xf7, 0x5f, + 0xe1, 0xa0, 0x82, 0x6d, 0x5f, 0xf4, 0x90, 0xba, 0xc7, 0xbe, 0x07, 0x1b, 0x95, 0x45, + 0xf6, 0xe7, 0xee, 0x75, 0x8c, 0xaf, 0x46, 0x0e, 0x7e, 0x92, 0xe5, 0x2e, 0xb8, 0x3d, + 0xca, 0xfb, 0x5b, 0xed, 0xee, 0xcf, 0x44, 0xa5, 0xf5, 0xef, 0x23, 0x69, 0x0b, 0xd8, + 0x3a, 0xa5, 0xed, 0x2c, 0xe0, 0x42, 0x0c, 0x69, 0x7d, 0xfe, 0x4e, 0xae, 0xff, 0x5d, + 0x64, 0xbe, 0x78, 0xfd, 0x3d, 0x9c, 0x96, 0xf6, 0x6f, 0xcf, 0xbe, 0x01, 0x5d, 0x8a, + 0x1e, 0x75, 0xe9, 0x3e, 0xed, 0x73, 0x4c, 0x26, 0x7f, 0xa5, 0x15, 0x22, 0x0e, 0x99, + 0x37, 0xfd, 0xf8, 0xdf, 0x27, 0x1f, 0x69, 0xc8, 0xe3, 0xd6, 0xde, 0xc7, 0x61, 0x52, + 0x40, 0x4d, 0x86, 0x24, 0x34, 0x21, 0x1b, 0xd1, 0xe4, 0xb5, 0x3c, 0xb9, 0x95, 0x1c, + 0x48, 0xb7, 0x96, 0xfb, 0xf4, 0x28, 0x7d, 0x33, 0x86, 0xc6, 0x52, 0x17, 0xb4, 0x1f, + 0x2c, 0x41, 0x4d, 0xaa, 0xda, 0x20, 0x23, 0xc4, 0x3c, 0x08, 0xf8, 0xb6, 0xed, 0xbe, + 0xcc, 0x7f, 0x75, 0x09, 0x68, 0xc4, 0xf1, 0x6c, 0x3c, 0x98, 0x3a, 0x95, 0xd7, 0x3c, + 0x25, 0xd3, 0xcd, 0x4a, 0xac, 0x5b, 0xd5, 0x94, 0x1f, 0xa3, 0x76, 0xe1, 0x93, 0x44, + 0x36, 0xac, 0xec, 0xf9, 0xbb, 0x9b, 0xd4, 0x40, 0x9d, 0x09, 0x44, 0xd3, 0x93, 0xd8, + 0x52, 0xaa, 0x15, 0xd6, 0x36, 0x3b, 0xbd, 0x83, 0xcc, 0x24, 0xb1, 0xea, 0x84, 0x1e, + 0x00, 0xb9, 0x9d, 0xbe, 0x9f, 0x7b, 0x9f, 0xc2, 0xa4, 0x15, 0x06, 0x38, 0x65, 0xb4, + 0x3e, 0xcc, 0x9d, 0xb0, 0xa9, 0x53, 0x36, 0x82, 0x0d, 0x40, 0xec, 0x4d, 0x73, 0x25, + 0xd5, 0x06, 0x6e, 0xeb, 0x2a, 0x14, 0x4e, 0xd3, 0xc2, 0x7f, 0x50, 0x72, 0xc9, 0xa2, + 0xe5, 0x96, 0xd3, 0x95, 0xbd, 0x06, 0x9f, 0xdb, 0x88, 0x71, 0x52, 0x1a, 0x08, 0xd0, + 0xe9, 0xc1, 0x81, 0x04, 0x67, 0xa2, 0x71, 0xb4, 0x06, 0x7a, 0x54, 0xd9, 0xd8, 0x1e, + 0xca, 0x8f, 0x26, 0xd1, 0x8a, 0xcb, 0x41, 0xa7, 0xde, 0x59, 0x9a, 0xab, 0x1f, 0x79, + 0xdd, 0xd0, 0x12, 0x8c, 0x07, 0xe4, 0x4c, 0xf2, 0xcc, 0xef, 0x72, 0x36, 0x8c, 0xb4, + 0x47, 0x4d, 0xb4, 0x7e, 0xf4, 0x39, 0x17, 0x94, 0x0a, 0x80, 0xd0, 0x5a, 0xea, 0x5e, + 0x8c, 0x93, 0x3a, 0x0e, 0xf8, 0xa8, 0x51, 0x6a, 0x6d, 0xc2, 0xa5, 0x0d, 0xf2, 0x73, + 0x28, 0x8d, 0x97, 0xa9, 0x78, 0x86, 0x29, 0xf0, 0x01, 0xe4, 0x87, 0x43, 0x4e, 0x6a, + 0x41, 0x92, 0x46, 0x6e, 0x63, 0xf0, 0xe1, 0x85, 0x81, 0x06, 0x65, 0x26, 0x7a, 0x02, + 0x18, 0x96, 0x96, 0x7d, 0x83, 0x3c, 0x1f, 0x10, 0x86, 0x45, 0xa5, 0xd1, 0x73, 0x34, + 0xd5, 0xdd, 0xe8, 0xfd, 0x61, 0x7c, 0x78, 0x66, 0x65, 0xd7, 0xdf, 0x97, 0x62, 0xb8, + 0xec, 0x06, 0x76, 0xaf, 0x69, 0x7d, 0xca, 0x63, 0xe6, 0x2b, 0x59, 0x7a, 0xa2, 0xcf, + 0x89, 0xc5, 0x58, 0xac, 0xcc, 0x87, 0x2c, 0xe9, 0xa1, 0x27, 0x7f, 0x88, 0xc5, 0xac, + 0x16, 0x0b, 0x2d, 0x13, 0xa2, 0x7d, 0xe6, 0xb4, 0x02, 0x73, 0x53, 0xad, 0xc3, 0xbf, + 0x59, 0x6d, 0x3d, 0x65, 0x27, 0x53, 0x2e, 0x66, 0x22, 0x5f, 0xa5, 0x3e, 0x25, 0x46, + 0xf6, 0xce, 0xb2, 0x40, 0x43, 0x5b, 0xb9, 0x3d, 0x10, 0xe4, 0x67, 0x72, 0x08, 0xe9, + 0x90, 0xf6, 0x22, 0x27, 0x6d, 0x04, 0xab, 0x8f, 0x2e, 0x4c, 0xe2, 0xe5, 0x18, 0x0a, + 0x43, 0x6d, 0x33, 0xad, 0xbf, 0x29, 0xc2, 0xce, 0xf8, 0x70, 0x4a, 0x41, 0x07, 0x4e, + 0xd1, 0x6c, 0x16, 0x4f, 0xfc, 0xd1, 0xc8, 0xf0, 0x9a, 0x2f, 0x75, 0x2c, 0x09, 0x8c, + 0xaa, 0xb0, 0x9d, 0xa3, 0xdb, 0x75, 0xd8, 0x4c, 0xa5, 0x10, 0x54, 0x2c, 0x3a, 0xde, + 0xa1, 0x75, 0x7a, 0x55, 0x3b, 0xf5, 0x36, 0x57, 0xf0, 0x3f, 0xee, 0xc8, 0x03, 0x95, + 0x07, 0x47, 0xc8, 0xdd, 0xce, 0xeb, 0x31, 0xbd, 0x65, 0x80, 0x72, 0xf0, 0x1b, 0x79, + 0x72, 0xdf, 0x73, 0x1a, 0xf5, 0xff, 0x53, 0xbf, 0x8a, 0x83, 0x61, 0xcc, 0x91, 0x8c, + 0x6a, 0x00, 0x69, 0x31, 0x34, 0xfe, 0x6e, 0x38, 0x5c, 0xc7, 0x04, 0x84, 0xd2, 0xe3, + 0xe6, 0xd3, 0x65, 0xc1, 0x4f, 0xbe, 0x6e, 0x23, 0x32, 0xea, 0xf8, 0x6b, 0x7a, 0xfb, + 0x8d, 0xa6, 0x19, 0xdd, 0x4c, 0x13, 0xe8, 0x6f, 0x62, 0xed, 0x63, 0xda, 0x3b, 0x99, + 0x89, 0x5d, 0x6e, 0xe4, 0x7b, 0x44, 0x0e, 0x16, 0xa3, 0x61, 0x5f, 0x34, 0x1d, 0x4b, + 0xe4, 0x12, 0x39, 0x33, 0x6b, 0x02, 0x01, 0x74, 0x81, 0x96, 0x81, 0x73, 0x25, 0x03, + 0xf2, 0x75, 0xbf, 0x8b, 0xc4, 0x94, 0xc2, 0x51, 0xe5, 0x44, 0x8f, 0xf3, 0x2b, 0xff, + 0xb3, 0xfe, 0x07, 0x87, 0x48, 0x2b, 0x79, 0x6c, 0x37, 0xfd, 0x8d, 0x25, 0xa2, 0x8e, + 0xa7, 0x86, 0x20, 0x04, 0x6b, 0x19, 0x2c, 0xe4, 0x6f, 0xa4, 0xc7, 0x98, 0xc0, 0xfe, + 0xed, 0x18, 0x19, 0x61, 0x44, 0x13, 0x32, 0x6e, 0xb3, 0x73, 0xe6, 0x22, 0x83, 0x4a, + 0xfe, 0xaf, 0xf8, 0x1a, 0xff, 0x30, 0x8c, 0xaa, 0xf8, 0x35, 0x04, 0xd3, 0x1b, 0x98, + 0x98, 0xe8, 0x48, 0xb3, 0x96, 0xbc, 0x86, 0xcc, 0x55, 0xc5, 0x19, 0xf1, 0xa0, 0x11, + 0x25, 0x99, 0x53, 0x11, 0xba, 0x37, 0xd9, 0x6a, 0xa5, 0x9f, 0xf4, 0x64, 0xba, 0xf8, + 0x88, 0x5f, 0x3b, 0xdd, 0x10, 0xb1, 0xc9, 0x2f, 0x0b, 0x28, 0x69, 0x90, 0x04, 0x8d, + 0x58, 0x10, 0x5a, 0x7a, 0xb5, 0xec, 0x17, 0x55, 0x76, 0x3e, 0xcb, 0x4d, 0x20, 0xfd, + 0x18, 0x17, 0xd6, 0xb2, 0xfd, + ], + ss: [ + 0xa0, 0x07, 0x1e, 0x94, 0xb4, 0xd0, 0x27, 0x5e, 0xd9, 0x1d, 0xfe, 0x4f, 0x3f, 0xe8, + 0x7d, 0xd4, 0xa5, 0x34, 0x26, 0x9c, 0x7a, 0x59, 0x91, 0xfd, 0xc2, 0x7a, 0xc3, 0x19, + 0x33, 0xfa, 0xd2, 0x4c, + ], + }, +]; diff --git a/age/src/x25519.rs b/age/src/native/x25519.rs similarity index 96% rename from age/src/x25519.rs rename to age/src/native/x25519.rs index f686c9ff..2d717643 100644 --- a/age/src/x25519.rs +++ b/age/src/native/x25519.rs @@ -1,4 +1,4 @@ -//! The "x25519" recipient type, native to age. +//! The classic recipient type, native to age. use std::collections::HashSet; use std::fmt; @@ -26,10 +26,10 @@ const PUBLIC_KEY_PREFIX: &str = "age"; pub(super) const X25519_RECIPIENT_TAG: &str = "X25519"; const X25519_RECIPIENT_KEY_LABEL: &[u8] = b"age-encryption.org/v1/X25519"; -pub(super) const EPK_LEN_BYTES: usize = 32; -pub(super) const ENCRYPTED_FILE_KEY_BYTES: usize = FILE_KEY_BYTES + 16; +pub(crate) const EPK_LEN_BYTES: usize = 32; +pub(crate) const ENCRYPTED_FILE_KEY_BYTES: usize = FILE_KEY_BYTES + 16; -/// The standard age identity type, which can decrypt files encrypted to the corresponding +/// The classic age identity type, which can decrypt files encrypted to the corresponding /// [`Recipient`]. #[derive(Clone)] pub struct Identity(StaticSecret); @@ -141,7 +141,7 @@ impl crate::Identity for Identity { } } -/// The standard age recipient type. Files encrypted to this recipient can be decrypted +/// The classic age recipient type. Files encrypted to this recipient can be decrypted /// with the corresponding [`Identity`]. /// /// This recipient type is anonymous, in the sense that an attacker can't tell from the diff --git a/age/src/primitives/armor.rs b/age/src/primitives/armor.rs index 0a73ec4b..9873c5e3 100644 --- a/age/src/primitives/armor.rs +++ b/age/src/primitives/armor.rs @@ -1400,12 +1400,10 @@ mod tests { Poll::Pending => panic!("Unexpected Pending"), } } - loop { - match w.as_mut().poll_close(&mut cx) { - Poll::Ready(Ok(())) => break, - Poll::Ready(Err(e)) => panic!("Unexpected error: {}", e), - Poll::Pending => panic!("Unexpected Pending"), - } + match w.as_mut().poll_close(&mut cx) { + Poll::Ready(Ok(())) => (), + Poll::Ready(Err(e)) => panic!("Unexpected error: {}", e), + Poll::Pending => panic!("Unexpected Pending"), } } @@ -1554,12 +1552,10 @@ mod tests { Poll::Pending => panic!("Unexpected Pending"), } } - loop { - match w.as_mut().poll_close(&mut cx) { - Poll::Ready(Ok(())) => break, - Poll::Ready(Err(e)) => panic!("Unexpected error: {}", e), - Poll::Pending => panic!("Unexpected Pending"), - } + match w.as_mut().poll_close(&mut cx) { + Poll::Ready(Ok(())) => (), + Poll::Ready(Err(e)) => panic!("Unexpected error: {}", e), + Poll::Pending => panic!("Unexpected Pending"), } } diff --git a/age/src/primitives/stream.rs b/age/src/primitives/stream.rs index 652e79ce..3e419267 100644 --- a/age/src/primitives/stream.rs +++ b/age/src/primitives/stream.rs @@ -807,12 +807,10 @@ mod tests { Poll::Pending => panic!("Unexpected Pending"), } } - loop { - match w.as_mut().poll_close(&mut cx) { - Poll::Ready(Ok(())) => break, - Poll::Ready(Err(e)) => panic!("Unexpected error: {}", e), - Poll::Pending => panic!("Unexpected Pending"), - } + match w.as_mut().poll_close(&mut cx) { + Poll::Ready(Ok(())) => (), + Poll::Ready(Err(e)) => panic!("Unexpected error: {}", e), + Poll::Pending => panic!("Unexpected Pending"), } }; diff --git a/age/src/protocol.rs b/age/src/protocol.rs index d95b7965..c8692a88 100644 --- a/age/src/protocol.rs +++ b/age/src/protocol.rs @@ -388,12 +388,10 @@ mod tests { let f = e.wrap_async_output(&mut encrypted); pin_mut!(f); - loop { - match f.as_mut().poll(&mut cx) { - Poll::Ready(Ok(w)) => break w, - Poll::Ready(Err(e)) => panic!("Unexpected error: {}", e), - Poll::Pending => panic!("Unexpected Pending"), - } + match f.as_mut().poll(&mut cx) { + Poll::Ready(Ok(w)) => w, + Poll::Ready(Err(e)) => panic!("Unexpected error: {}", e), + Poll::Pending => panic!("Unexpected Pending"), } }; pin_mut!(w); @@ -407,12 +405,10 @@ mod tests { Poll::Pending => panic!("Unexpected Pending"), } } - loop { - match w.as_mut().poll_close(&mut cx) { - Poll::Ready(Ok(())) => break, - Poll::Ready(Err(e)) => panic!("Unexpected error: {}", e), - Poll::Pending => panic!("Unexpected Pending"), - } + match w.as_mut().poll_close(&mut cx) { + Poll::Ready(Ok(())) => (), + Poll::Ready(Err(e)) => panic!("Unexpected error: {}", e), + Poll::Pending => panic!("Unexpected Pending"), } } @@ -420,12 +416,10 @@ mod tests { let f = Decryptor::new_async(&encrypted[..]); pin_mut!(f); - loop { - match f.as_mut().poll(&mut cx) { - Poll::Ready(Ok(w)) => break w, - Poll::Ready(Err(e)) => panic!("Unexpected error: {}", e), - Poll::Pending => panic!("Unexpected Pending"), - } + match f.as_mut().poll(&mut cx) { + Poll::Ready(Ok(w)) => w, + Poll::Ready(Err(e)) => panic!("Unexpected error: {}", e), + Poll::Pending => panic!("Unexpected Pending"), } }; diff --git a/age/tests/testkit.rs b/age/tests/testkit.rs index d169087b..4c569f0e 100644 --- a/age/tests/testkit.rs +++ b/age/tests/testkit.rs @@ -1,3 +1,6 @@ +// To avoid a lint in the `test_case` macro. +#![allow(clippy::items_after_test_module)] + use std::{ fs::File, io::{self, BufRead, BufReader, Read}, diff --git a/rage/CHANGELOG.md b/rage/CHANGELOG.md index 9d5c7e1f..ce51c066 100644 --- a/rage/CHANGELOG.md +++ b/rage/CHANGELOG.md @@ -9,9 +9,13 @@ and this project adheres to Rust's notion of to 1.0.0 are beta releases. ## [Unreleased] +### Added +- Support for the new native age recipient types: + - `age1tag1..` + - `age1tagpq1..` ### Changed -- MSRV is now 1.70.0. +- MSRV is now 1.74.0. ## [0.6.1, 0.7.2, 0.8.2, 0.9.3, 0.10.1, 0.11.1] - 2024-12-18 ### Security diff --git a/rage/Cargo.toml b/rage/Cargo.toml index e31c7f92..18daff3b 100644 --- a/rage/Cargo.toml +++ b/rage/Cargo.toml @@ -163,3 +163,6 @@ bench = false name = "rage-mount" required-features = ["mount"] bench = false + +[lints] +workspace = true diff --git a/rage/src/bin/rage-mount/tar.rs b/rage/src/bin/rage-mount/tar.rs index 86de1c77..93c2e223 100644 --- a/rage/src/bin/rage-mount/tar.rs +++ b/rage/src/bin/rage-mount/tar.rs @@ -270,8 +270,7 @@ impl FilesystemMT for AgeTarFs { // Read bytes let to_read = usize::min(size as usize, (file_size - offset) as usize); - let mut buf = vec![]; - buf.resize(to_read, 0); + let mut buf = vec![0; to_read]; match inner.read_exact(&mut buf) { Ok(_) => callback(Ok(&buf)), Err(_) => callback(Err(libc::EIO)), diff --git a/rage/src/bin/rage-mount/zip.rs b/rage/src/bin/rage-mount/zip.rs index 9ffe1b14..2a294f7c 100644 --- a/rage/src/bin/rage-mount/zip.rs +++ b/rage/src/bin/rage-mount/zip.rs @@ -233,8 +233,7 @@ impl FilesystemMT for AgeZipFs { } // Skip to offset - let mut buf = vec![]; - buf.resize(offset as usize, 0); + let mut buf = vec![0; offset as usize]; if zf.read_exact(&mut buf).is_err() { return callback(Err(libc::EIO)); } diff --git a/rust-toolchain.toml b/rust-toolchain.toml index 5299106e..7737e53e 100644 --- a/rust-toolchain.toml +++ b/rust-toolchain.toml @@ -1,3 +1,3 @@ [toolchain] -channel = "1.70.0" +channel = "1.74.0" components = ["clippy", "rustfmt"] diff --git a/supply-chain/config.toml b/supply-chain/config.toml index 3f867f1a..31c3c44c 100644 --- a/supply-chain/config.toml +++ b/supply-chain/config.toml @@ -97,6 +97,10 @@ criteria = "safe-to-run" version = "0.3.73" criteria = "safe-to-run" +[[exemptions.base16ct]] +version = "0.2.0" +criteria = "safe-to-deploy" + [[exemptions.base64ct]] version = "1.6.0" criteria = "safe-to-deploy" @@ -217,6 +221,10 @@ criteria = "safe-to-run" version = "0.8.8" criteria = "safe-to-deploy" +[[exemptions.crypto-bigint]] +version = "0.5.5" +criteria = "safe-to-deploy" + [[exemptions.ctr]] version = "0.9.2" criteria = "safe-to-deploy" @@ -241,6 +249,10 @@ criteria = "safe-to-deploy" version = "0.9.0" criteria = "safe-to-deploy" +[[exemptions.elliptic-curve]] +version = "0.13.8" +criteria = "safe-to-deploy" + [[exemptions.encode_unicode]] version = "0.3.6" criteria = "safe-to-deploy" @@ -253,6 +265,10 @@ criteria = "safe-to-deploy" version = "0.10.2" criteria = "safe-to-deploy" +[[exemptions.ff]] +version = "0.13.1" +criteria = "safe-to-deploy" + [[exemptions.filetime]] version = "0.2.26" criteria = "safe-to-deploy" @@ -301,6 +317,10 @@ criteria = "safe-to-deploy" version = "0.5.1" criteria = "safe-to-deploy" +[[exemptions.group]] +version = "0.12.0" +criteria = "safe-to-deploy" + [[exemptions.hashbrown]] version = "0.16.1" criteria = "safe-to-deploy" @@ -313,6 +333,10 @@ criteria = "safe-to-deploy" version = "0.12.4" criteria = "safe-to-deploy" +[[exemptions.hpke]] +version = "0.12.0" +criteria = "safe-to-deploy" + [[exemptions.humantime]] version = "2.2.0" criteria = "safe-to-deploy" @@ -321,6 +345,10 @@ criteria = "safe-to-deploy" version = "1.1.1" criteria = "safe-to-run" +[[exemptions.hybrid-array]] +version = "0.2.0-rc.9" +criteria = "safe-to-deploy" + [[exemptions.i18n-config]] version = "0.4.8" criteria = "safe-to-deploy" @@ -361,6 +389,10 @@ criteria = "safe-to-deploy" version = "0.3.76" criteria = "safe-to-deploy" +[[exemptions.kem]] +version = "0.3.0-pre.0" +criteria = "safe-to-deploy" + [[exemptions.libc]] version = "0.2.179" criteria = "safe-to-deploy" @@ -389,6 +421,10 @@ criteria = "safe-to-deploy" version = "2.6.3" criteria = "safe-to-deploy" +[[exemptions.ml-kem]] +version = "0.2.1" +criteria = "safe-to-deploy" + [[exemptions.nix]] version = "0.26.1" criteria = "safe-to-deploy" @@ -433,6 +469,10 @@ criteria = "safe-to-run" version = "1.2.2" criteria = "safe-to-run" +[[exemptions.p256]] +version = "0.13.2" +criteria = "safe-to-deploy" + [[exemptions.page_size]] version = "0.5.0" criteria = "safe-to-deploy" @@ -493,6 +533,10 @@ criteria = "safe-to-run" version = "0.2.21" criteria = "safe-to-deploy" +[[exemptions.primeorder]] +version = "0.13.6" +criteria = "safe-to-deploy" + [[exemptions.proc-macro-crate]] version = "3.3.0" criteria = "safe-to-deploy" @@ -585,6 +629,10 @@ criteria = "safe-to-deploy" version = "0.11.0" criteria = "safe-to-deploy" +[[exemptions.sec1]] +version = "0.7.3" +criteria = "safe-to-deploy" + [[exemptions.secrecy]] version = "0.10.3" criteria = "safe-to-deploy" diff --git a/supply-chain/imports.lock b/supply-chain/imports.lock index ce11a6af..4237f114 100644 --- a/supply-chain/imports.lock +++ b/supply-chain/imports.lock @@ -2059,6 +2059,21 @@ who = "David Cook " criteria = "safe-to-deploy" version = "0.12.1" +[[audits.isrg.audits.keccak]] +who = "David Cook " +criteria = "safe-to-deploy" +version = "0.1.2" + +[[audits.isrg.audits.keccak]] +who = "Brandon Pitman " +criteria = "safe-to-deploy" +delta = "0.1.2 -> 0.1.3" + +[[audits.isrg.audits.keccak]] +who = "Brandon Pitman " +criteria = "safe-to-deploy" +delta = "0.1.3 -> 0.1.4" + [[audits.isrg.audits.num-integer]] who = "David Cook " criteria = "safe-to-deploy" @@ -2221,6 +2236,21 @@ who = "David Cook " criteria = "safe-to-deploy" delta = "0.10.8 -> 0.10.9" +[[audits.isrg.audits.sha3]] +who = "David Cook " +criteria = "safe-to-deploy" +version = "0.10.6" + +[[audits.isrg.audits.sha3]] +who = "Brandon Pitman " +criteria = "safe-to-deploy" +delta = "0.10.6 -> 0.10.7" + +[[audits.isrg.audits.sha3]] +who = "Brandon Pitman " +criteria = "safe-to-deploy" +delta = "0.10.7 -> 0.10.8" + [[audits.isrg.audits.subtle]] who = "David Cook " criteria = "safe-to-deploy" @@ -3296,6 +3326,18 @@ criteria = "safe-to-deploy" delta = "0.3.2 -> 0.3.3" aggregated-from = "https://raw.githubusercontent.com/zcash/librustzcash/main/supply-chain/audits.toml" +[[audits.zcash.audits.group]] +who = "Kris Nuttycombe " +criteria = "safe-to-deploy" +delta = "0.12.0 -> 0.12.1" +aggregated-from = "https://raw.githubusercontent.com/zcash/zcash/master/qa/supply-chain/audits.toml" + +[[audits.zcash.audits.group]] +who = "Sean Bowe " +criteria = "safe-to-deploy" +delta = "0.12.1 -> 0.13.0" +aggregated-from = "https://raw.githubusercontent.com/zcash/zcash/master/qa/supply-chain/audits.toml" + [[audits.zcash.audits.half]] who = "Daira-Emma Hopwood " criteria = "safe-to-run"