diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..e8ebd97 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,55 @@ +name: CI + +on: + push: + branches: [main] + pull_request: + branches: [main] + +env: + CARGO_TERM_COLOR: always + +jobs: + fmt: + name: cargo fmt + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - name: Install Rust toolchain + uses: dtolnay/rust-toolchain@stable + with: + components: rustfmt + - run: cargo fmt --all -- --check + + clippy: + name: cargo clippy + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - name: Install Rust toolchain + uses: dtolnay/rust-toolchain@stable + with: + components: clippy + - name: Install system dependencies + run: | + sudo apt-get update + sudo apt-get install -y libudev-dev libclang-dev + - uses: Swatinem/rust-cache@v2 + # Warnings are surfaced but not treated as errors yet; existing + # transport-core code triggers a number of clippy nits that will be + # cleaned up in follow-up commits. + - run: cargo clippy --workspace --all-targets + + test: + name: cargo test + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - name: Install Rust toolchain + uses: dtolnay/rust-toolchain@stable + - name: Install system dependencies + run: | + sudo apt-get update + sudo apt-get install -y libudev-dev libclang-dev + - uses: Swatinem/rust-cache@v2 + - run: cargo test --workspace diff --git a/.gitignore b/.gitignore index fbc9a58..f057f78 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,11 @@ .idea target -Cargo.lock + +# Editor / OS noise +.DS_Store +*.swp +*~ + +# Tooling scratch artifacts (e.g. download-ripgrepXXXXXX/) +download-ripgrep*/ +*.tmp diff --git a/Cargo.toml b/Cargo.toml index a501bfe..3e584d3 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -2,15 +2,18 @@ members = [ "trussed-mldsa", "authenticator", - "trussed-mlkem", - "pc-usbip-runner", "pc-hid-runner", "transport-core" ] resolver = "2" +[workspace.package] +edition = "2021" +license = "Apache-2.0 OR MIT" +authors = ["Feitian Technologies "] +repository = "https://github.com/FeitianTech/FidoSoftwareAuthenticator" +rust-version = "1.85" + [patch.crates-io] trussed = { git = "https://github.com/trussed-dev/trussed.git", rev = "024e0eca5fb7dbd2457831f7c7bffe4341e08775" } -usbip-device = { path = "patches/usbip-device" } -ssmarshal = { path = "patches/ssmarshal" } diff --git a/README.md b/README.md index 9d4fbc6..ce252d1 100644 --- a/README.md +++ b/README.md @@ -1,176 +1,136 @@ # FIDO Software Authenticator -Software authenticator implementing post-quantum ML-DSA 44/65/87 with a Trussed-based stack in Rust, using the liboqs library for ML-DSA algorithm implementations. The host runner provisions a virtual HID token through `/dev/uhid`, letting browsers and libfido2 talk to the authenticator without custom kernel modules. A legacy USB/IP transport remains available for environments that still need it. The project exposes a FIDO2/CTAP2 HID interface and CCID that browsers and tooling can use for WebAuthn. +A software-based FIDO2/WebAuthn authenticator written in Rust. It uses the +Trussed framework and provides **Post-Quantum Cryptography** signatures +(ML-DSA-44/65/87 per FIPS 204) alongside classical ES256, with no C +dependencies — the cryptography is entirely pure Rust via the +[`fips204`](https://docs.rs/fips204) crate. -Highlights -- Algorithms: ML-DSA 44/65/87, ES256. -- Transports: USB HID (CTAPHID) presented through `/dev/uhid`. Optional CCID smartcard interface for smartcard-style applications. -- Runner: Host UHID runner that creates a virtual hidraw node and bridges CTAPHID to Trussed. Optional USB/IP backend for legacy testing. +The application runs on a Linux host and provisions a virtual HID token +through `/dev/uhid`. Web browsers and tools like `libfido2` interact with it +as if it were a physical hardware security key — no custom kernel modules +required. -## Tech stack +### Key Features +* **Algorithms:** Post-quantum ML-DSA-44/65/87 (FIPS 204) and standard ES256. +* **Virtual Hardware:** Acts as a standard USB HID (CTAPHID) device via `/dev/uhid`. +* **Smartcard Support:** Optional CCID interface. +* **Pure-Rust crypto:** No C toolchain or prebuilt `liboqs` binaries required. -- Languages and FFI: Rust across the workspace crates, C via liboqs for ML-DSA and ML-KEM bindings consumed by `trussed-mldsa` and `trussed-mlkem`. -- Core crates: - - `authenticator` - Trussed application that implements CTAP2/CTAPHID and CCID flows on top of the PQC wrappers. - - `transport-core` - shared storage/state crate providing littlefs-backed persistence, attestation helpers, and CTAP/CCID glue code. - - `pc-hid-runner` - host runner exposing `/dev/uhid`. - - `pc-usbip-runner` (`trussed-usbip`) - legacy USB/IP transport kept for regression coverage. - - `trussed-mldsa` & `trussed-mlkem` - thin zeroise-aware wrappers around liboqs ML-DSA/ML-KEM exports. -- Key ecosystem crates: Trussed (patched to commit `024e0ec`), `ctaphid-dispatch`, `usbd-ctaphid`, `usbd-ccid`, `apdu-dispatch`, `littlefs2`, `ciborium`, `serde`, `rcgen`, `p256`, `chacha20`, `rand_chacha`, `nix`, `signal-hook`, `daemonize`, and `clap`. -- Tooling for validation: `libfido2`/`python-fido2` for host interoperability tests, and USB/IP utilities for the legacy backend. +--- -## Patches and runner tools +## Prerequisites -- Crate patches: - - `trussed` is pinned to upstream commit `024e0ec` for the Trussed features used by the authenticator stack. - - `usbip-device` is vendored under `patches/usbip-device` with fixes for packet sizing, speed reporting, and EP0 hygiene to stabilise the legacy USB/IP transport. - - `ssmarshal` lives under `patches/ssmarshal` to guarantee the `no_std` feature set and serde 1.0 compatibility relied on by `transport-core`. -- Runner tooling: - - `pc-hid-runner` offers `/dev/uhid`, foreground/background service modes, permission checks, and helpers aligned with the packaged `contrib/udev` rule and `systemd` service unit. - - `pc-usbip-runner (patch)` continues to expose the authenticator over USB/IP, with examples under `pc-usbip-runner/examples/` for CTAPHID and CCID exercise. +You will need a Linux host with Rust and a standard C toolchain installed. -## Project structure - -``` -. -|-- authenticator/ -| |-- Cargo.toml -| `-- src/ -| |-- ctap.rs -| |-- ctap/ -| | `-- tests.rs -| `-- lib.rs -|-- contrib/ -| |-- systemd/ -| | `-- feitian-authenticator.service -| `-- udev/ -| `-- 70-feitian-authenticator.rules -|-- download-ripgrepSCJSfZ/ -| `-- tmp-file -|-- patches/ -| |-- ssmarshal/ -| `-- usbip-device/ -|-- pc-hid-runner/ -| |-- Cargo.toml -| `-- src/ -| |-- bin/ -| | `-- authenticator.rs -| |-- cli.rs -| |-- lib.rs -| |-- permissions.rs -| |-- service.rs -| |-- transport/ -| | |-- ctaphid_host.rs -| | `-- mod.rs -| `-- uhid.rs -|-- pc-usbip-runner/ -| |-- Cargo.toml -| |-- Dockerfile -| |-- Makefile -| |-- README.md -| |-- examples/ -| `-- src/ -|-- prebuilt_liboqs/ -| |-- linux-aarch64/ -| | |-- include/oqs/ -| | `-- lib/ -| `-- linux-x86_64/ -| |-- include/oqs/ -| `-- lib/ -|-- target/ -| `-- ... (build artifacts) -|-- transport-core/ -| |-- Cargo.toml -| `-- src/ -| |-- ctap/ -| |-- lib.rs -| |-- logging.rs -| `-- state.rs -|-- trussed-mldsa/ -| |-- Cargo.toml -| |-- build.rs -| `-- src/lib.rs -|-- trussed-mlkem/ -| |-- Cargo.toml -| |-- build.rs -| `-- src/lib.rs -|-- Cargo.toml -`-- README.md -``` - -## Dependencies - -**System (Linux host)** -- Rust toolchain via `rustup` (2021 edition-compatible toolchain recommended). -- A C toolchain and binutils (`nm`) for linking against liboqs from `prebuilt_liboqs/`. -- Optional testing utilities: `libfido2-tools`, `python3-fido2`, and the USB/IP userspace (`usbip`, `vhci-hcd`) for exercising the legacy transport. -- Service integration helpers: `systemd` (to deploy `contrib/systemd/feitian-authenticator.service`) and udev (for `contrib/udev/70-feitian-authenticator.rules`). - -**Rust crates of note** -- Transport and protocol layers: `ctaphid-dispatch`, `usbd-ctaphid`, `usbd-ccid`, `apdu-dispatch`, `transport-core`. -- Storage and serialization: `littlefs2`, `littlefs2-core`, `ciborium`, vendored `ssmarshal`, `serde`. -- Host runner and orchestration: `nix`, `signal-hook`, `daemonize`, `clap`, `heapless-bytes`. -- Cryptography: `trussed` (patched), `trussed-mldsa`, `trussed-mlkem`, `p256`, `rcgen`, `sha2`, `chacha20`, `rand_chacha`, `zeroize`. - -Install (example on Ubuntu/Debian) +**Ubuntu/Debian Setup:** ```bash -# Rust (recommended): -curl https://sh.rustup.rs -sSf | sh +# 1. Install Rust (if you haven't already) +curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -# System packages: +# 2. Install required system packages sudo apt update sudo apt install -y build-essential pkg-config libclang-dev libudev-dev -# Optional testing and legacy-runner tools: +# (Optional) Install tools for testing sudo apt install -y libfido2-1 libfido2-dev libfido2-tools usbip python3-pip ``` -## Build -# At the repository root: -cargo build # Debug build -cargo build --release # Release build -``` - -## Select a liboqs bundle +--- -Prebuilt ML-DSA binaries are supplied under `prebuilt_liboqs/`. Choose the directory that matches your host architecture, then add the `lib` folder to your `LD_LIBRARY_PATH` (or install the contents under `/usr/local`): +## Quick Start +### 1. Build the Project +From the repository root, build the project using Cargo: ```bash -# For x86_64 Linux -export LD_LIBRARY_PATH="$PWD/prebuilt_liboqs/linux-x86_64/lib:${LD_LIBRARY_PATH:-}" - -# For aarch64 Linux -export LD_LIBRARY_PATH="$PWD/prebuilt_liboqs/linux-aarch64/lib:${LD_LIBRARY_PATH:-}" +cargo build --release ``` -If you build liboqs yourself, ensure the resulting shared library matches the target architecture of the runner binary. +The cryptography is pure Rust — there is no `liboqs` build step and nothing +to add to `LD_LIBRARY_PATH`. -## Run the HID runner +### 2. Setup Virtual HID Permissions +To allow the authenticator to create a virtual USB device, you need to load the `uhid` kernel module and grant your user the correct permissions. -The HID runner provisions a virtual authenticator through `/dev/uhid`, creating a `hidraw` node that browsers can use transparently. From the root of the repository: ```bash -# Starting with clean state -sudo pkill -f pc-hid-runner || true -sudo rmmod uhid 2>/dev/null || true +# Load the uhid module sudo modprobe uhid -# Configure permission +# Create a udev rule to grant access to the 'plugdev' group echo 'KERNEL=="uhid", MODE="0660", GROUP="plugdev"' | sudo tee /etc/udev/rules.d/70-uhid.rules sudo udevadm control --reload-rules sudo udevadm trigger + +# Apply permissions immediately sudo chown root:plugdev /dev/uhid sudo chmod 660 /dev/uhid newgrp plugdev +``` + +### 3. Run the Authenticator +Launch the virtual authenticator in the foreground. It will automatically +handle WebAuthn requests from your browser: -# Launching the runner -RUST_LOG=info cargo run -p pc-hid-runner -- start --foreground +```bash +RUST_LOG=info cargo run -p pc-hid-runner -- attach --foreground ``` -Useful flags: +`attach` and `detach` are the new primary verbs; the legacy `start` and +`stop` aliases continue to work. + +--- + +## CLI Reference + +The `pc-hid-runner` binary is the single management tool. Every subcommand +takes an optional `--state-dir ` (defaults to +`$XDG_DATA_HOME/feitian-mldsa-authenticator`). + +### Lifecycle + +| Command | Purpose | +|---------|---------| +| `pc-hid-runner attach [--foreground]` | Start the daemon and expose the virtual security key | +| `pc-hid-runner detach` | Stop a running daemon and remove the virtual device | +| `pc-hid-runner status` | Report whether the daemon is currently running | +| `pc-hid-runner reset [--yes]` | Wipe all credentials and PIN state (daemon must be detached) | + +### PIN management + +`pin` subcommands must be run with the daemon detached; the daemon reloads +the persisted PIN state on its next `attach`. + +| Command | Purpose | +|---------|---------| +| `pc-hid-runner pin status` | Show whether a PIN is set, retries remaining, and blocked state | +| `pc-hid-runner pin set [--pin ]` | Set a new PIN on a PIN-less device | +| `pc-hid-runner pin change [--current --new ]` | Change the existing PIN | +| `pc-hid-runner pin remove [--current ]` | Remove the PIN entirely | + +When `--pin` / `--current` / `--new` are omitted, the CLI reads the values +interactively from stdin. + +### Attach-time flags + +| Flag | Purpose | +|------|---------| +| `--foreground` | Run in the foreground (useful for systemd integration) | +| `--manual-user-presence` | Require manual approval rather than auto-approving user presence | +| `--suppress-attestation` | Hide attestation certificates for privacy testing | + +--- + +## Supported Algorithms + +The authenticator advertises all of the following COSE algorithms in +`authenticatorGetInfo` and will register and assert credentials against any +of them: -- `--state-dir ` — override the persistent storage directory (defaults to `$XDG_DATA_HOME/feitian-mldsa-authenticator`) -- `--manual-user-presence` — require manual approval of user presence (auto-UP remains the default) -- `--suppress-attestation` — mask attestation certs for privacy testing -- `--pqc-policy ` — choose the PQC PIN/UV transport policy +* `ES256` (-7) — classical NIST P-256 ECDSA +* `ML-DSA-44` (-48) — post-quantum, NIST level 2 +* `ML-DSA-65` (-49) — post-quantum, NIST level 3 +* `ML-DSA-87` (-50) — post-quantum, NIST level 5 -Omit `--foreground` to run the service as a background daemon. The CLI also exposes `status` and `stop` subcommands that inspect or terminate that daemonised instance. +PIN/UV uses the standard CTAP2.1 protocols (1 and 2). The authenticator +also handles `authenticatorReset` (CTAP command 0x07) so credentials can be +wiped over the wire if needed. diff --git a/authenticator/Cargo.toml b/authenticator/Cargo.toml index 7dccf27..8ccc388 100644 --- a/authenticator/Cargo.toml +++ b/authenticator/Cargo.toml @@ -3,8 +3,8 @@ name = "authenticator" version = "0.1.0" edition = "2021" -description = "Skeleton Trussed application demonstrating ML‑DSA integration" -authors = ["Your Name "] +description = "FIDO2/CTAP2 authenticator core with post-quantum ML-DSA support" +authors = ["Feitian Technologies "] license = "Apache-2.0 OR MIT" [dependencies] @@ -12,7 +12,6 @@ trussed = "0.1.0" ciborium = { version = "0.2", default-features = false } heapless = "0.7" littlefs2 = "0.4" -aes-gcm = "0.10" aes = "0.8" cbc = { version = "0.1", features = ["alloc"] } hkdf = "0.12" @@ -27,10 +26,9 @@ rand_core = "0.6" log = { version = "0.4", default-features = false } transport-core = { path = "../transport-core", default-features = false } -# Use our local wrapper for ML‑DSA. By enabling all parameter set features the -# wrapper links to the stub C implementation for 44/65/87. +# Use our local wrapper for ML-DSA. By enabling all parameter set features the +# wrapper links to the underlying ML-DSA implementation for 44/65/87. trussed-mldsa = { path = "../trussed-mldsa", features = ["mldsa44", "mldsa65", "mldsa87"] } -trussed-mlkem = { path = "../trussed-mlkem", features = ["mlkem512", "mlkem768", "mlkem1024"] } [dev-dependencies] serial_test = "2" \ No newline at end of file diff --git a/authenticator/src/ctap.rs b/authenticator/src/ctap.rs index 5b406fa..96643ed 100644 --- a/authenticator/src/ctap.rs +++ b/authenticator/src/ctap.rs @@ -1,8 +1,7 @@ use crate::{ - cose_akp_key_map, cose_alg_for_kem_param_set, create_credential, credential_secret_from_bytes, - decrypt_classic_pin_block, decrypt_pqc_pin_block, derive_classic_pin_uv_session_keys, - derive_pqc_pin_uv_session_keys, encrypt_classic_pin_block, encrypt_pqc_pin_block, - sign_challenge, ClassicPinProtocol, CoseAlg, PinUvSessionKeys, PIN_UV_AUTH_PROTOCOL_PQC, + create_credential, credential_secret_from_bytes, decrypt_classic_pin_block, + derive_classic_pin_uv_session_keys, encrypt_classic_pin_block, sign_challenge, + ClassicPinProtocol, CoseAlg, PinUvSessionKeys, }; use aes::Aes256; @@ -33,7 +32,6 @@ use trussed::try_syscall; use trussed::types::consent; #[cfg(not(test))] use trussed::types::{Location, Message, PathBuf}; -use trussed_mlkem::{self, Ciphertext, ParamSet as KemParamSet, SecretKey as KemSecretKey}; use zeroize::Zeroize; use transport_core::{ctap::constants::*, logging::HexOption}; @@ -194,20 +192,16 @@ const COSE_ALG_ES256: i32 = -7; const CREDENTIAL_STORE_PATH: &str = "credentials.cbor"; #[cfg(not(test))] const ATTESTATION_STORE_PATH: &str = "attestation.cbor"; -const PIN_UV_AUTH_PROTOCOL_CLASSIC_V1: i32 = 1; -const PIN_UV_AUTH_PROTOCOL_CLASSIC_V2: i32 = 2; +#[cfg(not(test))] +const PIN_STATE_STORE_PATH: &str = "pin-state.cbor"; +pub(crate) const PIN_UV_AUTH_PROTOCOL_CLASSIC_V1: i32 = 1; +pub(crate) const PIN_UV_AUTH_PROTOCOL_CLASSIC_V2: i32 = 2; #[cfg_attr(not(test), allow(dead_code))] -const PIN_UV_AUTH_PROTOCOL_CLASSIC: i32 = PIN_UV_AUTH_PROTOCOL_CLASSIC_V2; -const PIN_UV_PROTOCOLS_PREFER: [i32; 3] = [ - PIN_UV_AUTH_PROTOCOL_PQC as i32, - PIN_UV_AUTH_PROTOCOL_CLASSIC_V2, - PIN_UV_AUTH_PROTOCOL_CLASSIC_V1, -]; -const PIN_UV_PROTOCOLS_CLASSIC: [i32; 2] = [ +pub(crate) const PIN_UV_AUTH_PROTOCOL_CLASSIC: i32 = PIN_UV_AUTH_PROTOCOL_CLASSIC_V2; +const PIN_UV_PROTOCOLS_SUPPORTED: [i32; 2] = [ PIN_UV_AUTH_PROTOCOL_CLASSIC_V2, PIN_UV_AUTH_PROTOCOL_CLASSIC_V1, ]; -const PIN_UV_PROTOCOLS_PQC_ONLY: [i32; 1] = [PIN_UV_AUTH_PROTOCOL_PQC as i32]; const PIN_PERMISSION_MC: u8 = 0x01; const PIN_PERMISSION_GA: u8 = 0x02; @@ -250,6 +244,28 @@ struct PinState { pin_uv_auth_rp_provided: bool, } +/// On-disk representation of the persistent PIN state. Kept in sync with +/// `transport-core::state::StoredPinState` so the CLI can read and write the +/// same `pin-state.cbor` file the daemon uses. +#[derive(Debug, Clone, Serialize, Deserialize)] +struct StoredPinState { + pin_hash: Option<[u8; 16]>, + pin_retries: u8, + consecutive_failures: u8, + pin_auth_blocked: bool, +} + +impl StoredPinState { + fn snapshot(state: &PinState) -> Self { + Self { + pin_hash: state.pin_hash, + pin_retries: state.pin_retries, + consecutive_failures: state.consecutive_failures, + pin_auth_blocked: state.pin_auth_blocked, + } + } +} + impl PinState { const MIN_PIN_LENGTH: usize = 4; @@ -266,6 +282,19 @@ impl PinState { } } + fn from_stored(stored: StoredPinState) -> Self { + Self { + pin_hash: stored.pin_hash, + pin_retries: stored.pin_retries, + consecutive_failures: stored.consecutive_failures, + pin_auth_blocked: stored.pin_auth_blocked, + pin_uv_auth_token: None, + pin_uv_auth_permissions: 0, + pin_uv_auth_rp_id: None, + pin_uv_auth_rp_provided: false, + } + } + fn is_set(&self) -> bool { self.pin_hash.is_some() } @@ -459,188 +488,109 @@ struct HmacSecretRequest { protocol: PinProtocol, } -#[derive(Copy, Clone, PartialEq, Eq)] -enum PinProtocol { - Pqc, - Classic(ClassicPinProtocol), -} +pub(crate) type PinProtocol = ClassicPinProtocol; -impl PinProtocol { - fn from_identifier(value: i128) -> Result { - if value == i128::from(PIN_UV_AUTH_PROTOCOL_PQC) { - Ok(PinProtocol::Pqc) - } else if value == i128::from(PIN_UV_AUTH_PROTOCOL_CLASSIC_V1) { - Ok(PinProtocol::Classic(ClassicPinProtocol::V1)) - } else if value == i128::from(PIN_UV_AUTH_PROTOCOL_CLASSIC_V2) { - Ok(PinProtocol::Classic(ClassicPinProtocol::V2)) - } else { - Err(CTAP2_ERR_PIN_AUTH_INVALID) - } +fn pin_protocol_from_identifier(value: i128) -> Result { + if value == i128::from(PIN_UV_AUTH_PROTOCOL_CLASSIC_V1) { + Ok(ClassicPinProtocol::V1) + } else if value == i128::from(PIN_UV_AUTH_PROTOCOL_CLASSIC_V2) { + Ok(ClassicPinProtocol::V2) + } else { + Err(CTAP2_ERR_PIN_AUTH_INVALID) } } -enum PinProtocolSession { - Pqc { - param_set: KemParamSet, - secret_key: KemSecretKey, - public_key: Vec, - }, - Classic { - protocol: ClassicPinProtocol, - public_key: EncodedPoint, - secret_key: P256SecretKey, - }, +struct PinProtocolSession { + protocol: ClassicPinProtocol, + public_key: EncodedPoint, + secret_key: P256SecretKey, } impl PinProtocolSession { fn protocol(&self) -> PinProtocol { - match self { - PinProtocolSession::Pqc { .. } => PinProtocol::Pqc, - PinProtocolSession::Classic { protocol, .. } => PinProtocol::Classic(*protocol), - } + self.protocol } fn key_agreement_value(&self) -> Value { - match self { - PinProtocolSession::Pqc { - param_set, - public_key, - .. - } => { - let alg = cose_alg_for_kem_param_set(*param_set); - cose_akp_key_map(alg, public_key) - } - PinProtocolSession::Classic { public_key, .. } => { - let (x, y) = match (public_key.x(), public_key.y()) { - (Some(x_bytes), Some(y_bytes)) => (x_bytes.to_vec(), y_bytes.to_vec()), - _ => (Vec::new(), Vec::new()), - }; - canonical_map(vec![ - ( - Value::Integer(Integer::from(1)), - Value::Integer(Integer::from(2)), - ), - ( - Value::Integer(Integer::from(3)), - Value::Integer(Integer::from(-25)), - ), - ( - Value::Integer(Integer::from(-1)), - Value::Integer(Integer::from(1)), - ), - (Value::Integer(Integer::from(-2)), Value::Bytes(x)), - (Value::Integer(Integer::from(-3)), Value::Bytes(y)), - ]) - } - } + let (x, y) = match (self.public_key.x(), self.public_key.y()) { + (Some(x_bytes), Some(y_bytes)) => (x_bytes.to_vec(), y_bytes.to_vec()), + _ => (Vec::new(), Vec::new()), + }; + canonical_map(vec![ + ( + Value::Integer(Integer::from(1)), + Value::Integer(Integer::from(2)), + ), + ( + Value::Integer(Integer::from(3)), + Value::Integer(Integer::from(-25)), + ), + ( + Value::Integer(Integer::from(-1)), + Value::Integer(Integer::from(1)), + ), + (Value::Integer(Integer::from(-2)), Value::Bytes(x)), + (Value::Integer(Integer::from(-3)), Value::Bytes(y)), + ]) } fn derive_session_keys( self, platform_key: &[(Value, Value)], ) -> Result<(PinUvSessionKeys, Vec), u8> { - match self { - PinProtocolSession::Pqc { - param_set, - secret_key, - public_key, - } => { - let Some(ciphertext_bytes) = platform_key - .iter() - .find(|(k, _)| *k == Value::Integer(Integer::from(-2))) - .and_then(|(_, v)| match v { - Value::Bytes(bytes) => Some(bytes.clone()), - _ => None, - }) - else { - return Err(CTAP1_ERR_INVALID_PARAMETER); - }; - let ciphertext = Ciphertext(ciphertext_bytes.clone()); - let shared = trussed_mlkem::decapsulate(param_set, &secret_key, &ciphertext) - .map_err(|_| CTAP1_ERR_INVALID_PARAMETER)?; - let mut hasher = Sha256::new(); - hasher.update(&public_key); - hasher.update(&ciphertext_bytes); - let transcript_hash = hasher.finalize().to_vec(); - let keys = derive_pqc_pin_uv_session_keys(&shared.0, &transcript_hash); - Ok((keys, transcript_hash)) - } - PinProtocolSession::Classic { - protocol, - public_key, - secret_key, - } => { - let Some(peer_x) = platform_key - .iter() - .find(|(k, _)| *k == Value::Integer(Integer::from(-2))) - .and_then(|(_, v)| match v { - Value::Bytes(bytes) => Some(bytes.clone()), - _ => None, - }) - else { - return Err(CTAP1_ERR_INVALID_PARAMETER); - }; - let Some(peer_y) = platform_key - .iter() - .find(|(k, _)| *k == Value::Integer(Integer::from(-3))) - .and_then(|(_, v)| match v { - Value::Bytes(bytes) => Some(bytes.clone()), - _ => None, - }) - else { - return Err(CTAP1_ERR_INVALID_PARAMETER); - }; - if peer_x.len() != 32 || peer_y.len() != 32 { - return Err(CTAP1_ERR_INVALID_PARAMETER); - } - - let mut peer_encoded = [0u8; 65]; - peer_encoded[0] = 0x04; - peer_encoded[1..33].copy_from_slice(&peer_x); - peer_encoded[33..65].copy_from_slice(&peer_y); - - let peer_public = P256PublicKey::from_sec1_bytes(&peer_encoded) - .map_err(|_| CTAP1_ERR_INVALID_PARAMETER)?; - let shared = - diffie_hellman(secret_key.to_nonzero_scalar(), peer_public.as_affine()); - - let auth_public_bytes = public_key.as_bytes(); - let mut hasher = Sha256::new(); - hasher.update(auth_public_bytes); - hasher.update(&peer_encoded); - let transcript_hash = hasher.finalize().to_vec(); - - let shared_bytes = shared.raw_secret_bytes(); - let keys = derive_classic_pin_uv_session_keys(protocol, shared_bytes.as_ref()); - Ok((keys, transcript_hash)) - } + let Some(peer_x) = platform_key + .iter() + .find(|(k, _)| *k == Value::Integer(Integer::from(-2))) + .and_then(|(_, v)| match v { + Value::Bytes(bytes) => Some(bytes.clone()), + _ => None, + }) + else { + return Err(CTAP1_ERR_INVALID_PARAMETER); + }; + let Some(peer_y) = platform_key + .iter() + .find(|(k, _)| *k == Value::Integer(Integer::from(-3))) + .and_then(|(_, v)| match v { + Value::Bytes(bytes) => Some(bytes.clone()), + _ => None, + }) + else { + return Err(CTAP1_ERR_INVALID_PARAMETER); + }; + if peer_x.len() != 32 || peer_y.len() != 32 { + return Err(CTAP1_ERR_INVALID_PARAMETER); } - } -} -#[cfg(test)] -mod tests; + let mut peer_encoded = [0u8; 65]; + peer_encoded[0] = 0x04; + peer_encoded[1..33].copy_from_slice(&peer_x); + peer_encoded[33..65].copy_from_slice(&peer_y); -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -pub enum PqcPolicy { - PreferPqc, - ClassicOnly, - RequirePqc, -} + let peer_public = P256PublicKey::from_sec1_bytes(&peer_encoded) + .map_err(|_| CTAP1_ERR_INVALID_PARAMETER)?; + let shared = diffie_hellman(self.secret_key.to_nonzero_scalar(), peer_public.as_affine()); -impl Default for PqcPolicy { - fn default() -> Self { - Self::PreferPqc + let auth_public_bytes = self.public_key.as_bytes(); + let mut hasher = Sha256::new(); + hasher.update(auth_public_bytes); + hasher.update(&peer_encoded); + let transcript_hash = hasher.finalize().to_vec(); + + let shared_bytes = shared.raw_secret_bytes(); + let keys = derive_classic_pin_uv_session_keys(self.protocol, shared_bytes.as_ref()); + Ok((keys, transcript_hash)) } } +#[cfg(test)] +mod tests; + pub struct CtapApp { client: C, aaguid: [u8; 16], pin_state: PinState, pin_protocol_session: Option, - platform_declined_pqc: bool, - pqc_policy: PqcPolicy, suppress_attestation: bool, cred_mgmt_state: CredentialManagementState, pending_assertion: Option, @@ -659,13 +609,11 @@ where C: TrussedClient + FilesystemClient + CryptoClient, { pub fn new(client: C, aaguid: [u8; 16]) -> Self { - let app = Self { + let mut app = Self { client, aaguid, pin_state: PinState::new(), pin_protocol_session: None, - platform_declined_pqc: false, - pqc_policy: PqcPolicy::default(), suppress_attestation: false, cred_mgmt_state: CredentialManagementState::new(), pending_assertion: None, @@ -678,6 +626,7 @@ where #[cfg(test)] stored_credentials: Vec::new(), }; + app.load_persistent_pin_state(); app } @@ -689,24 +638,15 @@ where self.auto_user_presence = enabled; } - pub fn set_pqc_policy(&mut self, policy: PqcPolicy) { - self.pqc_policy = policy; - self.platform_declined_pqc = matches!(policy, PqcPolicy::ClassicOnly); - } - pub fn suppress_attestation(&mut self, suppress: bool) { self.suppress_attestation = suppress; } fn supported_pin_uv_protocols(&self) -> &'static [i32] { - match self.pqc_policy { - PqcPolicy::PreferPqc => &PIN_UV_PROTOCOLS_PREFER, - PqcPolicy::ClassicOnly => &PIN_UV_PROTOCOLS_CLASSIC, - PqcPolicy::RequirePqc => &PIN_UV_PROTOCOLS_PQC_ONLY, - } + &PIN_UV_PROTOCOLS_SUPPORTED } fn verify_pin_auth( - protocol: PinProtocol, + _protocol: PinProtocol, keys: &PinUvSessionKeys, data: &[u8], provided: &[u8], @@ -715,49 +655,24 @@ where HmacSha256::new_from_slice(&keys.auth_key).map_err(|_| CTAP2_ERR_PROCESSING)?; mac.update(data); let result = mac.finalize().into_bytes(); - match protocol { - PinProtocol::Classic(ClassicPinProtocol::V1) - | PinProtocol::Classic(ClassicPinProtocol::V2) => { - if provided.len() != 16 { - return Err(CTAP2_ERR_PIN_AUTH_INVALID); - } - if result[..16] == provided[..16] { - Ok(()) - } else { - Err(CTAP2_ERR_PIN_AUTH_INVALID) - } - } - PinProtocol::Pqc => { - if provided.len() != 32 { - return Err(CTAP2_ERR_PIN_AUTH_INVALID); - } - if result[..] == provided[..] { - Ok(()) - } else { - Err(CTAP2_ERR_PIN_AUTH_INVALID) - } - } + if provided.len() != 16 { + return Err(CTAP2_ERR_PIN_AUTH_INVALID); + } + if result[..16] == provided[..16] { + Ok(()) + } else { + Err(CTAP2_ERR_PIN_AUTH_INVALID) } } fn decrypt_pin_block_checked( protocol: PinProtocol, keys: &PinUvSessionKeys, - transcript_hash: &[u8], + _transcript_hash: &[u8], ciphertext: &[u8], ) -> Result, u8> { - match protocol { - PinProtocol::Pqc => { - if ciphertext.len() < 16 { - return Err(CTAP1_ERR_INVALID_PARAMETER); - } - let nonce = [0u8; 12]; - decrypt_pqc_pin_block(keys, &nonce, ciphertext, transcript_hash) - .map_err(|_| CTAP2_ERR_PIN_AUTH_INVALID) - } - PinProtocol::Classic(classic) => decrypt_classic_pin_block(classic, keys, ciphertext) - .map_err(|_| CTAP2_ERR_PIN_AUTH_INVALID), - } + decrypt_classic_pin_block(protocol, keys, ciphertext) + .map_err(|_| CTAP2_ERR_PIN_AUTH_INVALID) } fn extract_new_pin(plaintext: &mut [u8]) -> Result, u8> { @@ -800,6 +715,62 @@ where } } + /// Load the persistent PIN state from `pin-state.cbor` on the internal + /// filesystem if one exists. Missing or unreadable files leave the + /// in-memory state at its defaults. + #[cfg(not(test))] + fn load_persistent_pin_state(&mut self) { + let path = match PathBuf::try_from(PIN_STATE_STORE_PATH) { + Ok(p) => p, + Err(_) => return, + }; + let reply = match try_syscall!(self.client.read_file(Location::Internal, path)) { + Ok(reply) => reply, + Err(_) => return, + }; + let data = reply.data.as_slice(); + if data.is_empty() { + return; + } + match from_reader::(data) { + Ok(stored) => { + self.pin_state = PinState::from_stored(stored); + } + Err(_) => { + log::warn!("pin-state.cbor is unreadable; starting with defaults"); + } + } + } + + #[cfg(test)] + fn load_persistent_pin_state(&mut self) {} + + /// Persist the current PIN state. Called after every CTAP handler that + /// can mutate the PIN/retries/lockout fields so the CLI and the next + /// daemon attach observe a consistent view. + #[cfg(not(test))] + fn save_persistent_pin_state(&mut self) { + let path = match PathBuf::try_from(PIN_STATE_STORE_PATH) { + Ok(p) => p, + Err(_) => return, + }; + let stored = StoredPinState::snapshot(&self.pin_state); + let mut encoded = Vec::new(); + if into_writer(&stored, &mut encoded).is_err() { + return; + } + let message = match Message::from_slice(&encoded) { + Ok(m) => m, + Err(_) => return, + }; + let _ = try_syscall!(self + .client + .write_file(Location::Internal, path, message, None)); + } + + #[cfg(test)] + fn save_persistent_pin_state(&mut self) {} + fn as_array(bytes: &[u8]) -> Result<[u8; N], u8> { if bytes.len() != N { return Err(CTAP1_ERR_INVALID_PARAMETER); @@ -882,41 +853,12 @@ where if let Some(Value::Integer(int)) = Self::map_get(map, Value::Integer(Integer::from(1))) { let value: i128 = int.clone().into(); match value { - v if v == i128::from(PIN_UV_AUTH_PROTOCOL_PQC) => { - if matches!(self.pqc_policy, PqcPolicy::ClassicOnly) { - return Err(CTAP1_ERR_INVALID_PARAMETER); - } - self.platform_declined_pqc = false; - Ok(PinProtocol::Pqc) - } - v if v == i128::from(PIN_UV_AUTH_PROTOCOL_CLASSIC_V2) => { - if matches!(self.pqc_policy, PqcPolicy::RequirePqc) { - return Err(CTAP1_ERR_INVALID_PARAMETER); - } - self.platform_declined_pqc = true; - Ok(PinProtocol::Classic(ClassicPinProtocol::V2)) - } - v if v == i128::from(PIN_UV_AUTH_PROTOCOL_CLASSIC_V1) => { - if matches!(self.pqc_policy, PqcPolicy::RequirePqc) { - return Err(CTAP1_ERR_INVALID_PARAMETER); - } - self.platform_declined_pqc = true; - Ok(PinProtocol::Classic(ClassicPinProtocol::V1)) - } + v if v == i128::from(PIN_UV_AUTH_PROTOCOL_CLASSIC_V2) => Ok(ClassicPinProtocol::V2), + v if v == i128::from(PIN_UV_AUTH_PROTOCOL_CLASSIC_V1) => Ok(ClassicPinProtocol::V1), _ => Err(CTAP1_ERR_INVALID_PARAMETER), } } else { - match self.pqc_policy { - PqcPolicy::PreferPqc => { - if self.platform_declined_pqc { - Ok(PinProtocol::Classic(ClassicPinProtocol::V2)) - } else { - Ok(PinProtocol::Pqc) - } - } - PqcPolicy::ClassicOnly => Ok(PinProtocol::Classic(ClassicPinProtocol::V2)), - PqcPolicy::RequirePqc => Ok(PinProtocol::Pqc), - } + Ok(ClassicPinProtocol::V2) } } @@ -932,35 +874,22 @@ where } fn client_pin_get_key_agreement(&mut self, protocol: PinProtocol) -> Result, u8> { - let session = match protocol { - PinProtocol::Pqc => { - let param_set = KemParamSet::MLKEM512; - let (public_key, secret_key) = trussed_mlkem::keypair(param_set); - PinProtocolSession::Pqc { - param_set, - secret_key, - public_key: public_key.0.clone(), - } + let secret_key = loop { + let bytes = syscall!(self.client.random_bytes(32)).bytes; + if bytes.len() != 32 { + continue; } - PinProtocol::Classic(classic_protocol) => { - let secret_key = loop { - let bytes = syscall!(self.client.random_bytes(32)).bytes; - if bytes.len() != 32 { - continue; - } - match P256SecretKey::from_slice(bytes.as_slice()) { - Ok(secret) => break secret, - Err(_) => continue, - } - }; - let public_key = secret_key.public_key().to_encoded_point(false); - PinProtocolSession::Classic { - protocol: classic_protocol, - public_key, - secret_key, - } + match P256SecretKey::from_slice(bytes.as_slice()) { + Ok(secret) => break secret, + Err(_) => continue, } }; + let public_key = secret_key.public_key().to_encoded_point(false); + let session = PinProtocolSession { + protocol, + public_key, + secret_key, + }; let mut key_map = session.key_agreement_value(); if let Value::Map(mut entries) = key_map { canonical_sort(&mut entries); @@ -1006,6 +935,7 @@ where let hash = Self::hash_pin(&new_pin); new_pin.zeroize(); self.pin_state.set_pin(hash); + self.save_persistent_pin_state(); Ok(vec![CTAP2_OK]) } @@ -1046,6 +976,7 @@ where let current_hash = Self::as_array::<16>(¤t_plain)?; current_plain.zeroize(); if let Err(err) = self.pin_state.verify_pin_hash(¤t_hash) { + self.save_persistent_pin_state(); return Err(err); } @@ -1055,6 +986,7 @@ where let hash = Self::hash_pin(&new_pin); new_pin.zeroize(); self.pin_state.set_pin(hash); + self.save_persistent_pin_state(); Ok(vec![CTAP2_OK]) } @@ -1093,8 +1025,10 @@ where let current_hash = Self::as_array::<16>(&plain)?; plain.zeroize(); if let Err(err) = self.pin_state.verify_pin_hash(¤t_hash) { + self.save_persistent_pin_state(); return Err(err); } + self.save_persistent_pin_state(); let random = syscall!(self.client.random_bytes(32)).bytes; if random.len() != 32 { @@ -1103,26 +1037,20 @@ where let mut token = [0u8; 32]; token.copy_from_slice(random.as_slice()); let encrypted = match protocol { - PinProtocol::Pqc => { - let nonce = [0u8; 12]; - encrypt_pqc_pin_block(&keys, &nonce, &token, &transcript_hash) + ClassicPinProtocol::V1 => { + encrypt_classic_pin_block(ClassicPinProtocol::V1, &keys, None, &token) + .map_err(|_| CTAP2_ERR_PROCESSING)? } - PinProtocol::Classic(classic_protocol) => match classic_protocol { - ClassicPinProtocol::V1 => { - encrypt_classic_pin_block(ClassicPinProtocol::V1, &keys, None, &token) - .map_err(|_| CTAP2_ERR_PROCESSING)? - } - ClassicPinProtocol::V2 => { - let iv_bytes = syscall!(self.client.random_bytes(16)).bytes; - if iv_bytes.len() != 16 { - return Err(CTAP2_ERR_PROCESSING); - } - let mut iv = [0u8; 16]; - iv.copy_from_slice(iv_bytes.as_slice()); - encrypt_classic_pin_block(ClassicPinProtocol::V2, &keys, Some(&iv), &token) - .map_err(|_| CTAP2_ERR_PROCESSING)? + ClassicPinProtocol::V2 => { + let iv_bytes = syscall!(self.client.random_bytes(16)).bytes; + if iv_bytes.len() != 16 { + return Err(CTAP2_ERR_PROCESSING); } - }, + let mut iv = [0u8; 16]; + iv.copy_from_slice(iv_bytes.as_slice()); + encrypt_classic_pin_block(ClassicPinProtocol::V2, &keys, Some(&iv), &token) + .map_err(|_| CTAP2_ERR_PROCESSING)? + } }; self.pin_state .set_pin_uv_auth_token(token, permissions, rp_id); @@ -1309,6 +1237,34 @@ where Err(CTAP1_ERR_INVALID_COMMAND) } + /// CTAP2 `authenticatorReset` (command 0x07). Wipes credentials and + /// PIN state after collecting user presence. The standard 10-second + /// "since power-up" window from the FIDO spec is intentionally not + /// enforced; a software authenticator on a multi-user desktop already + /// requires explicit user consent via the presence prompt. + fn handle_reset(&mut self) -> Result, u8> { + let _present = self.await_user_presence()?; + self.clear_credentials()?; + self.pin_state = PinState::new(); + self.save_persistent_pin_state(); + self.cred_mgmt_state = CredentialManagementState::new(); + self.pending_assertion = None; + Ok(vec![CTAP2_OK]) + } + + #[cfg(not(test))] + fn clear_credentials(&mut self) -> Result<(), u8> { + let path = Self::store_path()?; + let _ = try_syscall!(self.client.remove_file(Location::Internal, path)); + Ok(()) + } + + #[cfg(test)] + fn clear_credentials(&mut self) -> Result<(), u8> { + self.stored_credentials.clear(); + Ok(()) + } + fn client_pin_get_retries(&mut self) -> Result, u8> { let mut entries = vec![( Value::Integer(Integer::from(0x03)), @@ -2409,10 +2365,10 @@ where { Some(Value::Integer(int)) => { let value: i128 = int.clone().into(); - PinProtocol::from_identifier(value)? + pin_protocol_from_identifier(value)? } Some(_) => return Err(CTAP2_ERR_PIN_AUTH_INVALID), - None => PinProtocol::Classic(ClassicPinProtocol::V2), + None => ClassicPinProtocol::V2, }; hmac_secret_request = Some(HmacSecretRequest { key_agreement, @@ -2780,9 +2736,10 @@ where CTAP_CMD_GET_ASSERTION => self.handle_get_assertion(payload), CTAP_CMD_GET_NEXT_ASSERTION => self.handle_get_next_assertion(), CTAP_CMD_CLIENT_PIN => self.handle_client_pin(payload), + CTAP_CMD_RESET => self.handle_reset(), CTAP_CMD_CREDENTIAL_MANAGEMENT => self.handle_credential_management(payload), CTAP_CMD_BIO_ENROLLMENT => self.handle_bio_enrollment(payload), - _ => Err(CTAP2_ERR_INVALID_CBOR), + _ => Err(CTAP1_ERR_INVALID_COMMAND), }; let (message, status) = match result { diff --git a/authenticator/src/ctap/tests.rs b/authenticator/src/ctap/tests.rs index 4e35287..6923d1b 100644 --- a/authenticator/src/ctap/tests.rs +++ b/authenticator/src/ctap/tests.rs @@ -24,7 +24,6 @@ use trussed::client::{ }; use trussed::error::Error as TrussedError; use trussed::types::{consent, Message}; -use trussed_mlkem::{ParamSet as KemParamSet, SecretKey as KemSecretKey}; use zeroize::Zeroize; #[derive(Default)] @@ -110,30 +109,11 @@ impl ManagementClient for TestClient {} impl UiClient for TestClient {} impl TrussedClient for TestClient {} -#[test] -fn pqc_key_agreement_value_is_canonical_akp_map() { - let public_key = vec![0x01, 0x02]; - let session = PinProtocolSession::Pqc { - param_set: KemParamSet::MLKEM512, - secret_key: KemSecretKey(vec![]), - public_key: public_key.clone(), - }; - - let value = session.key_agreement_value(); - let expected_alg = cose_alg_for_kem_param_set(KemParamSet::MLKEM512); - assert_eq!(value, cose_akp_key_map(expected_alg, &public_key)); - - let mut encoded = Vec::new(); - into_writer(&value, &mut encoded).expect("encode COSE key agreement map"); - let expected = vec![0xA3, 0x01, 0x07, 0x03, 0x38, 0x6D, 0x20, 0x42, 0x01, 0x02]; - assert_eq!(encoded, expected); -} - #[test] fn classic_key_agreement_value_is_canonical() { let secret_key = P256SecretKey::from_slice(&[0x13; 32]).expect("valid secret key"); let public_key = secret_key.public_key().to_encoded_point(false); - let session = PinProtocolSession::Classic { + let session = PinProtocolSession { protocol: ClassicPinProtocol::V2, public_key: public_key.clone(), secret_key, @@ -247,8 +227,8 @@ fn assert_get_info_response(app: &mut CtapApp, aaguid: [u8; 16]) { ( Value::Integer(Integer::from(6)), Value::Array(vec![ - Value::Integer(Integer::from(i32::from(PIN_UV_AUTH_PROTOCOL_PQC))), - Value::Integer(Integer::from(PIN_UV_AUTH_PROTOCOL_CLASSIC)), + Value::Integer(Integer::from(PIN_UV_AUTH_PROTOCOL_CLASSIC_V2)), + Value::Integer(Integer::from(PIN_UV_AUTH_PROTOCOL_CLASSIC_V1)), ]), ), ( diff --git a/authenticator/src/lib.rs b/authenticator/src/lib.rs index c3f6778..e3f1c21 100644 --- a/authenticator/src/lib.rs +++ b/authenticator/src/lib.rs @@ -1,7 +1,4 @@ use aes::Aes256; -#[allow(deprecated)] -use aes_gcm::aead::{generic_array::GenericArray, Aead, KeyInit, Payload}; -use aes_gcm::Aes256Gcm; use cbc::cipher::{block_padding::NoPadding, BlockDecryptMut, BlockEncryptMut, KeyIvInit}; use cbc::{Decryptor, Encryptor}; use ciborium::ser::into_writer; @@ -14,7 +11,6 @@ use p256::{EncodedPoint, SecretKey as P256SecretKey}; use rand_core::OsRng; use sha2::{Digest, Sha256}; use trussed_mldsa::{keypair, sign, ParamSet, PublicKey, SecretKey}; -use trussed_mlkem::ParamSet as KemParamSet; use zeroize::Zeroize; pub mod ctap; @@ -22,9 +18,6 @@ pub mod ctap; type Aes256CbcEncryptor = Encryptor; type Aes256CbcDecryptor = Decryptor; -/// Identifier advertised in `authenticatorGetInfo` for the PQC PIN/UV protocol. -pub const PIN_UV_AUTH_PROTOCOL_PQC: u8 = 101; - /// COSE key type value assigned to Algorithm Key Pairs (AKP). pub const COSE_KEY_TYPE_AKP: i32 = 7; @@ -33,11 +26,6 @@ pub const COSE_KEY_LABEL_KTY: i32 = 1; pub const COSE_KEY_LABEL_ALG: i32 = 3; pub const COSE_KEY_PARAM_AKP_KEY: i32 = -1; -/// COSE algorithm identifiers for ML-KEM parameter sets. -pub const COSE_ALG_ML_KEM_512: i32 = -110; -pub const COSE_ALG_ML_KEM_768: i32 = -111; -pub const COSE_ALG_ML_KEM_1024: i32 = -112; - /// Session keys derived from an ML-KEM shared secret and the transcript hash. #[derive(Debug, Zeroize)] #[zeroize(drop)] @@ -63,27 +51,6 @@ impl ClassicPinProtocol { } } -/// Derive the AES-256-GCM encryption key and the 32-byte HMAC key used for -/// client PIN handling. The HKDF salt binds the keys to the transcript hash. -pub fn derive_pqc_pin_uv_session_keys( - shared_secret: &[u8], - transcript_hash: &[u8], -) -> PinUvSessionKeys { - let hkdf = Hkdf::::new(Some(transcript_hash), shared_secret); - let mut okm = [0u8; 64]; - hkdf.expand(b"FIDO2-PQC-PIN-KEYS", &mut okm) - .expect("HKDF expand must not fail for valid length"); - let mut encryption_key = [0u8; 32]; - let mut auth_key = [0u8; 32]; - encryption_key.copy_from_slice(&okm[..32]); - auth_key.copy_from_slice(&okm[32..]); - okm.zeroize(); - PinUvSessionKeys { - encryption_key, - auth_key, - } -} - /// Derive the AES/HMAC keys for the classic PIN/UV protocols. pub fn derive_classic_pin_uv_session_keys( protocol: ClassicPinProtocol, @@ -114,47 +81,6 @@ pub fn derive_classic_pin_uv_session_keys( } } -/// Encrypt PIN data using AES-256-GCM. The transcript hash should be supplied -/// as AAD to bind the ciphertext to the protocol run. -#[allow(deprecated)] -pub fn encrypt_pqc_pin_block( - keys: &PinUvSessionKeys, - nonce: &[u8; 12], - plaintext: &[u8], - transcript_hash: &[u8], -) -> Vec { - let cipher = Aes256Gcm::new_from_slice(&keys.encryption_key).expect("invalid AES key length"); - let nonce_ga = GenericArray::clone_from_slice(nonce); - cipher - .encrypt( - &nonce_ga, - Payload { - msg: plaintext, - aad: transcript_hash, - }, - ) - .expect("encryption should not fail for valid parameters") -} - -/// Decrypt the PIN block using AES-256-GCM and the previously derived keys. -#[allow(deprecated)] -pub fn decrypt_pqc_pin_block( - keys: &PinUvSessionKeys, - nonce: &[u8; 12], - ciphertext: &[u8], - transcript_hash: &[u8], -) -> Result, aes_gcm::Error> { - let cipher = Aes256Gcm::new_from_slice(&keys.encryption_key).expect("invalid AES key length"); - let nonce_ga = GenericArray::clone_from_slice(nonce); - cipher.decrypt( - &nonce_ga, - Payload { - msg: ciphertext, - aad: transcript_hash, - }, - ) -} - /// Encrypt a classic PIN block using AES-256-CBC. Protocol 1 uses an all-zero /// IV, while protocol 2 prepends the random IV to the ciphertext. pub fn encrypt_classic_pin_block( @@ -262,15 +188,6 @@ pub fn mldsa_paramset_from_alg(alg: CoseAlg) -> Option { } } -/// Translate an ML-KEM parameter set to the corresponding COSE `alg` value. -pub fn cose_alg_for_kem_param_set(param_set: KemParamSet) -> i32 { - match param_set { - KemParamSet::MLKEM512 => COSE_ALG_ML_KEM_512, - KemParamSet::MLKEM768 => COSE_ALG_ML_KEM_768, - KemParamSet::MLKEM1024 => COSE_ALG_ML_KEM_1024, - } -} - /// Build a COSE_Key map for an AKP public key using canonical ordering. pub(crate) fn cose_akp_key_map(alg_id: i32, public_key: &[u8]) -> Value { Value::Map(vec![ @@ -423,17 +340,11 @@ pub fn sign_challenge( } } -// Additional structs and functions would be defined here to manage -// credential records, persist secrets via Trussed storage, and -// implement the CTAP2 command handlers. See the README for links -// explaining how to integrate this crate into a runner. - #[cfg(test)] mod tests { use super::*; - use ciborium::{de::from_reader, ser::into_writer, value::Integer}; + use ciborium::{de::from_reader, value::Integer}; use trussed_mldsa::verify; - use trussed_mlkem::{self, ParamSet as KemParamSet}; #[test] fn cose_public_key_canonical_encoding_matches_fixture() { @@ -452,32 +363,6 @@ mod tests { ); } - #[test] - fn mlkem_akp_map_matches_canonical_fixture() { - let pk = [0xCA, 0xFE]; - let value = cose_akp_key_map(COSE_ALG_ML_KEM_512, &pk); - let mut encoded = Vec::new(); - into_writer(&value, &mut encoded).expect("encode ML-KEM COSE key"); - let expected = vec![0xA3, 0x01, 0x07, 0x03, 0x38, 0x6D, 0x20, 0x42, 0xCA, 0xFE]; - assert_eq!(encoded, expected); - } - - #[test] - fn mlkem_alg_mapping_matches_expected_values() { - assert_eq!( - cose_alg_for_kem_param_set(KemParamSet::MLKEM512), - COSE_ALG_ML_KEM_512 - ); - assert_eq!( - cose_alg_for_kem_param_set(KemParamSet::MLKEM768), - COSE_ALG_ML_KEM_768 - ); - assert_eq!( - cose_alg_for_kem_param_set(KemParamSet::MLKEM1024), - COSE_ALG_ML_KEM_1024 - ); - } - #[test] fn mldsa_roundtrip_signatures() { for alg in [CoseAlg::MLDSA44, CoseAlg::MLDSA65, CoseAlg::MLDSA87] { @@ -576,23 +461,4 @@ mod tests { } panic!("COSE key missing public key bytes"); } - - #[test] - fn mlkem_pin_protocol_roundtrip() { - let (pk, sk) = trussed_mlkem::keypair(KemParamSet::MLKEM512); - let (ciphertext, shared_secret_client) = - trussed_mlkem::encapsulate(KemParamSet::MLKEM512, &pk); - let shared_secret_auth = - trussed_mlkem::decapsulate(KemParamSet::MLKEM512, &sk, &ciphertext) - .expect("ciphertext should be valid"); - let transcript_hash = b"transcript"; - let client_keys = derive_pqc_pin_uv_session_keys(&shared_secret_client.0, transcript_hash); - let auth_keys = derive_pqc_pin_uv_session_keys(&shared_secret_auth.0, transcript_hash); - let nonce = [0u8; 12]; - let plaintext = b"PIN data"; - let ciphertext = encrypt_pqc_pin_block(&client_keys, &nonce, plaintext, transcript_hash); - let decrypted = decrypt_pqc_pin_block(&auth_keys, &nonce, &ciphertext, transcript_hash) - .expect("decryption should succeed"); - assert_eq!(plaintext.to_vec(), decrypted); - } } diff --git a/FidoSoftwareAuthenticator.txt b/docs/development-notes.md similarity index 64% rename from FidoSoftwareAuthenticator.txt rename to docs/development-notes.md index 1287d9d..56b141b 100644 --- a/FidoSoftwareAuthenticator.txt +++ b/docs/development-notes.md @@ -1,3 +1,12 @@ +# Development notes + +Useful shell commands collected while developing the authenticator. These are +the manual procedures the maintainers used during bring-up; the unified CLI +(`pc-hid-runner`) hides most of them in everyday use. + +## Rebuild and relaunch the daemon + +```bash sudo pkill -f pc-hid-runner || true git pull @@ -7,7 +16,8 @@ cargo build --release sudo rmmod uhid 2>/dev/null || true sudo modprobe uhid -echo 'KERNEL=="uhid", MODE="0660", GROUP="plugdev"' | sudo tee /etc/udev/rules.d/70-uhid.rules +echo 'KERNEL=="uhid", MODE="0660", GROUP="plugdev"' \ + | sudo tee /etc/udev/rules.d/70-uhid.rules sudo udevadm control --reload-rules sudo udevadm trigger sudo chown root:plugdev /dev/uhid @@ -15,26 +25,27 @@ sudo chmod 660 /dev/uhid newgrp plugdev RUST_LOG=pc_hid_runner=debug cargo run -p pc-hid-runner -- start --foreground +``` +## Confirm the virtual HID device is visible to userspace - +```bash ls -l /dev/hidraw* fido2-token -L - FIDO_DEBUG=1 fido2-token -I /dev/hidraw3 +``` +## Kernel-level introspection - - - -Tests: +```bash sudo lsmod | grep uhid cat /sys/class/hidraw/hidraw*/device/uevent sudo cat /sys/kernel/debug/hid/0003:096E:0858.0005/rdesc | hexdump -C +``` +## Full diagnostic walk-through - -Main Tests: +```bash sudo -i lsmod | grep uhid ls -l /dev/uhid @@ -46,5 +57,4 @@ ls -ld /sys/kernel/debug/hid ls -d /sys/kernel/debug/hid/*096E* 2>/dev/null stat -c "rdesc size: %s bytes" $(ls -d /sys/kernel/debug/hid/*096E* | tail -1)/rdesc cat $(ls -d /sys/kernel/debug/hid/*096E* | tail -1)/rdesc | hexdump -C | head -n 20 - - +``` diff --git a/download-ripgrepSCJSfZ/tmp-file b/download-ripgrepSCJSfZ/tmp-file deleted file mode 100644 index 3144fa5..0000000 Binary files a/download-ripgrepSCJSfZ/tmp-file and /dev/null differ diff --git a/patches/ssmarshal/.gitignore b/patches/ssmarshal/.gitignore deleted file mode 100644 index e31f0e5..0000000 --- a/patches/ssmarshal/.gitignore +++ /dev/null @@ -1,12 +0,0 @@ -# Compiled files -*.o -*.so -*.rlib -*.dll -*.pyc -# Executables -*.exe - -# Generated by Cargo -/target/ -Cargo.lock diff --git a/patches/ssmarshal/.gitlab-ci.yml b/patches/ssmarshal/.gitlab-ci.yml deleted file mode 100644 index 50f922e..0000000 --- a/patches/ssmarshal/.gitlab-ci.yml +++ /dev/null @@ -1,26 +0,0 @@ -build: - image: registry.gitlab.com/robigalia/runner:latest - cache: - key: $CACHE_KEY - paths: - - /root/.cargo - script: - - "xargo build --target i686-sel4-robigalia --no-default-features" - - "xargo build --target arm-sel4-robigalia --no-default-features" - - "cargo build --no-default-features" - - "cargo test" - - "cargo test --release" -# - "kcov --exclude-pattern=/.cargo,/usr/lib --verify target/cov/ target/debug/roundtrip-*[^\\.d]" -# - "bash <(curl -s https://codecov.io/bash) -t 84321081-ebe2-447a-bdf1-a69eee2bdcf7" -# - echo "Percent coverage: $(jq .percent_covered target/cov/rn-*/coverage.json)%" - -verify_signatures: - image: ubuntu:17.04 - script: - - apt update - - apt install --assume-yes python-pexpect gnupg2 git - - git clone --depth=1 https://gitlab.com/robigalia/meta - - gpg2 --list-keys # to force it to create GNUPGHOME instead of racing in the pipe below - - (gpg2 --export --no-default-keyring --keyring ./meta/.gnupg/pubring.kbx || true) | gpg2 --import - - gpg2 --list-keys --fingerprint --fingerprint --verbose - - ./meta/verify-signatures.py HEAD ./meta/.mailmap diff --git a/patches/ssmarshal/CHANGELOG.md b/patches/ssmarshal/CHANGELOG.md deleted file mode 100644 index 93b97df..0000000 --- a/patches/ssmarshal/CHANGELOG.md +++ /dev/null @@ -1,17 +0,0 @@ -# `ssmarshal` changelog - -This project follows semantic versioning. - -## v1.0.0 (2017-05-13) - -- [added] `cargo-fuzz` based fuzz testing -- [added] random datatype-based testing -- [removed] afl.rs based fuzz testing -- [changed] expanded quickcheck-based testing to more interesting types -- [changed] Ported to serde 1.0 -- [removed] Support for serializing values which can't be deserialized (slices etc) -- [fixed] Documented the high-level details of the format and limitations. - -## v0.0.1 (2017-01-03) - -- First release. diff --git a/patches/ssmarshal/CONTRIBUTING.md b/patches/ssmarshal/CONTRIBUTING.md deleted file mode 100644 index 804fbb2..0000000 --- a/patches/ssmarshal/CONTRIBUTING.md +++ /dev/null @@ -1,187 +0,0 @@ -Thank you for your interest in contributing to the Robigalia project! There -are many ways to contribute, and we appreciate all of them. - -If you have questions, please send an email to -[robigalia-dev@lists.robigalia.org][list] or hop on [#robigalia][irc]. - -As a reminder, all participants in our community are expected to honor our -[code of conduct][conduct]. - -[list]: mailto:robigalia-dev@lists.robigalia.org -[irc]: https://webchat.freenode.net/?channels=%23robigalia -[conduct]: https://robigalia.org/conduct.html - -## Feature Proposal - -To propose a change to the way that Robigo or any other Robigalia codebase -works, please open an issue directly on the relevant repository. Include the -text, `[feature-proposal]` in the title and someone will come by and re-tag -the issue appropriately. Here's a template you can use to file a feature -proposal, though it's not necessary to use it exactly: - -``` -One-paragraph summary - -# Details - -As many details as you think are necessary to communicate how the feature -should work. - -# Benefits - -Benefits of the feature. - -# Drawbacks - -Drawbacks of the feature. -``` - -There is [an example feature proposal][prop] if you want to see what it looks -like. - -[prop]: https://gitlab.com/robigalia/meta/issues/1 - -## Bug Reports - -While bugs are unfortunate, they're a reality in software. We can't fix what we -don't know about, so please report liberally. If you're not sure if something -is a bug or not, feel free to file a bug anyway. - -**If you believe reporting your bug publicly represents a security risk to -users of software developed by the Robigalia project, -please follow our [instructions for reporting security -vulnerabilities](https://robigalia.org/security.html)**. - -If you have the chance, before reporting a bug, please [search existing -issues](https://gitlab.com/groups/robigalia/issues) as it's possible that -someone else has already reported your error. This doesn't always work, and -sometimes it's hard to know what to search for, so consider this extra credit. -We won't mind if you accidentally file a duplicate report, we'll typically -close it and point out which issue is a duplicate of. - -Opening an issue is as easy as following [this -link](https://gitlab.com/groups/robigalia/issues) and filling out the fields -after clicking "New Issue". Here's a template that you can use to file a bug, -though it's not necessary to use it exactly: - - - - I tried this: - - - - I expected to see this happen: - - Instead, this happened: - -All three components are important: what you did, what you expected, what -happened instead. - - -## Submitting code - -To coordinate changes to our software, we use a feature of GitLab called -"merge requests". Alternatively, you can email patches (ideally with git -send-email) to [the development mailing list][list]. - -### Commit messages - -Commit messages should be self-contained and describe the motivation for a -change. The subject line should be short, with any elaborations in the body. -If the commit closes an issue, write "Closes #issuenumber" at the end of the -body. - -For some guidelines, read [this][chrisbeams] for the basics, and [this][pro] -to become a pro. - -[chrisbeams]: http://chris.beams.io/posts/git-commit/ -[pro]: https://robots.thoughtbot.com/5-useful-tips-for-a-better-commit-message - -### Commit signing - -For a [variety of reasons][horror], we use commit signing to verify the -authenticity and authorship of changes to our projects. If you don't already -have one, create a PGP key. There are many ways to do this. [This blog -post][keygen] by Alex Cabal has a decent explanation of how to do it and some -of the tradeoffs involved. - -Once you have a keypair and it is uploaded to the keyservers, [learn how to -use gpg with git][horror2]. Please sign all commits you intend to include in a -merge request. - -[horror]: https://mikegerwitz.com/papers/git-horror-story -[horror2]: https://mikegerwitz.com/papers/git-horror-story#trust-ensure -[keygen]: https://alexcabal.com/creating-the-perfect-gpg-keypair/ - -### Forking the repositories. - -We use a custom system for managing our large amount of repositories. We have -one "master" repository, [devbox][devbox], which contains scripts for fetching -the other repositories. It also includes a [Vagrant][vagrant] configuration, -which is the easiest way to get started with Rust and seL4. See the readme in -that repository to see how to use the scripts and, optionally, set up Vagrant. -Part of the setup is running the `add_remotes.sh` script, which will rename -the official repo to `upstream` and add an `origin` remote pointing to a repo -under your own username. - -To fork a repository, navigate to it on GitLab and click the "Fork project" -button", which is to the left of the repository URL: - -![fork project button location image][forkimg] - -Then, you can interact with that repository using the `origin` remote in the -relevant sub-repository of `devbox`. - -[devbox]: https://gitlab.com/robigalia/devbox -[vagrant]: https://www.vagrantup.com/ -[forkimg]: https://gitlab.com/robigalia/meta/raw/master/fork_button.png - -### Signing the Developer Certificate of Origin - -Before we can accept code you have written into our repositories, you must -agree to the Developers Certificate of Origin. You can view it [in this -repository][DCO]. It is quite minimalist, and is also used by the Linux -kernel. To do this, fork the meta repository and run a command like: - - gpg --sign --armor < DCO.txt > agreements/${your_gitlab_username} - -Create a new commit with that file and send a merge request. - -[DCO]: https://gitlab.com/robigalia/meta/blob/master/DCO.txt - -### Submitting a merge request - -To submit a merge request, push the commits you want to include to a branch on -your fork of the relevant repository. Refer to the [official GitLab -documentation][mergereq] to see how to proceed from there. - -Please open merge requests against the `master` branch. If needed, we will -merge into a separate branch manually. - -[mergereq]: http://doc.gitlab.com/ce/gitlab-basics/add-merge-request.html - -All merge requests are reviewed by another person. - -If you want to request that a specific person reviews your pull request, you -can specify the "assignee" when you create the pull request. For example, -Corey usually reviews changes to sel4-sys, so you could specify him as the -assignee if you send a merge request to sel4-sys. - -## Writing Documentation - -Documentation improvements are very welcome. The source of robigalia.org is -in its [own repository][web], and individual crate documentation is hosted on -[doc.robigalia.org](https://doc.robigalia.org). - -Documentation merge requests function in the same way as other merge requests. - -[web]: https://gitlab.com/robigalia/robigalia.org - -## Helpful Links and Information - -- The [seL4 website](https://sel4.systems/) has things like the manual and how - to build seL4. -- The [Rust website](https://rust-lang.org/) for all your Rust-related - questions. - -*This document adapted from * diff --git a/patches/ssmarshal/Cargo.toml b/patches/ssmarshal/Cargo.toml deleted file mode 100644 index dbaf3ca..0000000 --- a/patches/ssmarshal/Cargo.toml +++ /dev/null @@ -1,28 +0,0 @@ -# Copyright (c) 2017 The Robigalia Project Developers -# Licensed under the Apache License, Version 2.0 or the MIT license , at your option. All files in the -# project carrying such notice may not be copied, modified, or distributed -# except according to those terms. -[package] -name = "ssmarshal" -version = "1.0.0" -authors = ["Corey Richardson "] -description = "Stupid simple value-only marshaling using serde" -documentation = "https://docs.rs/ssmarshal" -repository = "https://gitlab.com/robigalia/ssmarshal" -readme = "README.md" -license = "MIT OR Apache-2.0" - -[features] -default = ["std"] -std = ["serde/std"] - -[dependencies] -serde = { version = "1.0", default-features = false } -encode_unicode = { version = "0.3", default-features = false } - -[dev-dependencies] -quickcheck = "0.4" -quickcheck_macros = "0.4" -serde_derive = "1.0" diff --git a/patches/ssmarshal/LICENSE-APACHE b/patches/ssmarshal/LICENSE-APACHE deleted file mode 100644 index 8dada3e..0000000 --- a/patches/ssmarshal/LICENSE-APACHE +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - - APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "{}" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - - Copyright {yyyy} {name of copyright owner} - - Licensed under the Apache License, Version 2.0 (the "License"); - you may not use this file except in compliance with the License. - You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - - Unless required by applicable law or agreed to in writing, software - distributed under the License is distributed on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - See the License for the specific language governing permissions and - limitations under the License. diff --git a/patches/ssmarshal/LICENSE-MIT b/patches/ssmarshal/LICENSE-MIT deleted file mode 100644 index 9789053..0000000 --- a/patches/ssmarshal/LICENSE-MIT +++ /dev/null @@ -1,25 +0,0 @@ -Copyright (c) 2015 The Robigalia Developers - -Permission is hereby granted, free of charge, to any -person obtaining a copy of this software and associated -documentation files (the "Software"), to deal in the -Software without restriction, including without -limitation the rights to use, copy, modify, merge, -publish, distribute, sublicense, and/or sell copies of -the Software, and to permit persons to whom the Software -is furnished to do so, subject to the following -conditions: - -The above copyright notice and this permission notice -shall be included in all copies or substantial portions -of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF -ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED -TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A -PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT -SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY -CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION -OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR -IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -DEALINGS IN THE SOFTWARE. diff --git a/patches/ssmarshal/README.md b/patches/ssmarshal/README.md deleted file mode 100644 index 0f6e168..0000000 --- a/patches/ssmarshal/README.md +++ /dev/null @@ -1,69 +0,0 @@ -# ssmarshal - -[![Crates.io](https://img.shields.io/crates/v/ssmarshal.svg?style=flat-square)](https://crates.io/crates/ssmarshal) - -[Documentation](https://docs.rs/ssmarshal) - -ssmarshal ("stupid simple marshaling") is a serde-based de/serialization -library. It is somewhat like [bincode](https://github.com/TyOverby/bincode), -but doesn't support String/Vec - this library is entirely zero-allocation, for -use in extremely limited `no_std` contexts. The key invariant is that the -encoding space for any value of a type is `<= size_of::()`. This allows -easy reasoning about limited buffer sizes, and how much is always enough. - -## Limitations - -These sorts of types are not supported: - -- Any non-core type (eg, `Vec`, `HashMap`) -- Slices -- Strings -- Types containing references or pointers -- Enums with more than 256 variants - -All enums MUST be `#[repr(C)]` in order for the size invariant to be upheld. -Note that this excludes using `Option`, especially with `NonZero` types! -You can use this crate with non-`#[repr(C)]` enums, but you should thoroughly -test (I recommend quickcheck, see [the tests](https://gitlab.com/robigalia/ssmarshal/blob/master/tests/roundtrip.rs) -for an example) de/serializing values of that type to be assured the size -invariant holds for the type. - -## Details of the format - -The format is not incredibly compact, but doesn't add extra fluff, and is -quick to en/decode. - -- `bool` is serialized as a byte, 1 if true, 0 is false. -- the integer types are encoded in their little-endian form. -- f32 is bitcast to a u32 then encoded as a u32. likewise, f64 and u64. -- inhabited enums are serialized as 1 byte for the discriminant, and then the fields. -- structs are serialized as just their fields. -- the unit type and uninhabited enums are not serialized at all. -- tuples are serialized as the fields, in order. - -There is no padding. - -As you might see, this format is not self-describing. To successfully -deserialize a value, the exact layout must be known ahead-of-time. - -## Alternatives - -This is designed for doing IPC in a microkernel, with a stable ABI, not saving -to disk or transferring over the network. It may be useful for those cases, -although you'll likely want a format which can handle data evolution, like -Cap'n Proto. - -If you care about truly minimizing encoding space, you might look into ASN.1 -PER. - -If you need more features (for example, slices or references), but still don't -care about data evolution, I recommend using bincode. - -## Testing - -The `roundtrip` test suite exercises almost all of the functionality of -ssmarshal, with coverage over 95% (missing mostly some of the error cases for -invalid/unsupported types). - -This library is extensively fuzz tested with `cargo-fuzz` (libFuzzer) before -every release. See the `fuzz` directory for the scripts used. diff --git a/patches/ssmarshal/src/lib.rs b/patches/ssmarshal/src/lib.rs deleted file mode 100644 index 5e0d38d..0000000 --- a/patches/ssmarshal/src/lib.rs +++ /dev/null @@ -1,788 +0,0 @@ -// Copyright (c) 2017 The Robigalia Project Developers Licensed under the Apache License, Version -// 2.0 or the MIT license -// , at your option. All files in the project -// carrying such notice may not be copied, modified, or distributed except according to those -// terms. - -#![cfg_attr(not(feature = "std"), no_std)] - -#[cfg(feature = "std")] -extern crate core; - -extern crate serde; -extern crate encode_unicode; - -use core::intrinsics::transmute; - -use serde::{Serialize, Deserialize}; -use serde::de::{Visitor, DeserializeSeed, DeserializeOwned, IntoDeserializer}; -#[cfg(not(feature = "std"))] -use serde::de::StdError as SerdeStdError; -//use serde::de::value::ValueDeserializer; -use encode_unicode::CharExt; -use encode_unicode::Utf8Char; - -use core::fmt::Display; - -const NS: &'static str = "not support"; - -#[inline(never)] -#[cold] -fn ns() -> Result { - if cfg!(debug_assertions) { - panic!(NS) - } - Err(Error::NotSupported) -} - -#[derive(Debug)] -pub enum Error { - EndOfStream, - InvalidRepresentation, - MoreElements, - TooManyVariants, - NotSupported, - ApplicationError(&'static str), - #[cfg(not(feature = "std"))] - Custom, - #[cfg(feature = "std")] - Custom(String), -} - -impl core::fmt::Display for Error { - fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { - #[cfg(feature = "std")] - use std::error::Error; - - match self { - &::Error::ApplicationError(s) => write!(f, "application error: {}", s), - _ => f.write_str(self.description()), - } - } -} - -#[cfg(not(feature = "std"))] -impl serde::de::Error for Error { - fn custom(_msg: T) -> Error { - Error::Custom - } -} - -#[cfg(not(feature = "std"))] -impl serde::ser::Error for Error { - fn custom(_msg: T) -> Error { - Error::Custom - } -} - -#[cfg(feature = "std")] -impl serde::de::Error for Error { - fn custom(msg: T) -> Error { - Error::Custom(format!("{}", msg)) - } -} - -#[cfg(feature = "std")] -impl serde::ser::Error for Error { - fn custom(msg: T) -> Error { - Error::Custom(format!("{}", msg)) - } -} - -#[cfg(not(feature = "std"))] -impl SerdeStdError for Error {} - -#[cfg(not(feature = "std"))] -impl Error { - fn description(&self) -> &str { - match self { - &Error::EndOfStream => "end of stream reached but more data was needed", - &Error::InvalidRepresentation => "invalid representation for a value", - &Error::MoreElements => "there are more elements of the sequence remaining", - &Error::TooManyVariants => "too many variants, only up to 256 are supported", - &Error::NotSupported => "feature not supported", - &Error::ApplicationError(s) => s, - &Error::Custom => "some custom error that couldn't be reported", - } - } -} - -#[cfg(feature = "std")] -impl std::error::Error for Error { - fn description(&self) -> &str { - match self { - &Error::EndOfStream => "end of stream reached but more data was needed", - &Error::InvalidRepresentation => "invalid representation for a value", - &Error::MoreElements => "there are more elements of the sequence remaining", - &Error::TooManyVariants => "too many variants, only up to 256 are supported", - &Error::NotSupported => "feature not supported", - &Error::ApplicationError(s) => s, - &Error::Custom(ref s) => &s - } - } -} - -/// Serialize a value into a buffer. Returns the number of bytes used. -pub fn serialize(buf: &mut [u8], val: &T) -> SerializeResult { - let mut serializer = Serializer { buf: buf, idx: 0 }; - T::serialize(val, &mut serializer)?; - debug_assert!(serializer.idx <= core::mem::size_of::(), "{} <=? {}", serializer.idx, core::mem::size_of::()); - Ok(serializer.idx) -} - -/// Deserialize a value from a buffer. Returns the number of bytes used. -pub fn deserialize(buf: &[u8]) -> SerializeResult<(T, usize)> { - let mut deserializer = Deserializer { buf: buf, idx: 0 }; - let val = T::deserialize(&mut deserializer)?; - debug_assert!(deserializer.idx <= core::mem::size_of::()); - Ok((val, deserializer.idx)) -} - -struct Serializer<'a> { - buf: &'a mut [u8], - idx: usize, -} - -impl<'a> Serializer<'a> { - #[inline] - fn check_bounds(&self, len: usize) -> Result<(), Error> { - if let Some(val) = self.idx.checked_add(len) { - if val <= self.buf.len() { - return Ok(()); - } - } - debug_assert!(false, "ran out of space serializing value; fix your buffer size"); - Err(Error::EndOfStream) - } - - #[inline] - fn write_u8(&mut self, val: u8) -> Result<(), Error> { - self.check_bounds(1)?; - unsafe { - *self.buf.get_unchecked_mut(self.idx) = val; - } - self.idx += 1; - Ok(()) - } - - #[inline] - fn write_u16(&mut self, val: u16) -> Result<(), Error> { - self.check_bounds(2)?; - unsafe { - *self.buf.get_unchecked_mut(self.idx) = (val & 0xFF) as u8; - *self.buf.get_unchecked_mut(self.idx + 1) = (val >> 8 & 0xFF) as u8; - } - self.idx += 2; - Ok(()) - } - - #[inline] - fn write_u32(&mut self, val: u32) -> Result<(), Error> { - self.check_bounds(4)?; - unsafe { - *self.buf.get_unchecked_mut(self.idx) = (val & 0xFF) as u8; - *self.buf.get_unchecked_mut(self.idx + 1) = (val >> 8 & 0xFF) as u8; - *self.buf.get_unchecked_mut(self.idx + 2) = (val >> 16 & 0xFF) as u8; - *self.buf.get_unchecked_mut(self.idx + 3) = (val >> 24 & 0xFF) as u8; - } - self.idx += 4; - Ok(()) - } - - #[inline] - fn write_u64(&mut self, val: u64) -> Result<(), Error> { - self.check_bounds(8)?; - unsafe { - *self.buf.get_unchecked_mut(self.idx) = (val & 0xFF) as u8; - *self.buf.get_unchecked_mut(self.idx + 1) = (val >> 8 & 0xFF) as u8; - *self.buf.get_unchecked_mut(self.idx + 2) = (val >> 16 & 0xFF) as u8; - *self.buf.get_unchecked_mut(self.idx + 3) = (val >> 24 & 0xFF) as u8; - *self.buf.get_unchecked_mut(self.idx + 4) = (val >> 32 & 0xFF) as u8; - *self.buf.get_unchecked_mut(self.idx + 5) = (val >> 40 & 0xFF) as u8; - *self.buf.get_unchecked_mut(self.idx + 6) = (val >> 48 & 0xFF) as u8; - *self.buf.get_unchecked_mut(self.idx + 7) = (val >> 56 & 0xFF) as u8; - } - self.idx += 8; - Ok(()) - } - - #[inline] - fn write_usize(&mut self, val: usize) -> Result<(), Error> { - self.write_u64(val as u64) - } -} - -type SerializeResult = Result; - -impl<'b, 'a: 'b> serde::Serializer for &'b mut Serializer<'a> { - type Ok = (); - type Error = Error; - type SerializeSeq = Self; - type SerializeTuple = Self; - type SerializeTupleStruct = Self; - type SerializeTupleVariant = Self; - type SerializeMap = serde::ser::Impossible<(), Error>; - type SerializeStruct = Self; - type SerializeStructVariant = Self; - - - #[inline] - fn serialize_bool(self, v: bool) -> SerializeResult<()> { - self.write_u8(if v { 1 } else { 0 }) - } - - #[inline] - fn serialize_u8(self, v: u8) -> SerializeResult<()> { - self.write_u8(v) - } - - #[inline] - fn serialize_u16(self, v: u16) -> SerializeResult<()> { - self.write_u16(v) - } - - #[inline] - fn serialize_u32(self, v: u32) -> SerializeResult<()> { - self.write_u32(v) - } - - #[inline] - fn serialize_u64(self, v: u64) -> SerializeResult<()> { - self.write_u64(v) - } - - #[inline] - fn serialize_i8(self, v: i8) -> SerializeResult<()> { - self.write_u8(v as u8) - } - - #[inline] - fn serialize_i16(self, v: i16) -> SerializeResult<()> { - self.write_u16(v as u16) - } - - #[inline] - fn serialize_i32(self, v: i32) -> SerializeResult<()> { - self.write_u32(v as u32) - } - - #[inline] - fn serialize_i64(self, v: i64) -> SerializeResult<()> { - self.write_u64(v as u64) - } - - #[inline] - fn serialize_f32(self, v: f32) -> SerializeResult<()> { - self.write_u32(unsafe { transmute(v) }) - } - - #[inline] - fn serialize_f64(self, v: f64) -> SerializeResult<()> { - self.write_u64(unsafe { transmute(v) }) - } - - fn serialize_str(self, _: &str) -> SerializeResult<()> { - ns() - } - - fn serialize_char(self, c: char) -> SerializeResult<()> { - let (arr, sz) = c.to_utf8_array(); - self.check_bounds(sz)?; - for (i, c) in arr[..sz].iter().enumerate() { - unsafe { - *self.buf.get_unchecked_mut(self.idx + i) = *c; - } - } - self.idx += sz; - Ok(()) - } - - fn serialize_bytes(self, _: &[u8]) -> SerializeResult<()> { - ns() - } - - #[inline] - fn serialize_none(self) -> SerializeResult<()> { - self.write_u8(0) - } - - fn serialize_some(self, v: &T) -> SerializeResult<()> { - self.write_u8(1)?; - v.serialize(self) - } - - #[inline] - fn serialize_unit(self) -> SerializeResult<()> { - Ok(()) - } - - #[inline] - fn serialize_unit_struct(self, _: &'static str) -> SerializeResult<()> { - Ok(()) - } - - #[inline] - fn serialize_unit_variant(self, - _name: &'static str, - variant_index: u32, - _variant: &'static str) - -> SerializeResult<()> { - if variant_index > 255 { - debug_assert!(false, "too many enum variants: {}", _name); - return Err(Error::TooManyVariants) - } - self.write_u8(variant_index as u8) - } - - fn serialize_newtype_struct(self, _name: &'static str, value: &T) -> SerializeResult<()> { - value.serialize(self) - } - - fn serialize_newtype_variant(self, - _name: &'static str, - variant_index: u32, - _variant: &'static str, - value: &T) - -> SerializeResult<()> { - if variant_index > 255 { - debug_assert!(false, "too many enum variants: {}", _name); - return Err(Error::TooManyVariants); - } - self.write_u8(variant_index as u8)?; - value.serialize(self) - } - - #[inline] - fn serialize_seq(self, len: Option) -> SerializeResult { - match len { - None => { - ns() - }, - Some(len) => { - self.write_usize(len)?; - Ok(self) - } - } - } - - #[inline] - fn serialize_tuple(self, _len: usize) -> SerializeResult { - Ok(self) - } - - #[inline] - fn serialize_tuple_struct(self, _name: &'static str, _len: usize) -> SerializeResult { - Ok(self) - } - - #[inline] - fn serialize_tuple_variant(self, - _name: &'static str, - variant_index: u32, - _variant: &'static str, - _len: usize) - -> SerializeResult { - if variant_index > 255 { - debug_assert!(false, "too many enum variants: {}", _name); - return Err(Error::TooManyVariants); - } - self.write_u8(variant_index as u8)?; - Ok(self) - } - - fn serialize_map(self, _len: Option) -> SerializeResult { - ns() - } - - #[inline] - fn serialize_struct(self, _name: &'static str, _len: usize) -> SerializeResult { - Ok(self) - } - - #[inline] - fn serialize_struct_variant(self, - _name: &'static str, - variant_index: u32, - _variant: &'static str, - _len: usize) - -> SerializeResult { - if variant_index > 255 { - debug_assert!(false, "too many enum variants: {}", _name); - return Err(Error::TooManyVariants); - } - self.write_u8(variant_index as u8)?; - Ok(self) - } - - #[cfg(not(feature = "std"))] - fn collect_str(self, _value: &T) -> SerializeResult<()> { - ns() - } -} - -impl<'b, 'a: 'b> serde::ser::SerializeSeq for &'b mut Serializer<'a> { - type Ok = (); - type Error = Error; - - fn serialize_element(&mut self, value: &V) -> SerializeResult<()> { - value.serialize(&mut **self) - } - - #[inline] - fn end(self) -> SerializeResult<()> { Ok(()) } -} - -impl<'b, 'a: 'b> serde::ser::SerializeTuple for &'b mut Serializer<'a> { - type Ok = (); - type Error = Error; - - fn serialize_element(&mut self, value: &V) -> SerializeResult<()> { - value.serialize(&mut **self) - } - - #[inline] - fn end(self) -> SerializeResult<()> { Ok(()) } -} - -impl<'b, 'a: 'b> serde::ser::SerializeTupleStruct for &'b mut Serializer<'a> { - type Ok = (); - type Error = Error; - - fn serialize_field(&mut self, value: &V) -> Result<(), Error> { - value.serialize(&mut **self) - } - - #[inline] - fn end(self) -> Result<(), Error> { Ok(()) } -} - -impl<'b, 'a: 'b> serde::ser::SerializeTupleVariant for &'b mut Serializer<'a> { - type Ok = (); - type Error = Error; - - fn serialize_field(&mut self, value: &V) -> Result<(), Error> { - value.serialize(&mut **self) - } - - #[inline] - fn end(self) -> Result<(), Error> { Ok(()) } -} - -impl<'b, 'a: 'b> serde::ser::SerializeStruct for &'b mut Serializer<'a> { - type Ok = (); - type Error = Error; - - fn serialize_field(&mut self, _: &'static str, value: &V) -> Result<(), Error> { - value.serialize(&mut **self) - } - - #[inline] - fn end(self) -> Result<(), Error> { - Ok(()) - } -} - -impl<'b, 'a: 'b> serde::ser::SerializeStructVariant for &'b mut Serializer<'a> { - type Ok = (); - type Error = Error; - - fn serialize_field(&mut self, _: &'static str, value: &V) -> Result<(), Error> { - value.serialize(&mut **self) - } - - #[inline] - fn end(self) -> Result<(), Error> { Ok(()) } -} - -struct Deserializer<'a> { - buf: &'a [u8], - idx: usize, -} - -impl<'a> Deserializer<'a> { - #[inline] - fn check_bounds(&self, len: usize) -> Result<(), Error> { - if let Some(val) = self.idx.checked_add(len) { - if val <= self.buf.len() { - return Ok(()); - } - } - debug_assert!(false, "ran out of space deserializing value; fix your buffer size"); - Err(Error::EndOfStream) - } - - #[inline] - fn read_u8(&mut self) -> Result { - self.check_bounds(1)?; - let val = unsafe { - *self.buf.get_unchecked(self.idx) - }; - self.idx += 1; - Ok(val) - } - - #[inline] - fn read_u16(&mut self) -> Result { - self.check_bounds(2)?; - let mut val; - unsafe { - val = *self.buf.get_unchecked(self.idx) as u16; - val |= (*self.buf.get_unchecked(self.idx + 1) as u16) << 8; - } - self.idx += 2; - Ok(val) - } - - #[inline] - fn read_u32(&mut self) -> Result { - self.check_bounds(4)?; - let mut val; - unsafe { - val = *self.buf.get_unchecked(self.idx) as u32; - val |= (*self.buf.get_unchecked(self.idx + 1) as u32) << 8; - val |= (*self.buf.get_unchecked(self.idx + 2) as u32) << 16; - val |= (*self.buf.get_unchecked(self.idx + 3) as u32) << 24; - } - self.idx += 4; - Ok(val) - } - - #[inline] - fn read_u64(&mut self) -> Result { - self.check_bounds(8)?; - let mut val; - unsafe { - val = *self.buf.get_unchecked(self.idx) as u64; - val |= (*self.buf.get_unchecked(self.idx + 1) as u64) << 8; - val |= (*self.buf.get_unchecked(self.idx + 2) as u64) << 16; - val |= (*self.buf.get_unchecked(self.idx + 3) as u64) << 24; - val |= (*self.buf.get_unchecked(self.idx + 4) as u64) << 32; - val |= (*self.buf.get_unchecked(self.idx + 5) as u64) << 40; - val |= (*self.buf.get_unchecked(self.idx + 6) as u64) << 48; - val |= (*self.buf.get_unchecked(self.idx + 7) as u64) << 56; - } - self.idx += 8; - Ok(val) - } -} - - -struct SeqAccess<'a, 'b: 'a> { - deserializer: &'a mut Deserializer<'b>, - len: usize, -} - -impl<'a, 'b: 'a> serde::de::SeqAccess<'b> for SeqAccess<'a, 'b> { - type Error = Error; - - fn next_element_seed>(&mut self, seed: V) -> Result, Error> { - if self.len > 0 { - self.len -= 1; - Ok(Some(DeserializeSeed::deserialize(seed, &mut *self.deserializer)?)) - } else { - Ok(None) - } - } - - fn size_hint(&self) -> Option { - Some(self.len) - } -} - -type DeserializeResult = Result; - -impl<'b, 'de: 'b> serde::Deserializer<'de> for &'b mut Deserializer<'de> { - type Error = Error; - - fn deserialize_any>(self, _visitor: V) -> DeserializeResult { - ns() - } - - fn deserialize_bool>(self, visitor: V) -> DeserializeResult { - let value: u8 = Deserialize::deserialize(self)?; - match value { - 0 => visitor.visit_bool(false), - 1 => visitor.visit_bool(true), - _ => Err(Error::InvalidRepresentation), - } - } - - fn deserialize_u8>(self, visitor: V) -> DeserializeResult { - visitor.visit_u8(self.read_u8()?) - } - - fn deserialize_u16>(self, visitor: V) -> DeserializeResult { - visitor.visit_u16(self.read_u16()?) - } - - fn deserialize_u32>(self, visitor: V) -> DeserializeResult { - visitor.visit_u32(self.read_u32()?) - } - - fn deserialize_u64>(self, visitor: V) -> DeserializeResult { - visitor.visit_u64(self.read_u64()?) - } - - fn deserialize_i8>(self, visitor: V) -> DeserializeResult { - visitor.visit_i8(self.read_u8()? as i8) - } - - fn deserialize_i16>(self, visitor: V) -> DeserializeResult { - visitor.visit_i16(self.read_u16()? as i16) - } - - fn deserialize_i32>(self, visitor: V) -> DeserializeResult { - visitor.visit_i32(self.read_u32()? as i32) - } - - fn deserialize_i64>(self, visitor: V) -> DeserializeResult { - visitor.visit_i64(self.read_u64()? as i64) - } - - fn deserialize_f32>(self, visitor: V) -> DeserializeResult { - visitor.visit_f32(unsafe { transmute(self.read_u32()?) }) - } - fn deserialize_f64>(self, visitor: V) -> DeserializeResult { - visitor.visit_f64(unsafe { transmute(self.read_u64()?) }) - } - - fn deserialize_char>(self, visitor: V) -> DeserializeResult { - match Utf8Char::from_slice_start(&self.buf[self.idx..]) { - Ok((c, count)) => { - // this ought to be correct, if it weren't how did from_slice_start do its thing? - self.idx = self.idx.wrapping_add(count); - visitor.visit_char(c.to_char()) - }, - Err(_) => Err(Error::InvalidRepresentation), - } - } - - fn deserialize_str>(self, _visitor: V) -> DeserializeResult { - ns() - } - - fn deserialize_string>(self, _visitor: V) -> DeserializeResult { - ns() - } - - fn deserialize_bytes>(self, _visitor: V) -> DeserializeResult { - ns() - } - - fn deserialize_byte_buf>(self, _visitor: V) -> DeserializeResult { - ns() - } - - fn deserialize_option>(self, visitor: V) -> DeserializeResult { - let value: u8 = Deserialize::deserialize(&mut *self)?; - match value { - 0 => visitor.visit_none(), - 1 => visitor.visit_some(self), - _ => Err(Error::InvalidRepresentation), - } - } - - fn deserialize_unit>(self, visitor: V) -> DeserializeResult { - visitor.visit_unit() - } - - fn deserialize_unit_struct>(self, - _name: &'static str, - visitor: V) - -> DeserializeResult { - visitor.visit_unit() - } - - fn deserialize_newtype_struct>(self, - _name: &str, - visitor: V) - -> DeserializeResult { - visitor.visit_newtype_struct(self) - } - - fn deserialize_seq>(self, visitor: V) -> DeserializeResult { - let len = Deserialize::deserialize(&mut *self)?; - - visitor.visit_seq(SeqAccess { - deserializer: self, - len: len, - }) - } - - fn deserialize_tuple>(self, len: usize, visitor: V) -> DeserializeResult { - visitor.visit_seq(SeqAccess { deserializer: self, len: len }) - } - - fn deserialize_tuple_struct>(self, - _name: &'static str, - len: usize, - visitor: V) - -> DeserializeResult { - self.deserialize_tuple(len, visitor) - } - - fn deserialize_map>(self, _visitor: V) -> DeserializeResult { - Err(Error::NotSupported) - } - - fn deserialize_struct>(self, - _name: &str, - fields: &'static [&'static str], - visitor: V) - -> DeserializeResult { - self.deserialize_tuple(fields.len(), visitor) - } - - fn deserialize_enum>(self, - _enum: &'static str, - _variants: &'static [&'static str], - visitor: V) - -> Result { - visitor.visit_enum(self) - } - - - fn deserialize_identifier>(self, _visitor: V) -> DeserializeResult { - // not the panic because it seems noone cares about these? - Err(Error::NotSupported) - } - - fn deserialize_ignored_any>(self, _visitor: V) -> DeserializeResult { - ns() - } -} - -impl<'b, 'de: 'b> serde::de::VariantAccess<'de> for &'b mut Deserializer<'de> { - type Error = Error; - - fn unit_variant(self) -> Result<(), Error> { - Ok(()) - } - - fn newtype_variant_seed>(self, seed: V) -> DeserializeResult { - DeserializeSeed::deserialize(seed, self) - } - - fn tuple_variant>(self, len: usize, visitor: V) -> DeserializeResult { - serde::de::Deserializer::deserialize_tuple(self, len, visitor) - } - - fn struct_variant>(self, - fields: &'static [&'static str], - visitor: V) - -> Result { - serde::de::Deserializer::deserialize_tuple(self, fields.len(), visitor) - } -} - -impl<'b, 'de: 'b> serde::de::EnumAccess<'de> for &'b mut Deserializer<'de> { - type Error = Error; - type Variant = Self; - - fn variant_seed>(self, seed: V) -> DeserializeResult<(V::Value, Self)> { - let x: u8 = Deserialize::deserialize(&mut *self)?; - let v = DeserializeSeed::deserialize(seed, (x as u32).into_deserializer())?; - Ok((v, self)) - } -} - diff --git a/patches/ssmarshal/tests/roundtrip.rs b/patches/ssmarshal/tests/roundtrip.rs deleted file mode 100644 index d4ea420..0000000 --- a/patches/ssmarshal/tests/roundtrip.rs +++ /dev/null @@ -1,239 +0,0 @@ -// Copyright (c) 2017 The Robigalia Project Developers Licensed under the Apache License, Version -// 2.0 or the MIT license -// , at your option. All files in the project -// carrying such notice may not be copied, modified, or distributed except according to those -// terms. - -#![feature(proc_macro, plugin)] -#![plugin(quickcheck_macros)] -#![allow(non_snake_case)] - -extern crate serde; -#[macro_use] -extern crate serde_derive; -extern crate quickcheck; - -extern crate ssmarshal; - -use serde::{Serialize}; -use serde::de::DeserializeOwned; - -use ssmarshal::{serialize, deserialize}; - -#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)] -struct U8(u8); - -#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)] -struct U16(u16); - -#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)] -struct U32(u32); - -#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)] -struct U64(u64); - -#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)] -struct USize(usize); - -#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)] -struct I8(i8); - -#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)] -struct I16(i16); - -#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)] -struct I32(i32); - -#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)] -struct I64(i64); - -#[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)] -struct ISize(isize); - -#[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)] -struct F32(f32); - -#[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)] -struct F64(f64); - -#[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)] -struct Simple { - a: u8, - b: u16, - c: u32, - d: u64, - e: i8, - f: f32, - g: u8, - h: f64, -} - -impl quickcheck::Arbitrary for Simple { - fn arbitrary(g: &mut G) -> Simple { - Simple { - a: g.gen(), - b: g.gen(), - c: g.gen(), - d: g.gen(), - e: g.gen(), - f: g.gen(), - g: g.gen(), - h: g.gen(), - } - } -} - -#[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)] -struct Unit; - -#[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)] -struct Complex { - a: Simple, - e: Unit, - b: Simple, - c: [u8; 7], - d: (), - f: [Unit; 3], -} - -impl quickcheck::Arbitrary for Complex { - fn arbitrary(g: &mut G) -> Complex { - Complex { - a: Simple::arbitrary(g), - b: Simple::arbitrary(g), - c: g.gen(), - d: (), - e: Unit, - f: [Unit; 3], - } - } -} - -#[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)] -#[repr(C)] -enum ComplexEnum { - A, - B(Simple), - C(u8, u16), - D(isize), - E { - foo: Simple - }, - F { - bar: Complex, - baz: Simple, - qux: char - } -} - -impl quickcheck::Arbitrary for ComplexEnum { - fn arbitrary(g: &mut G) -> ComplexEnum { - match g.gen_range(0, 6) { - 0 => { - ComplexEnum::A - }, - 1 => { - ComplexEnum::B(Simple::arbitrary(g)) - }, - 2 => { - ComplexEnum::C(g.gen(), g.gen()) - }, - 3 => { - ComplexEnum::D(g.gen()) - }, - 4 => { - ComplexEnum::E { foo: Simple::arbitrary(g) } - }, - 5 => { - ComplexEnum::F { bar: Complex::arbitrary(g), baz: Simple::arbitrary(g), qux: g.gen() } - }, - _ => unreachable!() - } - } -} - -#[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)] -struct TupleStruct(u8, u64, Simple, Option); - -impl quickcheck::Arbitrary for TupleStruct { - fn arbitrary(g: &mut G) -> TupleStruct { - TupleStruct(g.gen(), g.gen(), quickcheck::Arbitrary::arbitrary(g), quickcheck::Arbitrary::arbitrary(g)) - } -} - -fn rt_val(val: &T) -> bool { - let mut buf = vec![0; std::mem::size_of::()]; - serialize(&mut buf, val).unwrap(); - let new_val: T = deserialize(&buf).unwrap().0; - println!("\n\nOld: {:?}\nNew: {:?}", val, new_val); - val == &new_val -} - -#[quickcheck] -fn rt_simple(val: Simple) -> bool { - rt_val(&val) -} - -#[quickcheck] -fn rt_complex(val: Complex) -> bool { - rt_val(&val) -} - -#[quickcheck] -fn rt_complexenum(val: ComplexEnum) -> bool { - rt_val(&val) -} - -#[quickcheck] -fn rt_tuplestruct(val: TupleStruct) -> bool { - rt_val(&val) -} - -macro_rules! rt { - ($(($name:ident, $t:ty)),*) => { - $(#[quickcheck] fn $name(val: $t) -> bool { - rt_val::<$t>(&val) - })* - } -} - -macro_rules! rt_wrap { - ($(($name:ident, $t:ty, $n:ident)),*) => { - $(#[quickcheck] fn $name(val: $t) -> bool { - rt_val::<$n>(&$n(val)) - })* - } -} - -rt! { - (rt_i8, i8), - (rt_i16, i16), - (rt_i32, i32), - (rt_i64, i64), - (rt_u8, u8), - (rt_u16, u16), - (rt_u32, u32), - (rt_u64, u64), - (rt_usize, usize), - (rt_isize, isize), - (rt_f32, f32), - (rt_f64, f64), - (rt_tp1, (u8, u8, u8)), - (rt_tp2, (u8, i16, u8)), - (rt_tp3, (u8, i16, u8)), - (rt_tp4, (usize, i16, isize)), - (rt_char, char) -} - -rt_wrap! { - (rt_I8, i8 , I8), - (rt_I16, i16, I16), - (rt_I32, i32, I32), - (rt_I64, i64, I64), - (rt_U8, u8 , U8), - (rt_U16, u16, U16), - (rt_U32, u32, U32), - (rt_U64, u64, U64), - (rt_F32, f32, F32), - (rt_F64, f64, F64) -} diff --git a/patches/usbip-device/.cargo-ok b/patches/usbip-device/.cargo-ok deleted file mode 100644 index 5f8b795..0000000 --- a/patches/usbip-device/.cargo-ok +++ /dev/null @@ -1 +0,0 @@ -{"v":1} \ No newline at end of file diff --git a/patches/usbip-device/.cargo_vcs_info.json b/patches/usbip-device/.cargo_vcs_info.json deleted file mode 100644 index feb09e1..0000000 --- a/patches/usbip-device/.cargo_vcs_info.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "git": { - "sha1": "cc91cbd9c3f93425b998d2d57cfb5b6a8c98c1ea" - }, - "path_in_vcs": "" -} \ No newline at end of file diff --git a/patches/usbip-device/.gitignore b/patches/usbip-device/.gitignore deleted file mode 100644 index 62ea6b1..0000000 --- a/patches/usbip-device/.gitignore +++ /dev/null @@ -1,3 +0,0 @@ -.vscode/ -/target -Cargo.lock diff --git a/patches/usbip-device/Cargo.toml b/patches/usbip-device/Cargo.toml deleted file mode 100644 index b53d216..0000000 --- a/patches/usbip-device/Cargo.toml +++ /dev/null @@ -1,53 +0,0 @@ -# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO -# -# When uploading crates to the registry Cargo will automatically -# "normalize" Cargo.toml files for maximal compatibility -# with all versions of Cargo and also rewrite `path` dependencies -# to registry (e.g., crates.io) dependencies. -# -# If you are reading this file be aware that the original Cargo.toml -# will likely look very different (and much more reasonable). -# See Cargo.toml.orig for the original contents. - -[package] -edition = "2018" -name = "usbip-device" -version = "0.1.5" -authors = ["Leon Tan "] -description = "An implementation of usb-device on top of USBIP device." -readme = "README.md" -keywords = [ - "no-std", - "embedded", - "usb", - "usbip", -] -license = "Apache-2.0 OR MIT" -repository = "https://github.com/Sawchord/usbip-device" - -[dependencies.bitflags] -version = "1.3.2" -default-features = false - -[dependencies.log] -version = "0.4.17" -default-features = false - -[dependencies.usb-device] -version = "0.2.9" -default-features = false - -[dev-dependencies.pretty_env_logger] -version = "0.4.0" -default-features = false - -[dev-dependencies.usbd-hid] -version = "0.6.0" -default-features = false - -[dev-dependencies.usbd-serial] -version = "0.1.1" -default-features = false -[dependencies] -usbd-serial = "0.2.2" -usbd-hid = "0.8.2" diff --git a/patches/usbip-device/Cargo.toml.orig b/patches/usbip-device/Cargo.toml.orig deleted file mode 100644 index 1b09583..0000000 --- a/patches/usbip-device/Cargo.toml.orig +++ /dev/null @@ -1,20 +0,0 @@ -[package] -name = "usbip-device" -version = "0.1.5" -authors = ["Leon Tan "] -edition = "2018" -readme = "README.md" -keywords = ["no-std", "embedded", "usb", "usbip"] -license = "Apache-2.0 OR MIT" -description = "An implementation of usb-device on top of USBIP device." -repository = "https://github.com/Sawchord/usbip-device" - -[dependencies] -usb-device = { version = "0.2.9", default-features = false } -log = { version = "0.4.17", default-features = false } -bitflags = { version = "1.3.2", default-features = false } - -[dev-dependencies] -pretty_env_logger = { version = "0.4.0", default-features = false } -usbd-serial = { version = "0.1.1", default-features = false } -usbd-hid = { version = "0.6.0", default-features = false } \ No newline at end of file diff --git a/patches/usbip-device/LICENSE-APACHE b/patches/usbip-device/LICENSE-APACHE deleted file mode 100644 index 4e38cd3..0000000 --- a/patches/usbip-device/LICENSE-APACHE +++ /dev/null @@ -1,201 +0,0 @@ - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - -TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - -1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - -2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - -3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - -4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - -5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - -6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - -7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - -8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - -9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - -END OF TERMS AND CONDITIONS - -APPENDIX: How to apply the Apache License to your work. - - To apply the Apache License to your work, attach the following - boilerplate notice, with the fields enclosed by brackets "[]" - replaced with your own identifying information. (Don't include - the brackets!) The text should be enclosed in the appropriate - comment syntax for the file format. We also recommend that a - file or class name and description of purpose be included on the - same "printed page" as the copyright notice for easier - identification within third-party archives. - -Copyright 2021 Leon Tan - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. diff --git a/patches/usbip-device/LICENSE-MIT b/patches/usbip-device/LICENSE-MIT deleted file mode 100644 index 604e2a3..0000000 --- a/patches/usbip-device/LICENSE-MIT +++ /dev/null @@ -1,21 +0,0 @@ -MIT License - -Copyright (c) 2021 Leon Tan - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/patches/usbip-device/README.md b/patches/usbip-device/README.md deleted file mode 100644 index 2348686..0000000 --- a/patches/usbip-device/README.md +++ /dev/null @@ -1,69 +0,0 @@ -[1]: https://docs.rs/usb-device/0.2.7/usb_device/ -[3]: https://docs.rs/usb-device/0.2.7/usb_device/class/trait.UsbClass.html -[4]: https://docs.rs/usb-device/0.2.7/usb_device/bus/trait.UsbBus.html - -[doc-badge]: https://docs.rs/usbip-device/badge.svg -[doc-link]: https://docs.rs/usbip-device - -[crates-badge]: https://img.shields.io/crates/v/usbip-device -[crates-link]: https://crates.io/crates/usbip-device - -[apache2-license]: https://spdx.org/licenses/Apache-2.0.html -[mit-license]: https://spdx.org/licenses/MIT.htm - -# Usb-Hid Driver - -[![crates.io][crates-badge]][crates-link] -[![Documentation][doc-badge]][doc-link] - -This is an implementation of the [`UsbBus`][4] trait of [`usb-device`][1], simulating a USB device as a USBIP server. - -## Note - -This crate is **not** intended to be used in production ever. -It's purpose is to ease development of new [`UsbClass`][3] implementation or to emulate USB devices for easier embedded application development. - -## Usage - -The usbip client can be stared in the following way: - -```bash -sudo apt-get install linux-tools-generic -``` - -Then, start the application. - -```bash -cargo run --example serial_echo -``` - -and then start the USBIP client. - -```bash -// Start the vhci driver -sudo modprobe vhci-hcd - -// List available devices -usbip list -r "localhost" - -// Attach USB device -usbip attach -r "localhost" -b "1-1" - -// List connected devices -usbip port - -// Detach device -usbip detach -p "port" -``` - -Depending on you machine setup, you might need do `sudo`. - -## Known Bugs - -This is a very alpha software, which still has a lot of quirks to be worked out. - -- When using HID, the connection always fails the first time and usually works the second time. It is not entirely clear, why. - -## License - -[Apache-2.0][apache2-license] or [MIT][mit-license]. diff --git a/patches/usbip-device/examples/serial_echo.rs b/patches/usbip-device/examples/serial_echo.rs deleted file mode 100644 index d8fd0c4..0000000 --- a/patches/usbip-device/examples/serial_echo.rs +++ /dev/null @@ -1,43 +0,0 @@ -//! This example registers an ACM device, which can be connected -//! too using a serial terminal program, e.g. `screen`. -//! All printable characters are sent back, therefore, this program acts -//! as a serial echo. - -use usb_device::{bus::UsbBusAllocator, prelude::*}; -use usbd_serial::{SerialPort, USB_CLASS_CDC}; -use usbip_device::UsbIpBus; - -fn main() -> Result<(), Box> { - pretty_env_logger::init(); - - log::info!("initializing allocator"); - - let bus_allocator = UsbBusAllocator::new(UsbIpBus::new()); - let mut usb_serial = SerialPort::new(&bus_allocator); - let mut usb_bus = UsbDeviceBuilder::new(&bus_allocator, UsbVidPid(0x16c0, 0x27dd)) - .manufacturer("Fake company") - .product("Serial port") - .serial_number("TEST") - .device_class(USB_CLASS_CDC) - .build(); - - loop { - usb_bus.poll(&mut [&mut usb_serial]); - std::thread::sleep(std::time::Duration::from_millis(5)); - - let mut buf = [0; 64]; - if let Ok(count) = usb_serial.read(&mut buf) { - let text = String::from_utf8_lossy(&buf); - log::info!("read {} bytes: {}", count, text); - - // Send back, poll usb until we are ready - loop { - if let Ok(count) = usb_serial.write(&buf[0..count]) { - log::debug!("sent back {} bytes", count); - break; - } - usb_bus.poll(&mut [&mut usb_serial]); - } - } - } -} diff --git a/patches/usbip-device/examples/twitching_mouse.rs b/patches/usbip-device/examples/twitching_mouse.rs deleted file mode 100644 index 4e3027f..0000000 --- a/patches/usbip-device/examples/twitching_mouse.rs +++ /dev/null @@ -1,45 +0,0 @@ -//! This example registers a mouse as a HID device and then moves the -//! cursor down every couple of seconds. - -use usb_device::{bus::UsbBusAllocator, prelude::*}; -use usbd_hid::{ - descriptor::{generator_prelude::*, MouseReport}, - hid_class::HIDClass, -}; -use usbip_device::UsbIpBus; - -fn main() -> Result<(), Box> { - pretty_env_logger::init(); - - log::info!("initializing allocator"); - - let bus_allocator = UsbBusAllocator::new(UsbIpBus::new()); - let mut usb_hid = HIDClass::new(&bus_allocator, MouseReport::desc(), 5); - let mut usb_bus = UsbDeviceBuilder::new(&bus_allocator, UsbVidPid(0x16c0, 0x27dd)) - .manufacturer("Fake company") - .product("Twitchy Mousey") - .serial_number("TEST") - .device_class(0xEF) - .build(); - - let mut cnt = 0; - - loop { - std::thread::sleep(std::time::Duration::from_millis(5)); - cnt += 5; - - if cnt == 1000 { - let _ = usb_hid.push_input(&MouseReport { - x: 0, - y: 4, - buttons: 0, - wheel: 0, - pan: 0, - }); - - cnt = 0; - } - - usb_bus.poll(&mut [&mut usb_hid]); - } -} diff --git a/patches/usbip-device/src/cmd.rs b/patches/usbip-device/src/cmd.rs deleted file mode 100644 index 1f014c9..0000000 --- a/patches/usbip-device/src/cmd.rs +++ /dev/null @@ -1,86 +0,0 @@ -use std::{convert::TryInto, fmt::Debug}; - -/// The command type of the Urb -#[derive(Debug, Clone, Copy)] -pub enum UsbCmd { - Request, - UnlinkRequest, - Response, - UnlinkResponse, -} - -impl UsbCmd { - pub fn to_u32(self) -> u32 { - match self { - UsbCmd::Request => 1, - UsbCmd::UnlinkRequest => 2, - UsbCmd::Response => 3, - UsbCmd::UnlinkResponse => 4, - } - } - - pub fn try_from_u32(num: u32) -> Option { - match num { - 1 => Some(UsbCmd::Request), - 2 => Some(UsbCmd::UnlinkRequest), - 3 => Some(UsbCmd::Response), - 4 => Some(UsbCmd::UnlinkResponse), - _ => None, - } - } -} - -#[derive(Debug, Clone)] -pub struct UsbIpHeader { - pub command: UsbCmd, - pub seqnum: u32, - pub devid: u32, - pub direction: Direction, - pub ep: u32, -} - -impl UsbIpHeader { - pub fn to_array(&self) -> [u8; 20] { - let mut result = [0; 20]; - - result[0..4].copy_from_slice(&self.command.to_u32().to_be_bytes()); - result[4..8].copy_from_slice(&self.seqnum.to_be_bytes()); - result[8..12].copy_from_slice(&self.devid.to_be_bytes()); - result[12..16].copy_from_slice(&self.direction.bits().to_be_bytes()); - result[16..20].copy_from_slice(&self.ep.to_be_bytes()); - - result - } - - pub fn from_slice(data: &[u8]) -> Self { - Self { - command: UsbCmd::try_from_u32(u32::from_be_bytes(data[0..4].try_into().unwrap())) - .unwrap(), - seqnum: u32::from_be_bytes(data[4..8].try_into().unwrap()), - devid: u32::from_be_bytes(data[8..12].try_into().unwrap()), - direction: Direction::from_bits_truncate(u32::from_be_bytes( - data[12..16].try_into().unwrap(), - )), - ep: u32::from_be_bytes(data[16..20].try_into().unwrap()), - } - } -} - -bitflags::bitflags! { - pub struct TransferFlags: u32 { - const SHORT_NOT_OK = 0x00000001; - const ISO_ASAP = 0x00000002; - const NO_TRANSFER_DMA_MAP = 0x00000004; - const ZERO_PACKET = 0x00000040; - const NO_INTERRUPT = 0x00000080; - const FREE_BUFFER = 0x00000100; - const DIR_MASK = 0x00000200; - } -} - -bitflags::bitflags! { - pub struct Direction: u32 { - const OUT = 0x00000000; - const IN = 0x00000001; - } -} diff --git a/patches/usbip-device/src/debug.rs b/patches/usbip-device/src/debug.rs deleted file mode 100644 index 861c7e3..0000000 --- a/patches/usbip-device/src/debug.rs +++ /dev/null @@ -1,39 +0,0 @@ -//! A collection of functions which allow for better debug output. - -use std::fmt::{Debug, Formatter, LowerHex, Result as FmtResult}; - -/// Just a thin wrapper to allow for printing in hexadecimal -#[derive(Clone)] -pub struct DbgBuf<'a>(pub &'a [u8]); - -impl Debug for DbgBuf<'_> { - fn fmt(&self, f: &mut Formatter) -> FmtResult { - if self.0.len() == 0 { - return f.write_str("[]"); - } - - f.write_str("[ ")?; - f.write_fmt(format_args!("{:02x}", self))?; - f.write_str("]") - } -} - -impl LowerHex for DbgBuf<'_> { - fn fmt(&self, fmt: &mut Formatter) -> FmtResult { - for byte in self.0 { - (fmt.write_fmt(format_args!("{:02x} ", byte)))?; - } - Ok(()) - } -} - -#[derive(Clone)] -pub struct DbgEmpty; - -impl Debug for DbgEmpty { - fn fmt(&self, f: &mut Formatter) -> FmtResult { - f.write_str("(empty)") - } -} - -// TODO: Better output of Setup packets diff --git a/patches/usbip-device/src/handler.rs b/patches/usbip-device/src/handler.rs deleted file mode 100644 index d4d5b88..0000000 --- a/patches/usbip-device/src/handler.rs +++ /dev/null @@ -1,537 +0,0 @@ -use crate::{ - cmd::{Direction, TransferFlags, UsbCmd, UsbIpHeader}, - op::{OpDeviceDescriptor, OpInterfaceDescriptor, OpRequest, OpResponse, OpResponseCommand}, - request::{UsbIpCmdSubmit, UsbIpCmdUnlink, UsbIpRequest, UsbIpRequestCmd}, - response::{UsbIpResponse, UsbIpResponseCmd, UsbIpRetSubmit, UsbIpRetUnlink}, - UsbIpBusInner, -}; -use std::{ - io::{ErrorKind, Write}, - net::{TcpListener, TcpStream}, -}; -use usb_device::{endpoint::EndpointType, UsbError}; - -const ECONNRESET: i32 = 104; - -#[derive(Debug)] -pub struct SocketHandler { - listener: TcpListener, - connection: Option, -} - -impl SocketHandler { - /// Create a new handler - pub fn new() -> Self { - let listener = TcpListener::bind(("127.0.0.1", 3240)).unwrap(); - listener.set_nonblocking(true).unwrap(); - Self { - listener, - connection: None, - } - } - - pub fn is_connected(&self) -> bool { - self.connection.is_some() - } -} - -impl UsbIpBusInner { - pub fn handle_socket(&mut self) { - match self.handler.connection { - // If not connected, listen for new connections - None => match self.handler.listener.accept() { - Ok((connection, addr)) => { - log::info!("new connection from: {}", addr); - self.handler.connection = Some(connection) - } - Err(err) if err.kind() == ErrorKind::WouldBlock => (), - Err(err) => panic!("unexpected error: {}", err), - }, - - // If connected, receive the data - Some(ref mut stream) => { - match self.reset { - // If in reset state, answer op msgs - true => { - // in case of Op, we directly send a response here - let op = match OpRequest::read(stream) { - Ok(op) => op, - Err(err) if err.kind() == ErrorKind::WouldBlock => return, - Err(err) if err.kind() == ErrorKind::NotConnected => { - self.handler.connection = None; - return; - } - Err(err) => panic!("unexpected error {}", err), - }; - self.handle_op(op); - } - // If not in reset state, expect commands - false => { - let cmd = match UsbIpRequest::read(stream) { - Ok(cmd) => cmd, - Err(err) if err.kind() == ErrorKind::WouldBlock => return, - Err(err) if err.kind() == ErrorKind::NotConnected => { - // If the connection is no longer connected, return to initial state - self.reset = true; - self.handler.connection = None; - return; - } - Err(err) => panic!("unexpected error {}", err), - }; - self.handle_usbip_pkg(cmd); - } - } - } - } - } - - pub fn try_send_pending(&mut self, ep_addr: usize) { - let ep = match self.get_endpoint(ep_addr) { - Ok(ep) => ep, - Err(_) => return, - }; - - if !ep.is_rts() { - return; - } - - let (header, cmd, _) = match ep.pending_ins.pop_front() { - Some(urb) => urb, - None => return, - }; - let bytes_requested = cmd.transfer_buffer_length as usize; - - let ep_in = match ep.get_in() { - Ok(ep_in) => ep_in, - Err(UsbError::InvalidEndpoint) => return, - Err(e) => panic!("unexpected error {:?} while processing in packet", e), - }; - - // Read data from the packet buffer into the output buffer - // We must be careful to not send more bytes than requested - let mut out_buf = Vec::new(); - while let Some(mut data) = ep_in.data.pop_front() { - let remaining = bytes_requested.saturating_sub(out_buf.len()); - let chunk_len = data.len(); - - if remaining == 0 { - // We've already satisfied the host request; push the current - // data back so it can be used to service the next transfer. - ep_in.data.push_front(data); - break; - } - - if chunk_len <= remaining { - out_buf.extend_from_slice(&data); - } else { - out_buf.extend_from_slice(&data[..remaining]); - let leftover = data.split_off(remaining); - ep_in.data.push_front(leftover); - } - - // Control transactions are terminated by a short packet. When we - // see one, the transfer is complete even if the host requested - // more bytes than were queued by the device. - if chunk_len < ep_in.max_packet_size as usize { - break; - } - } - - // After sending, the in_complete can be set - ep.in_complete_flag = true; - - // TODO: Error if exact read was requested and out_buf.len() smaller than bytes_requested - - let response = UsbIpResponse { - header: UsbIpHeader { - command: UsbCmd::Response, - seqnum: header.seqnum, - devid: 2, - direction: Direction::IN, - ep: ep_addr as u32, - }, - cmd: UsbIpResponseCmd::Cmd(UsbIpRetSubmit { - status: 0, - actual_length: out_buf.len() as i32, - start_frame: 0, - number_of_packets: 0, - error_count: 0, - }), - data: out_buf, - }; - log::debug!("{:?}", response); - - self.handler - .connection - .as_mut() - .unwrap() - .write_all(&response.to_vec().unwrap()) - .unwrap(); - } - - /// Handles an incomming op packet, sends out the corresponding response - fn handle_op(&mut self, op: OpRequest) { - match op { - OpRequest::ListDevices(header) => { - let list_response = OpResponse { - version: header.version, - path: "/sys/devices/pci0000:00/0000:00:01.2/usb1/1-1".to_string(), - bus_id: "1-1".to_string(), - descriptor: OpDeviceDescriptor { - busnum: 1, - devnum: 2, - speed: self.device_speed, - - // These values should be settable via configuration - vendor: 0x1111, - product: 0x1010, - bcd_device: 0, - device_class: 0, - device_subclass: 0, - device_protocol: 0, - configuration_value: 0, - - // These are fixed for this implementation - num_configurations: 1, - num_interfaces: 1, - }, - cmd: OpResponseCommand::ListDevices(OpInterfaceDescriptor { - // TODO: Make these setable - interface_class: 0, - interface_subclass: 0, - interface_protocol: 0, - padding: 0, - }), - }; - - self.handler - .connection - .as_mut() - .unwrap() - .write_all(&list_response.to_vec().unwrap()) - .unwrap(); - } - OpRequest::ConnectDevice(header) => { - let list_response = OpResponse { - version: header.version, - path: "/sys/devices/pci0000:00/0000:00:01.2/usb1/1-1".to_string(), - bus_id: "1-1".to_string(), - descriptor: OpDeviceDescriptor { - busnum: 1, - devnum: 2, - speed: self.device_speed, - - // These values should be settable via configuration - vendor: 0x1111, - product: 0x1010, - bcd_device: 0, - device_class: 0, - device_subclass: 0, - device_protocol: 0, - configuration_value: 0, - - // These are fixed for this implementation - num_configurations: 1, - num_interfaces: 1, - }, - cmd: OpResponseCommand::ConnectDevice, - }; - - // Set the inner value to not reset, because we have connected the device - log::info!("device is leaving reset state"); - self.reset = false; - - self.handler - .connection - .as_mut() - .unwrap() - .write_all(&list_response.to_vec().unwrap()) - .unwrap(); - } - } - } - - fn handle_usbip_pkg(&mut self, request: UsbIpRequest) { - log::debug!("{:?}", request); - - match request.cmd { - UsbIpRequestCmd::Unlink(unlink) => self.handle_unlink(request.header, unlink), - UsbIpRequestCmd::Cmd(cmd) => self.handle_cmd(request.header, cmd, request.data), - } - } - - /// Handle a [`UsbIpCmdSubmit`] package - fn handle_cmd(&mut self, header: UsbIpHeader, cmd: UsbIpCmdSubmit, data: Vec) { - let mut control_abort_headers = Vec::new(); - - { - // Get the endpoint - let ep = match self.get_endpoint(header.ep as usize) { - Ok(ep) => ep, - Err(err) => { - log::warn!("reveiced message for unimplemented endpoint {:?}", err); - return; - } - }; - - let has_setup = cmd.setup != [0, 0, 0, 0, 0, 0, 0, 0]; - let is_control_setup = header.ep == 0 && has_setup; - - if is_control_setup { - match ep.get_in() { - Ok(ep_in) => { - if !ep_in.data.is_empty() { - log::debug!( - "clearing pending IN data for endpoint 0 after new SETUP" - ); - ep_in.data.clear(); - } - } - Err(err) => { - log::debug!("failed to access IN pipe for endpoint 0: {:?}", err); - } - } - - if !ep.pending_ins.is_empty() { - log::debug!( - "failing {} pending IN URBs for endpoint 0 after new SETUP", - ep.pending_ins.len() - ); - - while let Some((pending_header, _, _)) = ep.pending_ins.pop_front() { - control_abort_headers.push(pending_header); - } - } - } - - // check wether we have a setup packet - // NOTE: This assumes the control endpoints have no URBs pending - if has_setup { - ep.get_out().unwrap().data.push_back(cmd.setup.to_vec()); - ep.setup_flag = true; - } - - match header.direction { - Direction::OUT => { - let ep_out = ep.get_out().unwrap(); - - // pass the data into the correct buffers - for chunk in data.chunks(ep_out.max_packet_size as usize) { - ep_out.data.push_back(chunk.to_vec()); - } - - if cmd.transfer_flags.contains(TransferFlags::ZERO_PACKET) - && ep_out.ty == EndpointType::Bulk - { - ep_out.data.push_back(vec![]); - } - - self.ack_cmd_out(header.ep, header.seqnum, data.len()); - } - Direction::IN => { - let ep_addr = header.ep; - ep.pending_ins.push_back((header, cmd, data)); - self.try_send_pending(ep_addr as usize); - } - _ => panic!(), - } - } - - for pending_header in control_abort_headers { - let response = UsbIpResponse { - header: UsbIpHeader { - command: UsbCmd::Response, - seqnum: pending_header.seqnum, - devid: 2, - direction: Direction::IN, - ep: pending_header.ep, - }, - cmd: UsbIpResponseCmd::Cmd(UsbIpRetSubmit { - status: -ECONNRESET, - actual_length: 0, - start_frame: 0, - number_of_packets: 0, - error_count: 0, - }), - data: vec![], - }; - - match self.handler.connection.as_mut() { - Some(connection) => { - let response_bytes = response - .to_vec() - .expect("failed to serialize abort response"); - - if let Err(err) = connection.write_all(&response_bytes) { - log::warn!( - "failed to send abort response for seqnum {}: {:?}", - pending_header.seqnum, - err - ); - } - } - None => { - log::warn!( - "dropping pending IN URB {} without an active connection", - pending_header.seqnum - ); - } - } - } - } - - /// Send an acknowledgement after recieving a cmd out package. - fn ack_cmd_out(&mut self, ep: u32, seqnum: u32, len: usize) { - let response = UsbIpResponse { - header: UsbIpHeader { - command: UsbCmd::Response, - seqnum, - devid: 2, - direction: Direction::OUT, - ep, - }, - cmd: UsbIpResponseCmd::Cmd(UsbIpRetSubmit { - status: 0, - actual_length: len as i32, - start_frame: 0, - number_of_packets: 0, - error_count: 0, - }), - data: vec![], - }; - log::debug!("{:?}", response); - - self.handler - .connection - .as_mut() - .unwrap() - .write_all(&response.to_vec().unwrap()) - .unwrap(); - } - - /// Handle a received unlink package - fn handle_unlink(&mut self, header: UsbIpHeader, unlink: UsbIpCmdUnlink) { - match self.unlink(unlink.seqnum) { - true => (), - false => { - log::warn!( - "received request to remove urb {} that does not exists", - unlink.seqnum - ); - } - } - - self.ack_unlink(header.ep, header.seqnum); - } - - /// Send an acknowledgement after recieving an unlink package. - fn ack_unlink(&mut self, ep: u32, seqnum: u32) { - let response = UsbIpResponse { - header: UsbIpHeader { - command: UsbCmd::UnlinkResponse, - seqnum, - devid: 2, - direction: Direction::OUT, - ep, - }, - cmd: UsbIpResponseCmd::Unlink(UsbIpRetUnlink { status: 0 }), - data: vec![], - }; - log::debug!("{:?}", response); - - self.handler - .connection - .as_mut() - .unwrap() - .write_all(&response.to_vec().unwrap()) - .unwrap(); - } -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::Pipe; - use std::collections::VecDeque; - - fn make_control_pipe() -> Pipe { - Pipe { - data: VecDeque::new(), - ty: EndpointType::Control, - max_packet_size: 64, - interval: 0, - } - } - - #[test] - fn new_control_setup_clears_in_data() { - let mut bus = UsbIpBusInner::new(); - - bus.endpoint[0].pipe_in = Some(make_control_pipe()); - bus.endpoint[0].pipe_out = Some(make_control_pipe()); - - let stale_header = UsbIpHeader { - command: UsbCmd::Request, - seqnum: 42, - devid: 2, - direction: Direction::IN, - ep: 0, - }; - - let stale_cmd = UsbIpCmdSubmit { - transfer_flags: TransferFlags::empty(), - transfer_buffer_length: 0, - start_frame: 0, - number_of_packets: 0, - interval: 0, - setup: [0; 8], - }; - - bus.endpoint[0] - .pending_ins - .push_back((stale_header, stale_cmd, Vec::new())); - - if let Some(ref mut pipe_in) = bus.endpoint[0].pipe_in { - pipe_in.data.push_back(vec![0xAA; pipe_in.max_packet_size as usize]); - } - - let header = UsbIpHeader { - command: UsbCmd::Request, - seqnum: 1, - devid: 2, - direction: Direction::IN, - ep: 0, - }; - - let new_seqnum = header.seqnum; - - let cmd = UsbIpCmdSubmit { - transfer_flags: TransferFlags::empty(), - transfer_buffer_length: 0, - start_frame: 0, - number_of_packets: 0, - interval: 0, - setup: [1, 0, 0, 0, 0, 0, 0, 0], - }; - - bus.handle_cmd(header, cmd, Vec::new()); - - assert!( - bus.endpoint[0] - .pipe_in - .as_ref() - .expect("control IN pipe missing") - .data - .is_empty(), - "control endpoint IN data should be cleared before queuing IN request" - ); - - let pending_seqnums: Vec<_> = bus.endpoint[0] - .pending_ins - .iter() - .map(|(pending_header, _, _)| pending_header.seqnum) - .collect(); - - assert_eq!(pending_seqnums, vec![new_seqnum]); - } -} diff --git a/patches/usbip-device/src/lib.rs b/patches/usbip-device/src/lib.rs deleted file mode 100644 index c27a903..0000000 --- a/patches/usbip-device/src/lib.rs +++ /dev/null @@ -1,509 +0,0 @@ -pub(crate) mod cmd; -pub(crate) mod debug; -pub(crate) mod handler; -pub(crate) mod op; -pub(crate) mod request; -pub(crate) mod response; - -use crate::{cmd::UsbIpHeader, handler::SocketHandler, request::UsbIpCmdSubmit}; -use std::{ - collections::VecDeque, - sync::{Arc, Mutex, MutexGuard}, -}; -use usb_device::{ - Result as UsbResult, UsbDirection, UsbError, - { - bus::{PollResult, UsbBus}, - endpoint::{EndpointAddress, EndpointType}, - }, -}; - -#[derive(Debug, Clone)] -/// The error type, used by this crate. -pub enum UsbIpError { - /// The connection closed unexpectedly. - ConnectionClosed, - - /// A packet was received but it was shorter than the 48 bytes required to parse the header. - PkgTooShort(usize), - - /// A received packet contained a command, that is unknown to the USBIP specification. - InvalidCommand(u16), - - /// A received packet had a status field set to an unknown status value. - StatusNotOk(u32), -} - -impl std::fmt::Display for UsbIpError { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - Self::ConnectionClosed => write!(f, "connection no longer exsists"), - Self::PkgTooShort(len) => write!(f, "packet of length {} is to short to parse", len), - Self::InvalidCommand(cmd) => write!(f, "unknown command: {}", cmd), - Self::StatusNotOk(status) => write!(f, "received invalid status: {}", status), - } - } -} - -impl std::error::Error for UsbIpError {} - -const NUM_ENDPOINTS: usize = 8; - -#[derive(Debug, Clone)] -pub(crate) struct Pipe { - pub data: VecDeque>, - pub ty: EndpointType, - pub max_packet_size: u16, - #[allow(dead_code)] - pub interval: u8, -} - -impl Pipe { - /// Checks, whether the endpoint contains a full transaction - /// (terminated by a short packet) and is ready to send it. - pub fn is_rts(&self) -> bool { - match self.data.back() { - // If there is no data pending, we are not ready to send - None => false, - Some(val) => { - if self.ty != EndpointType::Control { - true - } else { - // Control Endpoint use packet transactions. - // Therefore, we must wait until a transaction is complete before we return the packets - val.len() < self.max_packet_size as usize - } - } - } - } -} - -#[derive(Debug, Clone)] -struct Endpoint { - pub(crate) pipe_in: Option, - pub(crate) pipe_out: Option, - pub(crate) pending_ins: VecDeque<(UsbIpHeader, UsbIpCmdSubmit, Vec)>, - pub(crate) stalled: bool, - pub(crate) setup_flag: bool, - pub(crate) in_complete_flag: bool, -} - -impl Default for Endpoint { - fn default() -> Self { - Self { - pipe_in: None, - pipe_out: None, - pending_ins: VecDeque::new(), - stalled: true, - setup_flag: false, - in_complete_flag: false, - } - } -} - -impl Endpoint { - /// Returns the input pipe of this endpoint - fn get_in(&mut self) -> UsbResult<&mut Pipe> { - self.pipe_in.as_mut().ok_or(UsbError::InvalidEndpoint) - } - - /// Returns the output pipe of this endpoint - fn get_out(&mut self) -> UsbResult<&mut Pipe> { - self.pipe_out.as_mut().ok_or(UsbError::InvalidEndpoint) - } - - /// Checks, whether the input pipe is ready to send data back to the host. - fn is_rts(&self) -> bool { - match self.pipe_in { - None => false, - Some(ref pipe) => pipe.is_rts(), - } - } - - /// Processes an unlink and removes the pending packet on this endpoint. - /// - /// # Returns - /// - `true` if pending urb was removed - /// - `false` if it was not found - // NOTE: This is super inefficient, use linked lists, as soon as linked_list_remove stabilizes - fn unlink(&mut self, seqnum: u32) -> bool { - let old_len = self.pending_ins.len(); - - self.pending_ins = self - .pending_ins - .drain(..) - .filter(|(header, _, _)| header.seqnum != seqnum) - .collect(); - - // If the length is the same as before, we have not changed anything - // and return false - old_len != self.pending_ins.len() - } -} - -#[derive(Debug)] -pub(crate) struct UsbIpBusInner { - pub handler: SocketHandler, - pub endpoint: [Endpoint; NUM_ENDPOINTS], - pub device_address: u8, - pub device_speed: u32, - pub reset: bool, - pub suspended: bool, -} - -impl UsbIpBusInner { - /// Creates a new UsbIpBusInner - fn new() -> Self { - Self { - handler: SocketHandler::new(), - endpoint: <[Endpoint; NUM_ENDPOINTS]>::default(), - device_address: 0, - device_speed: 3, - reset: true, - suspended: false, - } - } - - /// Resets the handler to the state, in which it acts like it is new - fn reset(&mut self) { - self.endpoint = <[Endpoint; NUM_ENDPOINTS]>::default(); - self.reset = true; - self.suspended = false; - } - - /// Returns the first enpoint, that is not already initialized or `None`, - /// if all are already in use. - fn next_available_endpoint(&self, direction: UsbDirection) -> Option { - match direction { - UsbDirection::In => { - for i in 1..NUM_ENDPOINTS { - if self.endpoint[i].pipe_in.is_none() { - return Some(i); - } - } - } - UsbDirection::Out => { - for i in 1..NUM_ENDPOINTS { - if self.endpoint[i].pipe_out.is_none() { - return Some(i); - } - } - } - } - - None - } - - /// Returns the requested endpoint if it exists and - /// [`UsbError::InvalidEndpoint`] otherwise. - fn get_endpoint(&mut self, ep: usize) -> UsbResult<&mut Endpoint> { - //let ep_addr = ep.index(); - - if ep >= NUM_ENDPOINTS { - log::error!("attempt to access out-of-bounds endpoint {:?}", ep); - return Err(UsbError::InvalidEndpoint); - } - - Ok(&mut self.endpoint[ep]) - } - - /// Processes an unlink and removes the pending packet. - /// - /// # Returns - /// - `true` if pending urb was removed - /// - `false` if it was not found - fn unlink(&mut self, seqnum: u32) -> bool { - for i in 0..NUM_ENDPOINTS { - if self.endpoint[i].unlink(seqnum) { - return true; - } - } - - false - } -} - -#[derive(Debug, Clone)] -/// An implementation of [`UsbBus`](https://docs.rs/usb-device/0.2.7/usb_device/bus/trait.UsbBus.html), -/// based on the Linux USBIP protocol. -pub struct UsbIpBus(Arc>); - -impl UsbIpBus { - /// Create a new [`UsbIpBus`]. - /// - /// # Note - /// There can only ever be one bus [`UsbIpBus`] device on the system, since - /// it is blocking port 3240. - /// - /// # Panics - /// If port 3240 is already in use. - pub fn new() -> Self { - Self(Arc::new(Mutex::new(UsbIpBusInner::new()))) - } - - fn lock(&self) -> MutexGuard<'_, UsbIpBusInner> { - self.0.lock().unwrap() - } - - /// Sets the USB device speed reported to the host. - pub fn set_device_speed(&self, speed: u32) { - let mut inner = self.lock(); - inner.device_speed = speed; - } -} - -impl Default for UsbIpBus { - fn default() -> Self { - Self::new() - } -} - -impl UsbBus for UsbIpBus { - fn alloc_ep( - &mut self, - ep_dir: UsbDirection, - ep_addr: Option, - ep_type: EndpointType, - max_packet_size: u16, - interval: u8, - ) -> UsbResult { - let mut inner = self.lock(); - - // Get the endpoint to initialize - let endpoint_index = match ep_addr { - Some(addr) => { - if addr.index() < NUM_ENDPOINTS { - addr.index() - } else { - return Err(UsbError::InvalidEndpoint); - } - } - None => inner - .next_available_endpoint(ep_dir) - .ok_or(UsbError::EndpointMemoryOverflow)?, - }; - - let endpoint = &mut inner.endpoint[endpoint_index as usize]; - - // check endpoint allocation here - let maybe_pipe = match ep_dir { - UsbDirection::In => endpoint.get_in(), - UsbDirection::Out => endpoint.get_out(), - }; - - // we want to get an invalid enpoint, otherwise the requested endpoint - // was already allocated - match maybe_pipe { - Err(UsbError::InvalidEndpoint) => (), - Ok(_) => return Err(UsbError::InvalidEndpoint), - Err(_) => return Err(UsbError::InvalidEndpoint), - } - - // initialize the endpoint - let pipe = Pipe { - data: VecDeque::new(), - ty: ep_type, - max_packet_size, - interval, - }; - match ep_dir { - UsbDirection::In => endpoint.pipe_in = Some(pipe), - UsbDirection::Out => endpoint.pipe_out = Some(pipe), - } - - log::debug!( - "initialized new endpoint {:?} as address {:?}", - endpoint, - endpoint_index - ); - - Ok(EndpointAddress::from_parts(endpoint_index as usize, ep_dir)) - } - - fn enable(&mut self) { - log::info!("usb device is being enabled"); - } - - fn reset(&self) { - let mut inner = self.lock(); - - // Skip if we are already in reset state - if inner.reset { - return; - } - - inner.reset(); - log::debug!("usb device is being reset"); - } - - fn set_device_address(&self, addr: u8) { - let mut inner = self.lock(); - - log::info!("setting device address to {}", addr); - inner.device_address = addr; - } - - fn write(&self, ep_addr: EndpointAddress, buf: &[u8]) -> UsbResult { - log::trace!("write request at endpoint {}", ep_addr.index()); - let mut inner = self.lock(); - - // We can not write anything, as long as there is no connection - if !inner.handler.is_connected() { - return Err(UsbError::WouldBlock); - } - - // Get the endpoint - let ep = inner.get_endpoint(ep_addr.index())?; - - // NOTE: This is a hack to allow driving the setup packets in a transactional way - // while the rest of the packets use packet logic - if ep_addr.index() == 0 { - ep.in_complete_flag = true; - } - - let pipe = ep.get_in()?; - - // If there is data waiting in the output buffer, we need to wait - if pipe.is_rts() { - if ep_addr.index() == 0 { - ep.in_complete_flag = false; - } - return Err(UsbError::WouldBlock); - } - - pipe.data.push_back(buf.to_vec()); - - // we attempt to service in packets, if we have them available - if pipe.is_rts() { - inner.try_send_pending(ep_addr.index()); - } - - Ok(buf.len()) - } - - fn read(&self, ep_addr: EndpointAddress, buf: &mut [u8]) -> UsbResult { - log::trace!("read request at endpoint {}", ep_addr.index()); - let mut inner = self.lock(); - let ep = inner.get_endpoint(ep_addr.index())?; - let pipe = ep.get_out()?; - - // Try to get data - let data = match pipe.data.pop_front() { - None => { - log::trace!("no data available at endpoint"); - return Err(UsbError::WouldBlock); - } - Some(data) => data, - }; - - if buf.len() < data.len() { - buf.copy_from_slice(&data[..buf.len()]); - } else { - buf[..data.len()].copy_from_slice(&data); - } - Ok(data.len()) - } - - fn set_stalled(&self, ep_addr: EndpointAddress, stalled: bool) { - let mut inner = self.lock(); - - let endpoint = match inner.get_endpoint(ep_addr.index()) { - Ok(endpoint) => endpoint, - _ => return, - }; - - if endpoint.stalled != stalled { - log::debug!( - "setting endpoint {:?} to stalled state {}", - ep_addr, - stalled - ); - } - endpoint.stalled = stalled; - } - - fn is_stalled(&self, ep_addr: EndpointAddress) -> bool { - let mut inner = self.lock(); - - let endpoint = match inner.get_endpoint(ep_addr.index()) { - Ok(endpoint) => endpoint, - _ => return false, - }; - - endpoint.stalled - } - - fn suspend(&self) { - let mut inner = self.lock(); - - log::info!("suspending device"); - if inner.suspended { - log::warn!("supending already suspended device"); - } - - inner.suspended = true; - } - - fn resume(&self) { - let mut inner = self.lock(); - - log::info!("resuming device"); - if !inner.suspended { - log::warn!("resuming already active device"); - } - - inner.suspended = false; - } - - fn poll(&self) -> PollResult { - let mut inner = self.lock(); - log::trace!("usb device is being polled"); - - inner.handle_socket(); - - if inner.reset { - log::trace!("device is in reset state"); - return PollResult::Reset; - } - - if inner.suspended { - log::trace!("device is suspended"); - return PollResult::Suspend; - } - - let mut ep_in: u16 = 0; - let mut ep_out: u16 = 0; - let mut ep_setup: u16 = 0; - - for i in (0..NUM_ENDPOINTS).into_iter().rev() { - ep_in <<= 1; - ep_out <<= 1; - ep_setup <<= 1; - - let ep = &mut inner.endpoint[i]; - - // Check for pending output - if let Some(ref pipe) = ep.pipe_out { - if !pipe.data.is_empty() { - ep_out |= 1; - } - } - - if ep.in_complete_flag { - ep.in_complete_flag = false; - ep_in |= 1; - } - - if ep.setup_flag { - ep.setup_flag = false; - ep_setup |= 1; - } - } - - PollResult::Data { - ep_out, - ep_in_complete: ep_in, - ep_setup, - } - } -} diff --git a/patches/usbip-device/src/op.rs b/patches/usbip-device/src/op.rs deleted file mode 100644 index 6388196..0000000 --- a/patches/usbip-device/src/op.rs +++ /dev/null @@ -1,239 +0,0 @@ -use crate::UsbIpError; -use std::{ - convert::TryInto, - io::{Error, ErrorKind, Read}, - net::TcpStream, -}; - -#[repr(C)] -#[derive(Debug, Clone)] -pub struct OpHeader { - pub version: u16, - pub command: u16, - pub status: u32, -} - -impl OpHeader { - fn to_array(&self) -> [u8; 8] { - let mut result = [0; 8]; - - result[0..2].copy_from_slice(&self.version.to_be_bytes()); - result[2..4].copy_from_slice(&self.command.to_be_bytes()); - result[4..8].copy_from_slice(&self.status.to_be_bytes()); - - result - } - - fn from_slice(data: &[u8]) -> Self { - Self { - version: u16::from_be_bytes(data[0..2].try_into().unwrap()), - command: u16::from_be_bytes(data[2..4].try_into().unwrap()), - status: u32::from_be_bytes(data[4..8].try_into().unwrap()), - } - } -} - -pub enum OpRequest { - ListDevices(OpHeader), - ConnectDevice(OpHeader), -} - -impl OpRequest { - pub fn read(reader: &mut TcpStream) -> Result { - // Receive the header - reader.set_nonblocking(true)?; - let mut header_buf = [0; 8]; - match reader.read(&mut header_buf) { - Ok(bytes_read) if bytes_read == 8 => (), - Ok(0) => { - return Err(Error::new( - ErrorKind::NotConnected, - Box::new(UsbIpError::ConnectionClosed), - )) - } - Ok(bytes_read) => { - return Err(Error::new( - ErrorKind::InvalidInput, - Box::new(UsbIpError::PkgTooShort(bytes_read)), - )) - } - Err(err) => return Err(err), - } - reader.set_nonblocking(false)?; - - // Parse the header - let header = OpHeader::from_slice(&header_buf); - - // Check status - if header.status != 0 { - return Err(Error::new( - ErrorKind::InvalidInput, - Box::new(UsbIpError::StatusNotOk(header.status)), - )); - } - - log::debug!("request version is {}", header.version); - - // Dispatch on command - match header.command { - 0x8005 => { - log::info!("received request to list devices"); - Ok(Self::ListDevices(header)) - } - 0x8003 => { - let mut bus_id_buf = [0; 32]; - reader.read_exact(&mut bus_id_buf)?; - - let bus_id = match std::str::from_utf8(&bus_id_buf) { - Ok(data) => data.trim_matches(char::from(0)).to_string(), - Err(err) => { - return Err(Error::new(ErrorKind::InvalidInput, err)); - } - }; - - log::info!("received request to connect device {}", bus_id); - Ok(Self::ConnectDevice(header)) - } - _ => Err(Error::new( - ErrorKind::InvalidInput, - Box::new(UsbIpError::InvalidCommand(header.command)), - )), - } - } -} - -#[derive(Debug, Clone)] -pub struct OpResponse { - pub version: u16, - pub path: String, - pub bus_id: String, - pub descriptor: OpDeviceDescriptor, - pub cmd: OpResponseCommand, -} - -#[derive(Debug, Clone)] -pub enum OpResponseCommand { - ListDevices(OpInterfaceDescriptor), - ConnectDevice, -} - -impl OpResponse { - pub fn to_vec(&self) -> Option> { - let mut result = vec![]; - - // Build and serialize the header - let reply: u16 = match self.cmd { - OpResponseCommand::ListDevices(_) => 0x0005, - OpResponseCommand::ConnectDevice => 0x0003, - }; - - let header = OpHeader { - version: self.version, - command: reply, - status: 0, - }; - - result.extend_from_slice(&header.to_array()); - - match self.cmd { - // This implementation can only ever export one device, - // therefore number of exported devices is fixed - OpResponseCommand::ListDevices(_) => result.extend_from_slice(&[0, 0, 0, 1]), - OpResponseCommand::ConnectDevice => (), - }; - - // Serialize path - let str_len = self.path.as_bytes().len(); - if str_len > 256 { - log::warn!("path is longer than 256 bytes"); - return None; - } - - let mut path_buf = [0; 256]; - path_buf[..str_len].copy_from_slice(self.path.as_bytes()); - result.extend_from_slice(&path_buf); - - // Serialize bus_id - let str_len = self.bus_id.as_bytes().len(); - if str_len > 32 { - log::warn!("bus_id is longr than 32 bytes"); - return None; - } - - let mut bus_id_buf = [0; 32]; - bus_id_buf[..str_len].copy_from_slice(self.bus_id.as_bytes()); - result.extend_from_slice(&bus_id_buf); - - // Serialize the Op Desciptor - result.extend_from_slice(&self.descriptor.to_array()); - - // If exists, serialize the interface descriptor - if let OpResponseCommand::ListDevices(ref interface) = self.cmd { - result.extend_from_slice(&interface.to_array()); - } - - Some(result) - } -} - -#[repr(C)] -#[derive(Debug, Clone)] -pub struct OpDeviceDescriptor { - pub busnum: u32, - pub devnum: u32, - pub speed: u32, - pub vendor: u16, - pub product: u16, - pub bcd_device: u16, - pub device_class: u8, - pub device_subclass: u8, - pub device_protocol: u8, - pub configuration_value: u8, - pub num_configurations: u8, - pub num_interfaces: u8, -} - -impl OpDeviceDescriptor { - fn to_array(&self) -> [u8; 24] { - let mut result = [0; 24]; - - result[0..4].copy_from_slice(&self.busnum.to_be_bytes()); - result[4..8].copy_from_slice(&self.devnum.to_be_bytes()); - result[8..12].copy_from_slice(&self.speed.to_be_bytes()); - - result[12..14].copy_from_slice(&self.vendor.to_be_bytes()); - result[14..16].copy_from_slice(&self.product.to_be_bytes()); - result[16..18].copy_from_slice(&self.bcd_device.to_be_bytes()); - - result[18..24].copy_from_slice(&[ - self.device_class, - self.device_subclass, - self.device_protocol, - self.configuration_value, - self.num_configurations, - self.num_interfaces, - ]); - - result - } -} - -#[repr(C)] -#[derive(Debug, Clone)] -pub struct OpInterfaceDescriptor { - pub interface_class: u8, - pub interface_subclass: u8, - pub interface_protocol: u8, - pub padding: u8, -} - -impl OpInterfaceDescriptor { - fn to_array(&self) -> [u8; 4] { - [ - self.interface_class, - self.interface_subclass, - self.interface_protocol, - self.padding, - ] - } -} diff --git a/patches/usbip-device/src/request.rs b/patches/usbip-device/src/request.rs deleted file mode 100644 index a9a309c..0000000 --- a/patches/usbip-device/src/request.rs +++ /dev/null @@ -1,158 +0,0 @@ -use crate::{ - cmd::{Direction, TransferFlags, UsbCmd, UsbIpHeader}, - debug::{DbgBuf, DbgEmpty}, - UsbIpError, -}; -use std::{ - convert::TryInto, - fmt::{Debug, Formatter, Result as FmtResult}, - io::{Error, ErrorKind, Read}, - net::TcpStream, -}; - -#[derive(Clone)] -pub struct UsbIpRequest { - pub header: UsbIpHeader, - pub cmd: UsbIpRequestCmd, - pub data: Vec, -} - -impl Debug for UsbIpRequest { - fn fmt(&self, f: &mut Formatter) -> FmtResult { - f.debug_struct("UsbIpRequest") - .field("header", &self.header) - .field("cmd", &self.cmd) - .field("data", &DbgBuf(&self.data)) - .finish() - } -} - -#[derive(Debug, Clone)] -pub enum UsbIpRequestCmd { - Cmd(UsbIpCmdSubmit), - Unlink(UsbIpCmdUnlink), -} - -impl UsbIpRequest { - pub fn read(reader: &mut TcpStream) -> Result { - // Read an parse header - reader.set_nonblocking(true)?; - let mut buf = [0; 48]; - match reader.read(&mut buf) { - Ok(bytes_read) if bytes_read == 48 => (), - Ok(0) => { - return Err(Error::new( - ErrorKind::NotConnected, - Box::new(UsbIpError::ConnectionClosed), - )) - } - Ok(bytes_read) => { - return Err(Error::new( - ErrorKind::InvalidInput, - Box::new(UsbIpError::PkgTooShort(bytes_read)), - )) - } - Err(err) => return Err(err), - } - reader.set_nonblocking(false)?; - - let header = UsbIpHeader::from_slice(&buf[0..20]); - match header.command { - UsbCmd::Request => { - let cmd = UsbIpCmdSubmit::from_slice(&buf[20..48]); - - // Receive the URB if this is a OUT packet - let data = if header.direction == Direction::OUT && cmd.transfer_buffer_length != 0 - { - // NOTE: Reading 0 bytes would still block the reader - let mut data = vec![0; cmd.transfer_buffer_length as usize]; - reader.read_exact(&mut data)?; - - data - } else { - vec![] - }; - - //Ok(Self::Cmd(header, cmd, data)) - Ok(Self { - header, - cmd: UsbIpRequestCmd::Cmd(cmd), - data, - }) - } - UsbCmd::UnlinkRequest => { - let unlink = UsbIpCmdUnlink::from_slice(&buf[20..24]); - - // NOTE: We do not expect to see urb data behind an unlink - - Ok(Self { - header, - cmd: UsbIpRequestCmd::Unlink(unlink), - data: vec![], - }) - } - _ => Err(Error::new( - ErrorKind::InvalidInput, - Box::new(UsbIpError::InvalidCommand(header.command as u16)), - )), - } - } -} - -#[derive(Clone)] -pub struct UsbIpCmdSubmit { - pub transfer_flags: TransferFlags, - pub transfer_buffer_length: i32, - pub start_frame: i32, - pub number_of_packets: i32, - pub interval: i32, - pub setup: [u8; 8], -} - -impl Debug for UsbIpCmdSubmit { - /// As `start_frame`, `number_of_packets` and `interval` are unused as of now, - /// they are not being printed - fn fmt(&self, f: &mut Formatter) -> FmtResult { - // Only output setup bytes, if they are relevant - let setup_dbg = DbgBuf(&self.setup); - let setup: &dyn Debug = if self.setup != [0, 0, 0, 0, 0, 0, 0, 0] { - &setup_dbg - } else { - &DbgEmpty - }; - - f.debug_struct("UsbIpCmdSubmit") - .field("transfer_flags", &self.transfer_flags) - .field("transfer_buffer_length", &self.transfer_buffer_length) - .field("setup", &setup) - .finish() - } -} - -impl UsbIpCmdSubmit { - fn from_slice(data: &[u8]) -> Self { - Self { - transfer_flags: TransferFlags::from_bits_truncate(u32::from_be_bytes( - data[0..4].try_into().unwrap(), - )), - transfer_buffer_length: i32::from_be_bytes(data[4..8].try_into().unwrap()), - start_frame: i32::from_be_bytes(data[8..12].try_into().unwrap()), - number_of_packets: i32::from_be_bytes(data[12..16].try_into().unwrap()), - interval: i32::from_be_bytes(data[16..20].try_into().unwrap()), - setup: data[20..28].try_into().unwrap(), - } - } -} - -#[derive(Debug, Clone)] -pub struct UsbIpCmdUnlink { - pub seqnum: u32, -} - -impl UsbIpCmdUnlink { - fn from_slice(data: &[u8]) -> Self { - Self { - seqnum: u32::from_be_bytes(data[0..4].try_into().unwrap()), - } - } -} diff --git a/patches/usbip-device/src/response.rs b/patches/usbip-device/src/response.rs deleted file mode 100644 index 533aa06..0000000 --- a/patches/usbip-device/src/response.rs +++ /dev/null @@ -1,96 +0,0 @@ -use crate::{cmd::UsbIpHeader, debug::DbgBuf}; -use std::fmt::{Debug, Formatter, Result as FmtResult}; - -#[derive(Clone)] -pub struct UsbIpResponse { - pub header: UsbIpHeader, - pub cmd: UsbIpResponseCmd, - pub data: Vec, -} - -impl Debug for UsbIpResponse { - fn fmt(&self, f: &mut Formatter) -> FmtResult { - f.debug_struct("UsbIpResponse") - .field("header", &self.header) - .field("cmd", &self.cmd) - .field("data", &DbgBuf(&self.data)) - .finish() - } -} - -#[derive(Debug, Clone)] -pub enum UsbIpResponseCmd { - Cmd(UsbIpRetSubmit), - Unlink(UsbIpRetUnlink), -} - -impl UsbIpResponse { - pub fn to_vec(&self) -> Option> { - let mut result = vec![]; - - // Parse the header - result.extend_from_slice(&self.header.to_array()); - - // parse the command - match self.cmd { - UsbIpResponseCmd::Cmd(ref cmd) => { - result.extend_from_slice(&cmd.to_array()); - } - UsbIpResponseCmd::Unlink(ref unlink) => { - result.extend_from_slice(&unlink.to_array()); - } - } - - // parse the data - result.extend_from_slice(&self.data[..]); - - Some(result) - } -} - -#[derive(Clone)] -pub struct UsbIpRetSubmit { - pub status: i32, - pub actual_length: i32, - pub start_frame: i32, - pub number_of_packets: i32, - pub error_count: i32, -} - -impl Debug for UsbIpRetSubmit { - /// As `start_frame`, `number_of_packets` and `error_count` are unused as of now, - /// they are not being printed - fn fmt(&self, f: &mut Formatter) -> FmtResult { - f.debug_struct("UsbIpRetSubmit") - .field("status", &self.status) - .field("actual_length", &self.actual_length) - .finish() - } -} - -impl UsbIpRetSubmit { - fn to_array(&self) -> [u8; 28] { - let mut result = [0; 28]; - - result[0..4].copy_from_slice(&self.status.to_be_bytes()); - result[4..8].copy_from_slice(&self.actual_length.to_be_bytes()); - result[8..12].copy_from_slice(&self.start_frame.to_be_bytes()); - result[12..16].copy_from_slice(&self.number_of_packets.to_be_bytes()); - result[16..20].copy_from_slice(&self.error_count.to_be_bytes()); - - result - } -} - -#[derive(Debug, Clone)] -pub struct UsbIpRetUnlink { - pub status: u32, -} - -impl UsbIpRetUnlink { - fn to_array(&self) -> [u8; 28] { - let mut result = [0; 28]; - result[0..4].copy_from_slice(&self.status.to_be_bytes()); - result - } -} diff --git a/pc-hid-runner/Cargo.toml b/pc-hid-runner/Cargo.toml index adb60a8..79b0c43 100644 --- a/pc-hid-runner/Cargo.toml +++ b/pc-hid-runner/Cargo.toml @@ -2,7 +2,6 @@ name = "pc-hid-runner" version = "0.1.0" edition = "2021" -default-run = "pc-hid-runner" [dependencies] ctaphid-dispatch = { version = "0.3", features = ["log-all"] } @@ -22,15 +21,9 @@ trussed = { version = "0.1", default-features = false, features = ["log-all", "v authenticator = { path = "../authenticator" } daemonize = "0.4" rand = { version = "0.8", features = ["std"] } - -[dependencies.pc-usbip-runner] -optional = true -package = "trussed-usbip" -path = "../pc-usbip-runner" +sha2 = "0.10" [features] default = ["uhid-backend"] uhid-backend = [] -usbip-backend = ["pc-usbip-runner", "pc-usbip-runner/ctaphid"] ctaphid = [] -ccid = [] diff --git a/pc-hid-runner/src/bin/authenticator.rs b/pc-hid-runner/src/bin/authenticator.rs deleted file mode 100644 index 31b12b9..0000000 --- a/pc-hid-runner/src/bin/authenticator.rs +++ /dev/null @@ -1,3 +0,0 @@ -fn main() -> std::io::Result<()> { - pc_hid_runner::cli::run_cli() -} diff --git a/pc-hid-runner/src/cli.rs b/pc-hid-runner/src/cli.rs index fb95fe2..335905f 100644 --- a/pc-hid-runner/src/cli.rs +++ b/pc-hid-runner/src/cli.rs @@ -7,7 +7,6 @@ use std::{ time::{Duration, Instant}, }; -use authenticator::ctap::PqcPolicy; use clap::{Args, Parser, Subcommand, ValueEnum}; use clap_num::maybe_hex; use daemonize::Daemonize; @@ -34,12 +33,69 @@ pub struct Cli { #[derive(Subcommand, Debug)] pub enum Command { - /// Start the authenticator service - Start(StartCommand), - /// Stop a running authenticator service - Stop(StateArgs), + /// Start the authenticator service and expose the virtual security key + #[clap(alias = "start")] + Attach(StartCommand), + /// Stop the authenticator service and remove the virtual security key + #[clap(alias = "stop")] + Detach(StateArgs), /// Show service status Status(StateArgs), + /// Wipe all credentials and PIN state (requires the daemon to be detached) + Reset(ResetArgs), + /// Manage the authenticator PIN + Pin(PinCommand), +} + +#[derive(Args, Debug, Clone)] +pub struct ResetArgs { + #[clap(flatten)] + pub state: StateArgs, + /// Skip the interactive confirmation prompt + #[clap(long)] + pub yes: bool, +} + +#[derive(Args, Debug, Clone)] +pub struct PinCommand { + #[clap(subcommand)] + pub action: PinAction, +} + +#[derive(Subcommand, Debug, Clone)] +pub enum PinAction { + /// Set a new PIN on a PIN-less authenticator + Set { + #[clap(flatten)] + state: StateArgs, + /// PIN value (omit to be prompted) + #[clap(long)] + pin: Option, + }, + /// Change the existing PIN + Change { + #[clap(flatten)] + state: StateArgs, + /// Current PIN (omit to be prompted) + #[clap(long, value_name = "CURRENT_PIN")] + current: Option, + /// New PIN (omit to be prompted) + #[clap(long, value_name = "NEW_PIN")] + new: Option, + }, + /// Remove the PIN entirely + Remove { + #[clap(flatten)] + state: StateArgs, + /// Current PIN (omit to be prompted) + #[clap(long)] + current: Option, + }, + /// Show whether a PIN is set, retries remaining, and block status + Status { + #[clap(flatten)] + state: StateArgs, + }, } #[derive(Args, Debug, Clone)] @@ -98,9 +154,6 @@ pub struct DeviceArgs { /// Suppress attestation certificate material for makeCredential operations #[clap(long)] pub suppress_attestation: bool, - /// Policy controlling whether PQC PIN/UV is preferred, required, or disabled - #[clap(long, value_enum, default_value_t = PqcPolicyArg::Prefer)] - pub pqc_policy: PqcPolicyArg, /// Backend transport to use #[clap(long, value_enum, default_value_t = BackendArg::Uhid)] pub backend: BackendArg, @@ -109,33 +162,12 @@ pub struct DeviceArgs { #[derive(Copy, Clone, Debug, ValueEnum, PartialEq, Eq)] pub enum BackendArg { Uhid, - #[cfg(feature = "usbip-backend")] - Usbip, -} - -#[derive(Copy, Clone, Debug, ValueEnum, PartialEq, Eq)] -pub enum PqcPolicyArg { - Prefer, - ClassicOnly, - Require, -} - -impl From for PqcPolicy { - fn from(value: PqcPolicyArg) -> Self { - match value { - PqcPolicyArg::Prefer => PqcPolicy::PreferPqc, - PqcPolicyArg::ClassicOnly => PqcPolicy::ClassicOnly, - PqcPolicyArg::Require => PqcPolicy::RequirePqc, - } - } } impl BackendArg { fn into_backend(self) -> service::Backend { match self { BackendArg::Uhid => service::Backend::Uhid, - #[cfg(feature = "usbip-backend")] - BackendArg::Usbip => service::Backend::Usbip, } } } @@ -175,7 +207,6 @@ impl StartCommand { }, auto_user_presence: !self.device.manual_user_presence, suppress_attestation: self.device.suppress_attestation, - pqc_policy: self.device.pqc_policy.into(), backend: self.device.backend.into_backend(), }) } @@ -379,8 +410,114 @@ fn status(state: StateArgs) -> io::Result<()> { pub fn run_cli() -> io::Result<()> { let cli = Cli::parse(); match cli.command { - Command::Start(cmd) => start(cmd), - Command::Stop(state) => stop(state), + Command::Attach(cmd) => start(cmd), + Command::Detach(state) => stop(state), Command::Status(state) => status(state), + Command::Reset(args) => reset(args), + Command::Pin(cmd) => pin(cmd), + } +} + +fn require_daemon_stopped(state: &StateArgs) -> io::Result<()> { + if let Some(pid) = read_pid(&state.pid_path())? { + if process_running(pid) { + return Err(io::Error::new( + io::ErrorKind::Other, + format!( + "authenticator daemon is running (pid {pid}); run 'feitian-authenticator detach' first" + ), + )); + } + } + Ok(()) +} + +fn confirm(prompt: &str) -> io::Result { + use std::io::{BufRead, BufReader}; + eprint!("{prompt} [y/N] "); + use std::io::Write; + std::io::stderr().flush().ok(); + let stdin = std::io::stdin(); + let mut line = String::new(); + BufReader::new(stdin.lock()).read_line(&mut line)?; + Ok(matches!(line.trim(), "y" | "Y" | "yes" | "YES" | "Yes")) +} + +fn read_pin_interactive(prompt: &str) -> io::Result { + use std::io::Write; + eprint!("{prompt}: "); + std::io::stderr().flush().ok(); + let mut buf = String::new(); + std::io::stdin().read_line(&mut buf)?; + Ok(buf.trim_end_matches(['\n', '\r']).to_string()) +} + +fn reset(args: ResetArgs) -> io::Result<()> { + require_daemon_stopped(&args.state)?; + service::ensure_state_dir(&args.state.state_dir)?; + if !args.yes + && !confirm(&format!( + "This will wipe ALL credentials and PIN state under {}. Continue?", + args.state.state_dir.display() + ))? + { + eprintln!("Reset cancelled."); + return Ok(()); } + service::reset_state(&args.state.state_dir)?; + println!("Authenticator state has been reset."); + Ok(()) +} + +fn pin(cmd: PinCommand) -> io::Result<()> { + match cmd.action { + PinAction::Status { state } => pin_status(state), + PinAction::Set { state, pin } => { + require_daemon_stopped(&state)?; + let pin = match pin { + Some(value) => value, + None => read_pin_interactive("New PIN")?, + }; + service::pin_set(&state.state_dir, &pin)?; + println!("PIN set."); + Ok(()) + } + PinAction::Change { + state, + current, + new, + } => { + require_daemon_stopped(&state)?; + let current = match current { + Some(value) => value, + None => read_pin_interactive("Current PIN")?, + }; + let new = match new { + Some(value) => value, + None => read_pin_interactive("New PIN")?, + }; + service::pin_change(&state.state_dir, ¤t, &new)?; + println!("PIN changed."); + Ok(()) + } + PinAction::Remove { state, current } => { + require_daemon_stopped(&state)?; + let current = match current { + Some(value) => value, + None => read_pin_interactive("Current PIN")?, + }; + service::pin_remove(&state.state_dir, ¤t)?; + println!("PIN removed."); + Ok(()) + } + } +} + +fn pin_status(state: StateArgs) -> io::Result<()> { + service::ensure_state_dir(&state.state_dir)?; + let info = service::pin_info(&state.state_dir)?; + println!("PIN set: {}", info.is_set); + println!("Retries remaining: {}", info.retries); + println!("Blocked: {}", info.blocked); + Ok(()) } diff --git a/pc-hid-runner/src/service.rs b/pc-hid-runner/src/service.rs index 131070a..f3d5156 100644 --- a/pc-hid-runner/src/service.rs +++ b/pc-hid-runner/src/service.rs @@ -3,10 +3,11 @@ use std::{ path::{Path, PathBuf}, }; -use authenticator::ctap::{CtapApp, PqcPolicy}; -#[cfg(feature = "usbip-backend")] -use pc_usbip_runner::{exec as usbip_exec, Builder as UsbipBuilder}; -use transport_core::state::{IdentityConfig, PersistentStore}; +use authenticator::ctap::CtapApp; +use sha2::{Digest, Sha256}; +use transport_core::state::{ + reset_state_dir, IdentityConfig, PersistentStore, StoredPinState, DEFAULT_PIN_RETRIES, +}; use transport_core::{set_waiting, Apps as TrussedApps, Builder, Options, Platform, Syscall}; use trussed::{ backend::{CoreOnly, NoId}, @@ -20,8 +21,6 @@ use crate::{exec, HidDeviceDescriptor, CTAPHID_FRAME_LEN}; #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub enum Backend { Uhid, - #[cfg(feature = "usbip-backend")] - Usbip, } #[derive(Clone)] @@ -39,7 +38,6 @@ pub struct RunnerConfig { pub identity: IdentityStrings, pub auto_user_presence: bool, pub suppress_attestation: bool, - pub pqc_policy: PqcPolicy, pub backend: Backend, } @@ -48,7 +46,6 @@ pub struct AppData { pub aaguid: [u8; 16], pub auto_user_presence: bool, pub suppress_attestation: bool, - pub pqc_policy: PqcPolicy, } pub struct Apps { @@ -72,7 +69,6 @@ impl<'a> TrussedApps<'a, CoreOnly> for Apps { let mut ctap = CtapApp::new(client, data.aaguid); ctap.set_auto_user_presence(data.auto_user_presence); ctap.suppress_attestation(data.suppress_attestation); - ctap.set_pqc_policy(data.pqc_policy); ctap.set_keepalive_callback(set_waiting); Self { ctap } } @@ -83,14 +79,6 @@ impl<'a> TrussedApps<'a, CoreOnly> for Apps { ) -> T { f(&mut [&mut self.ctap]) } - - #[cfg(feature = "ccid")] - fn with_ccid_apps( - &mut self, - f: impl FnOnce(&mut [&mut dyn apdu_dispatch::app::App]) -> T, - ) -> T { - f(&mut []) - } } pub fn run(config: RunnerConfig) -> io::Result<()> { @@ -102,7 +90,6 @@ pub fn run(config: RunnerConfig) -> io::Result<()> { identity, auto_user_presence, suppress_attestation, - pqc_policy, backend, } = config; @@ -119,7 +106,6 @@ pub fn run(config: RunnerConfig) -> io::Result<()> { aaguid, auto_user_presence, suppress_attestation, - pqc_policy, }; match backend { @@ -127,11 +113,6 @@ pub fn run(config: RunnerConfig) -> io::Result<()> { let runner = Builder::new(options).build::(); exec(runner, descriptor, platform, data) } - #[cfg(feature = "usbip-backend")] - Backend::Usbip => { - let runner = UsbipBuilder::new(options).build::(); - usbip_exec(runner, platform, data) - } } } @@ -177,3 +158,134 @@ pub fn default_identity() -> IdentityStrings { pub fn ensure_state_dir(path: &Path) -> io::Result<()> { transport_core::state::ensure_state_dir(path) } + +/// Minimum PIN length enforced by the CTAP layer. +const MIN_PIN_LENGTH: usize = 4; +/// Maximum PIN length permitted by CTAP (63 byte UTF-8 string max). +const MAX_PIN_LENGTH: usize = 63; + +fn validate_pin(pin: &str) -> io::Result<()> { + let bytes = pin.as_bytes(); + if bytes.len() < MIN_PIN_LENGTH { + return Err(io::Error::new( + io::ErrorKind::InvalidInput, + format!("PIN must be at least {MIN_PIN_LENGTH} bytes"), + )); + } + if bytes.len() > MAX_PIN_LENGTH { + return Err(io::Error::new( + io::ErrorKind::InvalidInput, + format!("PIN must be at most {MAX_PIN_LENGTH} bytes"), + )); + } + Ok(()) +} + +fn hash_pin(pin: &str) -> [u8; 16] { + let digest = Sha256::digest(pin.as_bytes()); + let mut out = [0u8; 16]; + out.copy_from_slice(&digest[..16]); + out +} + +/// Summary view of the persistent PIN state for the `pin status` CLI. +pub struct PinInfo { + pub is_set: bool, + pub retries: u8, + pub blocked: bool, +} + +/// Read the persistent PIN summary for the CLI. +pub fn pin_info(state_dir: &Path) -> io::Result { + let store = PersistentStore::new(state_dir)?; + let state = store.read_pin_state()?; + Ok(PinInfo { + is_set: state.pin_hash.is_some(), + retries: state.pin_retries, + blocked: state.pin_auth_blocked, + }) +} + +/// Persist a brand-new PIN. Fails if a PIN is already set. +pub fn pin_set(state_dir: &Path, new_pin: &str) -> io::Result<()> { + validate_pin(new_pin)?; + let store = PersistentStore::new(state_dir)?; + let existing = store.read_pin_state()?; + if existing.pin_hash.is_some() { + return Err(io::Error::new( + io::ErrorKind::AlreadyExists, + "a PIN is already set; use 'pin change' instead", + )); + } + let updated = StoredPinState { + pin_hash: Some(hash_pin(new_pin)), + pin_retries: DEFAULT_PIN_RETRIES, + consecutive_failures: 0, + pin_auth_blocked: false, + }; + store.write_pin_state(&updated) +} + +/// Persist a replacement PIN after verifying the current one. +pub fn pin_change(state_dir: &Path, current_pin: &str, new_pin: &str) -> io::Result<()> { + validate_pin(new_pin)?; + let store = PersistentStore::new(state_dir)?; + let mut state = store.read_pin_state()?; + verify_current_pin(&mut state, current_pin)?; + state.pin_hash = Some(hash_pin(new_pin)); + state.pin_retries = DEFAULT_PIN_RETRIES; + state.consecutive_failures = 0; + state.pin_auth_blocked = false; + store.write_pin_state(&state) +} + +/// Clear the PIN after verifying the current one. +pub fn pin_remove(state_dir: &Path, current_pin: &str) -> io::Result<()> { + let store = PersistentStore::new(state_dir)?; + let mut state = store.read_pin_state()?; + verify_current_pin(&mut state, current_pin)?; + state.pin_hash = None; + state.pin_retries = DEFAULT_PIN_RETRIES; + state.consecutive_failures = 0; + state.pin_auth_blocked = false; + store.write_pin_state(&state) +} + +/// Wipe credentials and reset PIN state. Equivalent to a factory reset. +pub fn reset_state(state_dir: &Path) -> io::Result<()> { + reset_state_dir(state_dir) +} + +fn verify_current_pin(state: &mut StoredPinState, candidate: &str) -> io::Result<()> { + let stored = state.pin_hash.ok_or_else(|| { + io::Error::new(io::ErrorKind::PermissionDenied, "no PIN is currently set") + })?; + if state.pin_auth_blocked { + return Err(io::Error::new( + io::ErrorKind::PermissionDenied, + "PIN is blocked until the authenticator is reset", + )); + } + let provided = hash_pin(candidate); + let mut diff = 0u8; + for (a, b) in stored.iter().zip(provided.iter()) { + diff |= a ^ b; + } + if diff == 0 { + state.pin_retries = DEFAULT_PIN_RETRIES; + state.consecutive_failures = 0; + Ok(()) + } else { + if state.pin_retries > 0 { + state.pin_retries -= 1; + } + state.consecutive_failures = state.consecutive_failures.saturating_add(1); + if state.pin_retries == 0 { + state.pin_auth_blocked = true; + } + Err(io::Error::new( + io::ErrorKind::PermissionDenied, + format!("PIN is incorrect ({} retries remaining)", state.pin_retries), + )) + } +} diff --git a/pc-hid-runner/src/transport/ctaphid_host.rs b/pc-hid-runner/src/transport/ctaphid_host.rs index 7ff7546..02581ce 100644 --- a/pc-hid-runner/src/transport/ctaphid_host.rs +++ b/pc-hid-runner/src/transport/ctaphid_host.rs @@ -771,7 +771,9 @@ mod tests { let frames = take_frame_bytes(&mut host); assert_eq!(frames.len(), 1); - let assigned = u32::from_be_bytes(frames[0][8..12].try_into().unwrap()); + // Init response payload: 8-byte nonce echo followed by 4-byte + // assigned channel id; payload starts at frame offset 7. + let assigned = u32::from_be_bytes(frames[0][15..19].try_into().unwrap()); assert_eq!(assigned, 0x1234_5678); } @@ -792,7 +794,7 @@ mod tests { let frames = take_frame_bytes(&mut host); assert_eq!(frames.len(), 1); - let assigned = u32::from_be_bytes(frames[0][8..12].try_into().unwrap()); + let assigned = u32::from_be_bytes(frames[0][15..19].try_into().unwrap()); assert_eq!(assigned, 0xA1A2_A3A4); let mut reinit_packet = [0u8; 64]; @@ -806,7 +808,7 @@ mod tests { let frames = take_frame_bytes(&mut host); assert_eq!(frames.len(), 1); - let reused = u32::from_be_bytes(frames[0][8..12].try_into().unwrap()); + let reused = u32::from_be_bytes(frames[0][15..19].try_into().unwrap()); assert_eq!(reused, assigned); let mut second_broadcast = [0u8; 64]; @@ -820,7 +822,7 @@ mod tests { let frames = take_frame_bytes(&mut host); assert_eq!(frames.len(), 1); - let next_cid = u32::from_be_bytes(frames[0][8..12].try_into().unwrap()); + let next_cid = u32::from_be_bytes(frames[0][15..19].try_into().unwrap()); assert_eq!(next_cid, 0xDEAD_BEEF); } @@ -840,7 +842,7 @@ mod tests { let _ = host.poll_dispatch(&mut dispatch, &mut apps); let frames = take_frame_bytes(&mut host); assert_eq!(frames.len(), 1); - let first_cid = u32::from_be_bytes(frames[0][8..12].try_into().unwrap()); + let first_cid = u32::from_be_bytes(frames[0][15..19].try_into().unwrap()); assert_eq!(first_cid, 0x0102_0304); let mut second_init = [0u8; 64]; @@ -854,7 +856,7 @@ mod tests { let frames = take_frame_bytes(&mut host); assert_eq!(frames.len(), 1); - let second_cid = u32::from_be_bytes(frames[0][8..12].try_into().unwrap()); + let second_cid = u32::from_be_bytes(frames[0][15..19].try_into().unwrap()); assert_eq!(second_cid, 0x0BAD_F00D); assert_ne!(first_cid, second_cid); } @@ -877,9 +879,15 @@ mod tests { assert_eq!(frames.len(), 1); assert_eq!(frames[0][4] & 0x7f, Command::Init.into_u8()); assert_eq!(frames[0][5..7], [0, 17]); + // Init response payload layout: + // [7..15] nonce echo + // [15..19] assigned channel id + // [19] CTAPHID protocol version (2) + // [20..23] device major/minor/build version + // [23] capability flags assert_eq!(&frames[0][7..15], &[1, 2, 3, 4, 5, 6, 7, 8]); - // Verify CAPABILITY_CBOR | CAPABILITY_NMSG = 0x0C - assert_eq!(frames[0][16], CAPABILITY_CBOR | CAPABILITY_NMSG); + assert_eq!(frames[0][19], 2); + assert_eq!(frames[0][23], CAPABILITY_CBOR | CAPABILITY_NMSG); } #[test] diff --git a/pc-hid-runner/src/uhid.rs b/pc-hid-runner/src/uhid.rs index ea95c28..f295e97 100644 --- a/pc-hid-runner/src/uhid.rs +++ b/pc-hid-runner/src/uhid.rs @@ -386,68 +386,10 @@ fn event_as_bytes(event: &raw::uhid_event) -> &[u8] { } } -fn force_ctaphid_report_descriptor(event: &mut raw::uhid_event) { - // Non-mutating validator: we only log; we never rewrite rd_data/rd_size. - if event.type_ != raw::UHID_EVENT_TYPE_CREATE2 { - return; - } - - let size = unsafe { - usize::from(core::ptr::read_unaligned(core::ptr::addr_of!( - event.u.create2.rd_size - ))) - }; - let expected_len = CTAPHID_REPORT_DESCRIPTOR.len(); - - if size >= expected_len - && unsafe { - std::slice::from_raw_parts( - core::ptr::addr_of!(event.u.create2.rd_data) as *const u8, - expected_len, - ) - } == CTAPHID_REPORT_DESCRIPTOR - { - return; - } - if size == 0 { - log::warn!( - "create2 descriptor length is zero; expected {} bytes. Not mutating.", - expected_len - ); - } else if size > raw::HID_MAX_DESCRIPTOR_SIZE { - log::warn!( - "create2 descriptor length {} exceeds HID max {}; not mutating.", - size, - raw::HID_MAX_DESCRIPTOR_SIZE - ); - } else { - log::warn!( - "create2 descriptor does not match reference (size={}, expected={}); not mutating.", - size, - expected_len - ); - } -} - fn to_io_error(err: nix::Error) -> io::Error { io::Error::from(err) } -fn looks_like_ascii_hex(bytes: &[u8]) -> bool { - let mut saw_digit = false; - for &byte in bytes { - if byte.is_ascii_whitespace() { - continue; - } - if byte.is_ascii_hexdigit() { - saw_digit = true; - continue; - } - return saw_digit; - } - saw_digit -} - mod raw { pub const UHID_DATA_MAX: usize = 4096; pub const HID_MAX_DESCRIPTOR_SIZE: usize = 4096; @@ -748,134 +690,11 @@ mod tests { assert_eq!(descriptor_bytes, &CTAPHID_REPORT_DESCRIPTOR); } - #[test] - fn write_event_decodes_ascii_descriptor_bytes() { - use nix::unistd::{close, pipe, read}; - - let mut event = raw::uhid_event::default(); - event.type_ = raw::UHID_EVENT_TYPE_CREATE2; - let ascii_descriptor = b"06 d0 f1 09 01 a1 01 09 20 15 00 26 ff 00 75 08 95 40 81 02 09 21 15 00 26 ff 00 75 08 95 40 91 02 c0"; - let descriptor_len = ascii_descriptor.len(); - let create2 = unsafe { &mut event.u.create2 }; - create2.rd_size = descriptor_len as u16; - create2.rd_data[..descriptor_len].copy_from_slice(ascii_descriptor); - - let (read_fd, write_fd) = pipe().expect("pipe"); - write_event_blocking(write_fd, &mut event).expect("write_event"); - close(write_fd).ok(); - - let create2 = unsafe { &event.u.create2 }; - assert_eq!(create2.rd_size as usize, CTAPHID_REPORT_DESCRIPTOR.len()); - assert_eq!( - &create2.rd_data[..CTAPHID_REPORT_DESCRIPTOR.len()], - &CTAPHID_REPORT_DESCRIPTOR - ); - - let mut buffer = [0u8; raw::UHID_EVENT_SIZE]; - let mut offset = 0; - while offset < buffer.len() { - let read_bytes = read(read_fd, &mut buffer[offset..]).expect("read"); - if read_bytes == 0 { - break; - } - offset += read_bytes; - } - close(read_fd).ok(); - assert_eq!(offset, raw::UHID_EVENT_SIZE); - - let data_offset = unsafe { - let base = (&event as *const raw::uhid_event).cast::(); - let data = event.u.create2.rd_data.as_ptr(); - data.offset_from(base) as usize - }; - let descriptor_bytes = &buffer[data_offset..data_offset + CTAPHID_REPORT_DESCRIPTOR.len()]; - assert_eq!(descriptor_bytes, &CTAPHID_REPORT_DESCRIPTOR); - } - - #[test] - fn write_event_decodes_ascii_descriptor_with_suffix() { - use nix::unistd::{close, pipe, read}; - - let mut event = raw::uhid_event::default(); - event.type_ = raw::UHID_EVENT_TYPE_CREATE2; - let ascii_descriptor = b"06 d0 f1 09 01 a1 01 09 20 15 00 26 ff 00 75 08 95 40 81 02 09 21 15 00 26 ff 00 75 08 95 40 91 02 c0\n INPUT[INPUT]\n"; - let descriptor_len = ascii_descriptor.len(); - let create2 = unsafe { &mut event.u.create2 }; - create2.rd_size = descriptor_len as u16; - create2.rd_data[..descriptor_len].copy_from_slice(ascii_descriptor); - - let (read_fd, write_fd) = pipe().expect("pipe"); - write_event_blocking(write_fd, &mut event).expect("write_event"); - close(write_fd).ok(); - - let create2 = unsafe { &event.u.create2 }; - assert_eq!(create2.rd_size as usize, CTAPHID_REPORT_DESCRIPTOR.len()); - assert_eq!( - &create2.rd_data[..CTAPHID_REPORT_DESCRIPTOR.len()], - &CTAPHID_REPORT_DESCRIPTOR - ); - - let mut buffer = [0u8; raw::UHID_EVENT_SIZE]; - let mut offset = 0; - while offset < buffer.len() { - let read_bytes = read(read_fd, &mut buffer[offset..]).expect("read"); - if read_bytes == 0 { - break; - } - offset += read_bytes; - } - close(read_fd).ok(); - assert_eq!(offset, raw::UHID_EVENT_SIZE); - - let data_offset = unsafe { - let base = (&event as *const raw::uhid_event).cast::(); - let data = event.u.create2.rd_data.as_ptr(); - data.offset_from(base) as usize - }; - let descriptor_bytes = &buffer[data_offset..data_offset + CTAPHID_REPORT_DESCRIPTOR.len()]; - assert_eq!(descriptor_bytes, &CTAPHID_REPORT_DESCRIPTOR); - } - - #[test] - fn write_event_overrides_incorrect_binary_descriptor() { - use nix::unistd::{close, pipe, read}; - - let mut event = raw::uhid_event::default(); - event.type_ = raw::UHID_EVENT_TYPE_CREATE2; - let bogus_descriptor = [0xAAu8; CTAPHID_REPORT_DESCRIPTOR.len()]; - let create2 = unsafe { &mut event.u.create2 }; - create2.rd_size = bogus_descriptor.len() as u16; - create2.rd_data[..bogus_descriptor.len()].copy_from_slice(&bogus_descriptor); - - let (read_fd, write_fd) = pipe().expect("pipe"); - write_event_blocking(write_fd, &mut event).expect("write_event"); - close(write_fd).ok(); - - let create2 = unsafe { &event.u.create2 }; - assert_eq!(create2.rd_size as usize, CTAPHID_REPORT_DESCRIPTOR.len()); - assert_eq!( - &create2.rd_data[..CTAPHID_REPORT_DESCRIPTOR.len()], - &CTAPHID_REPORT_DESCRIPTOR - ); - - let mut buffer = [0u8; raw::UHID_EVENT_SIZE]; - let mut offset = 0; - while offset < buffer.len() { - let read_bytes = read(read_fd, &mut buffer[offset..]).expect("read"); - if read_bytes == 0 { - break; - } - offset += read_bytes; - } - close(read_fd).ok(); - assert_eq!(offset, raw::UHID_EVENT_SIZE); - - let data_offset = unsafe { - let base = (&event as *const raw::uhid_event).cast::(); - let data = event.u.create2.rd_data.as_ptr(); - data.offset_from(base) as usize - }; - let descriptor_bytes = &buffer[data_offset..data_offset + CTAPHID_REPORT_DESCRIPTOR.len()]; - assert_eq!(descriptor_bytes, &CTAPHID_REPORT_DESCRIPTOR); - } + // NOTE: previous versions of this file contained tests for an in-place + // descriptor rewriter (`force_ctaphid_report_descriptor`). That helper + // was never wired into the production write path, so the tests asserted + // behaviour the code never performed. They are intentionally removed + // here; `descriptor_bytes_are_copied_verbatim` and + // `write_event_sends_raw_descriptor_bytes` above cover the actual + // serialization contract. } diff --git a/pc-usbip-runner/.dockerignore b/pc-usbip-runner/.dockerignore deleted file mode 100644 index 80678f9..0000000 --- a/pc-usbip-runner/.dockerignore +++ /dev/null @@ -1,2 +0,0 @@ -./target/ -./cargo-cache diff --git a/pc-usbip-runner/.gitignore b/pc-usbip-runner/.gitignore deleted file mode 100644 index 2d15be8..0000000 --- a/pc-usbip-runner/.gitignore +++ /dev/null @@ -1,5 +0,0 @@ -cargo-cache -tmp -trussed-state.bin -usbip-simulation -target diff --git a/pc-usbip-runner/Cargo.toml b/pc-usbip-runner/Cargo.toml deleted file mode 100644 index ea7b520..0000000 --- a/pc-usbip-runner/Cargo.toml +++ /dev/null @@ -1,38 +0,0 @@ -[package] -name = "trussed-usbip" -version = "0.0.1" -authors = ["Nicolas Stalder ", "Conor Patrick ", "Szczepan Zalega "] -edition = "2021" - -[dependencies] -interchange = "0.3.0" -log = { version = "0.4.14", default-features = false } -transport-core = { path = "../transport-core", default-features = false } -usb-device = { version = "0.2.7", default-features = false } -usbip-device = "0.1.5" -trussed = { version = "0.1", default-features = false, features = ["log-all", "virt"] } - -# ctaphid -ctaphid-dispatch = { version = "0.3", features = ["log-all"], optional = true } -usbd-ctaphid = { version = "0.3", features = ["log-all"], optional = true } - -# ccid -apdu-dispatch = { version = "0.3", optional = true } -usbd-ccid = { version = "0.3", features = ["log-all"], optional = true } - -[dev-dependencies] -clap = { version = "3.0.0", features = ["derive"] } -clap-num = "1.0.0" -delog = { version = "0.1.6", features = ["std-log"] } -heapless-bytes = "0.3" -littlefs2 = "0.6" -pretty_env_logger = "0.4.0" -trussed = "0.1" -authenticator = { path = "../authenticator" } - -[features] -default = ["ctaphid"] -ctaphid = ["ctaphid-dispatch", "usbd-ctaphid", "transport-core/ctaphid"] -ccid = ["apdu-dispatch", "usbd-ccid", "transport-core/ccid"] -legacy = [] - diff --git a/pc-usbip-runner/Dockerfile b/pc-usbip-runner/Dockerfile deleted file mode 100644 index 2cb8b7b..0000000 --- a/pc-usbip-runner/Dockerfile +++ /dev/null @@ -1,4 +0,0 @@ -FROM rust:latest -RUN apt update -qy && apt install -qy libclang-dev -RUN rustc --version -ENV CARGO_HOME /root/.cargo/ diff --git a/pc-usbip-runner/Makefile b/pc-usbip-runner/Makefile deleted file mode 100644 index c48a27c..0000000 --- a/pc-usbip-runner/Makefile +++ /dev/null @@ -1,54 +0,0 @@ -EXAMPLE_NAME := authenticator - -all: | start-sim attach finish-message - -.PHONY: finish-message -finish-message: - @echo "###################################################" - @echo "Done. Device should be visible in your system now. Run 'make stop' to disconnect it." - -.PHONY: start-sim -start-sim: build - -$(MAKE) stop - env RUST_LOG=debug cargo run --example $(EXAMPLE_NAME) & - sleep 1 - -.PHONY: attach -attach: - lsmod | grep vhci-hcd || sudo modprobe vhci-hcd - sudo usbip list -r "localhost" - sudo usbip attach -r "localhost" -b "1-1" - sleep 5 - -.PHONY: ci -ci: - timeout 10 -k 5 $(MAKE) - -.PHONY: build -build: - cargo build --example $(EXAMPLE_NAME) - -.PHONY: build-clean -build-clean: | clean build - -.PHONY: stop -stop: - -sudo usbip detach -p "00" - killall $(EXAMPLE_NAME) - -.PHONY: setup-fedora -setup-fedora: - sudo dnf install usbip clang-libs-13.0.0 - sudo ln -s /usr/lib64/libclang.so.13 /usr/lib64/libclang.so - -.PHONY: clean -clean: - cargo clean - rm -r cargo-cache - -.PHONY: build-docker -CMD=make -C /app/ build -build-docker: - docker build -t usbip . - mkdir -p cargo-cache - docker run -it --rm -v $(PWD)/cargo-cache:/root/.cargo -v $(PWD):/app usbip $(CMD) diff --git a/pc-usbip-runner/README.md b/pc-usbip-runner/README.md deleted file mode 100644 index 942ee4f..0000000 --- a/pc-usbip-runner/README.md +++ /dev/null @@ -1,86 +0,0 @@ -# PC USB/IP Runner - -The `trussed-usbip` crate provides a USB/IP runner for Trussed-based -applications. The `authenticator` example wires the ML-DSA authenticator's -CTAP implementation into the runner so it can be exercised from a desktop -machine. - -## Authenticator example - -Build and run the example with `cargo run --example authenticator` or use the -Makefile target, which automatically starts the USB/IP device and attaches it -via `usbip`: - -```sh -make -C pc-usbip-runner -``` - -The CLI accepts standard USB identity parameters and the authenticator AAGUID: - -```text -Usage: authenticator [OPTIONS] - -Options: - -n, --product USB product string [default: Feitian FIDO2 Software Authenticator (ML-DSA)] - -m, --manufacturer - USB manufacturer string [default: Feitian Technologies Co., Ltd.] - --serial USB serial number [default: FEITIAN-PQC-001] - --state-file Trussed state file (currently unused, reserved for future persistence) [default: trussed-state.bin] - -v, --vid USB VID [default: 0x1998] - -p, --pid USB PID [default: 0x0616] - --aaguid Authenticator AAGUID as 32 hex characters (hyphens optional) - --manual-user-presence Require physical confirmation instead of automatically acknowledging presence - -h, --help Print help information - -V, --version Print version information -``` - -The provided options are forwarded to the USB/IP runner so the CTAPHID stack -identifies itself using the supplied VID/PID and product strings. The crate -enables the CTAPHID transport by default; enable the `ccid` feature when you -also want to expose the smart-card interface. - -By default the example automatically fulfils user-presence checks so that the -VM workflow can progress without manual intervention. Pass -`--manual-user-presence` to disable the auto-confirmation and exercise the -normal polling path instead. - -### Choosing the correct `liboqs` binaries - -The ML-DSA and ML-KEM wrappers link against prebuilt `liboqs` artifacts. Pick -the directory that matches the target triple you're building for: - -```sh -uname -m -``` - -* `aarch64` → use `prebuilt_liboqs/linux-aarch64` -* `x86_64` → populate `prebuilt_liboqs/linux-x86_64` with the headers and - libraries from the [liboqs release artifacts][liboqs-release] - -Because the chat environment cannot upload binary artifacts, the x86_64 -directory is intentionally left empty in commits. When developing on an x86_64 -system, download the official `liboqs` release tarball, extract the `lib` and -`include` directories and copy them into `prebuilt_liboqs/linux-x86_64/` before -building. - -When running the compiled binary outside of `cargo run`, export -`LD_LIBRARY_PATH=/path/to/prebuilt_liboqs//lib` so the dynamic linker can -locate `liboqs.so`. - -[liboqs-release]: https://github.com/open-quantum-safe/liboqs/releases - -## USB/IP usage - -Once the runner is active you can attach it using the standard usbip flow: - -```sh -sudo modprobe vhci-hcd -sudo usbip list -r localhost -sudo usbip attach -r localhost -b 1-1 -sudo usbip port -lsusb -``` - -The authenticator will then appear as a FIDO CTAPHID device and can be used -for registration and authentication ceremonies with WebAuthn-compatible -relying parties. diff --git a/pc-usbip-runner/examples/authenticator.rs b/pc-usbip-runner/examples/authenticator.rs deleted file mode 100644 index 185ae80..0000000 --- a/pc-usbip-runner/examples/authenticator.rs +++ /dev/null @@ -1,199 +0,0 @@ -#![cfg(feature = "legacy")] - -//! USB/IP runner that exposes the ML-DSA authenticator over CTAPHID. -//! -//! The example wires the authenticator's CTAP application into the -//! `trussed-usbip` runner so it can be tested with `usbip` and existing -//! FIDO tooling. - -use std::path::PathBuf; - -use authenticator::ctap::CtapApp; -use clap::Parser; -use clap_num::maybe_hex; -use littlefs2_core::path; -use transport_core::state::{default_state_dir, IdentityConfig, PersistentStore}; -use trussed::{ - backend::{CoreOnly, NoId}, - client::Client, - pipe::{ServiceEndpoint, TrussedChannel}, - service::Service, - types::{CoreContext, NoData}, -}; -use trussed_usbip::{exec, set_waiting, Builder, Client, Platform, Syscall}; - -#[derive(Parser, Debug)] -#[clap(about, version, author)] -struct Args { - /// USB product - #[clap( - short = 'n', - long, - default_value = "Feitian FIDO2 Software Authenticator (ML-DSA)" - )] - product: String, - - /// USB manufacturer - #[clap(short, long, default_value = "Feitian Technologies Co., Ltd.")] - manufacturer: String, - - /// USB serial number - #[clap(long, default_value = "FEITIAN-PQC-001")] - serial: String, - - /// Directory where persistent Trussed state will be stored - #[clap(long, value_parser, default_value_os_t = default_state_dir())] - state_dir: PathBuf, - - /// USB VID - #[clap(short, long, parse(try_from_str = maybe_hex), default_value_t = 0x1998)] - vid: u16, - - /// USB PID - #[clap(short, long, parse(try_from_str = maybe_hex), default_value_t = 0x0616)] - pid: u16, - - /// Authenticator AAGUID - #[clap(long, default_value = "4645495449414E980616525A30310000")] - aaguid: String, - - /// Require user gestures instead of automatically satisfying presence checks - #[clap(long)] - manual_user_presence: bool, -} - -#[derive(Clone, Copy)] -struct AppData { - aaguid: [u8; 16], - auto_user_presence: bool, -} - -struct Apps { - ctap: CtapApp, -} - -impl<'a> trussed_usbip::Apps<'a, CoreOnly> for Apps> { - type Data = AppData; - - fn new( - _service: &mut Service, - endpoints: &mut Vec>, - syscall: Syscall, - data: Self::Data, - ) -> Self { - static CHANNEL: TrussedChannel = TrussedChannel::new(); - let (requester, responder) = CHANNEL.split().expect("Trussed channel split"); - let context = CoreContext::new(path!("authenticator").into()); - endpoints.push(ServiceEndpoint::new(responder, context, &[])); - let client = Client::new(requester, syscall, None); - let mut ctap = CtapApp::new(client, data.aaguid); - ctap.set_auto_user_presence(data.auto_user_presence); - ctap.set_keepalive_callback(set_waiting); - Self { ctap } - } - - #[cfg(feature = "ctaphid")] - fn with_ctaphid_apps( - &mut self, - f: impl FnOnce(&mut [&mut dyn ctaphid_dispatch::app::App<'a, N>]) -> T, - ) -> T { - f(&mut [&mut self.ctap]) - } - - #[cfg(feature = "ccid")] - fn with_ccid_apps( - &mut self, - f: impl FnOnce(&mut [&mut dyn apdu_dispatch::app::App]) -> T, - ) -> T { - f(&mut []) - } -} - -fn parse_aaguid(input: &str) -> Result<[u8; 16], String> { - let mut cleaned = input.to_owned(); - cleaned.retain(|c| c != '-'); - if cleaned.len() != 32 { - return Err(format!("expected 32 hex characters, got {}", cleaned.len())); - } - let mut out = [0u8; 16]; - for (idx, chunk) in cleaned.as_bytes().chunks(2).enumerate() { - let hex = std::str::from_utf8(chunk).map_err(|_| "invalid UTF-8 in AAGUID".to_string())?; - out[idx] = - u8::from_str_radix(hex, 16).map_err(|_| format!("invalid hex at byte {}", idx))?; - } - Ok(out) -} - -fn main() { - pretty_env_logger::init(); - - let args = Args::parse(); - let aaguid = parse_aaguid(&args.aaguid).expect("invalid AAGUID"); - - let mut persistent = - PersistentStore::new(&args.state_dir).expect("failed to open persistent store"); - persistent - .initialize_identity(IdentityConfig { - aaguid, - manufacturer: &args.manufacturer, - product: &args.product, - serial: &args.serial, - }) - .expect("failed to initialize persistent state"); - let store = persistent.store(); - let options = trussed_usbip::Options { - manufacturer: Some(args.manufacturer), - product: Some(args.product), - serial_number: Some(args.serial), - vid: args.vid, - pid: args.pid, - device_class: None, - }; - - log::info!("Initializing Trussed"); - let platform = Platform::new(store); - let runner = Builder::new(options).build::>(); - exec( - runner, - platform, - AppData { - aaguid, - auto_user_presence: !args.manual_user_presence, - }, - ) - .expect("usbip transport exited"); -} - -#[cfg(test)] -mod tests { - use super::parse_aaguid; - - #[test] - fn parses_plain_hex() { - let input = "00112233445566778899aabbccddeeff"; - assert_eq!( - parse_aaguid(input).unwrap(), - [ - 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, - 0xEE, 0xFF - ] - ); - } - - #[test] - fn parses_hyphenated_hex() { - let input = "00112233-4455-6677-8899-aabbccddeeff"; - assert_eq!( - parse_aaguid(input).unwrap(), - [ - 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, - 0xEE, 0xFF - ] - ); - } - - #[test] - fn rejects_invalid_length() { - assert!(parse_aaguid("0011").is_err()); - } -} diff --git a/pc-usbip-runner/fido2-patch/0001-Ignore-difference-between-the-sent-data-size-and-rep.patch b/pc-usbip-runner/fido2-patch/0001-Ignore-difference-between-the-sent-data-size-and-rep.patch deleted file mode 100644 index d213de8..0000000 --- a/pc-usbip-runner/fido2-patch/0001-Ignore-difference-between-the-sent-data-size-and-rep.patch +++ /dev/null @@ -1,27 +0,0 @@ -From aa6019ee64df3b85db92ffa3a4894f614b062437 Mon Sep 17 00:00:00 2001 -From: Szczepan Zalega -Date: Mon, 27 Jun 2022 14:07:58 +0200 -Subject: [PATCH] Ignore difference between the sent data size and reported - -Required for the USB/IP simulation, as apparently calls on it always return 1. ---- - fido2/hid/base.py | 3 ++- - 1 file changed, 2 insertions(+), 1 deletion(-) - -diff --git a/fido2/hid/base.py b/fido2/hid/base.py -index a184265..5cc2187 100644 ---- a/fido2/hid/base.py -+++ b/fido2/hid/base.py -@@ -74,7 +74,8 @@ def close(self): - - def write_packet(self, packet): - if os.write(self.handle, packet) != len(packet): -- raise OSError("failed to write entire packet") -+ # raise OSError("failed to write entire packet") -+ pass - - def read_packet(self): - return os.read(self.handle, self.descriptor.report_size_in) --- -2.35.3 - diff --git a/pc-usbip-runner/src/ccid.rs b/pc-usbip-runner/src/ccid.rs deleted file mode 100644 index 76e56d3..0000000 --- a/pc-usbip-runner/src/ccid.rs +++ /dev/null @@ -1,36 +0,0 @@ -use std::time::{Duration, Instant}; - -use apdu_dispatch::dispatch::ApduDispatch; -use apdu_dispatch::interchanges::Data; -use usb_device::bus::{UsbBus, UsbBusAllocator}; -use usbd_ccid::{Ccid, Status}; - -use transport_core::Timeout; - -pub fn setup<'bus, 'pipe, B: UsbBus>( - bus_allocator: &'bus UsbBusAllocator, - contact: &'pipe interchange::Channel, - contactless: &'pipe interchange::Channel, -) -> (Ccid<'bus, 'pipe, B, 3072>, ApduDispatch<'pipe>) { - let (ccid_rq, ccid_rp) = contact.split().unwrap(); - let ccid = Ccid::new(bus_allocator, ccid_rq, None); - let apdu_dispatch = ApduDispatch::new(ccid_rp, contactless.split().unwrap().1); - (ccid, apdu_dispatch) -} - -pub fn keepalive( - ccid: &mut Ccid<'_, '_, B, N>, - timeout: &mut Timeout, - epoch: Instant, -) -> bool { - timeout.update(epoch, map_status(ccid.did_start_processing()), || { - map_status(ccid.send_wait_extension()) - }) -} - -fn map_status(status: Status) -> Option { - match status { - Status::ReceivedData(ms) => Some(Duration::from_millis(ms.0.into())), - Status::Idle => None, - } -} diff --git a/pc-usbip-runner/src/ctaphid.rs b/pc-usbip-runner/src/ctaphid.rs deleted file mode 100644 index 9a20512..0000000 --- a/pc-usbip-runner/src/ctaphid.rs +++ /dev/null @@ -1,41 +0,0 @@ -use std::time::{Duration, Instant}; - -use ctaphid_dispatch::Dispatch; -use usb_device::bus::{UsbBus, UsbBusAllocator}; -use usbd_ctaphid::{types::Status, CtapHid}; - -use transport_core::Timeout; - -pub fn setup<'bus, 'pipe, 'interrupt, B: UsbBus, const N: usize>( - bus_allocator: &'bus UsbBusAllocator, - interchange: &'pipe ctaphid_dispatch::Channel, -) -> ( - CtapHid<'bus, 'pipe, 'interrupt, B, N>, - Dispatch<'pipe, 'interrupt, N>, -) { - let (ctaphid_rq, ctaphid_rp) = interchange.split().unwrap(); - let ctaphid = CtapHid::new(bus_allocator, ctaphid_rq, 0u32) - .implements_ctap1() - .implements_ctap2() - .implements_wink(); - let ctaphid_dispatch = Dispatch::new(ctaphid_rp); - (ctaphid, ctaphid_dispatch) -} - -pub fn keepalive( - ctaphid: &mut CtapHid<'_, '_, '_, B, N>, - timeout: &mut Timeout, - epoch: Instant, - waiting_for_user: bool, -) -> bool { - timeout.update(epoch, map_status(ctaphid.did_start_processing()), || { - map_status(ctaphid.send_keepalive(waiting_for_user)) - }) -} - -fn map_status(status: Status) -> Option { - match status { - Status::ReceivedData(ms) => Some(Duration::from_millis(ms.0.into())), - Status::Idle => None, - } -} diff --git a/pc-usbip-runner/src/lib.rs b/pc-usbip-runner/src/lib.rs deleted file mode 100644 index 30dbc16..0000000 --- a/pc-usbip-runner/src/lib.rs +++ /dev/null @@ -1,234 +0,0 @@ -#![cfg_attr(not(any(feature = "ctaphid", feature = "ccid")), allow(dead_code))] - -#[cfg(feature = "ccid")] -mod ccid; -#[cfg(feature = "ctaphid")] -mod ctaphid; - -use std::{io, thread, time::Instant}; - -#[cfg(feature = "ccid")] -use apdu_dispatch::interchanges::Data; -#[cfg(feature = "ctaphid")] -use ctaphid_dispatch::{self, Channel, DEFAULT_MESSAGE_SIZE}; -use trussed::backend::Dispatch; -use usb_device::{ - bus::UsbBusAllocator, - device::{UsbDevice, UsbDeviceBuilder, UsbVidPid}, -}; -use usbip_device::UsbIpBus; - -#[cfg(feature = "ccid")] -use usbd_ccid::Ccid; -#[cfg(feature = "ctaphid")] -use usbd_ctaphid::CtapHid; - -pub use transport_core::{ - set_waiting, waiting_for_user_presence, Apps, Builder, Client, DeviceClass, Options, Platform, - Runner, Store, Syscall, Timeout, Transport, -}; - -pub struct UsbIpTransport<'bus, 'pipe, 'interrupt> { - usb_device: &'bus mut UsbDevice<'bus, UsbIpBus>, - #[cfg(feature = "ctaphid")] - ctaphid: &'bus mut CtapHid<'bus, 'pipe, 'interrupt, UsbIpBus, { DEFAULT_MESSAGE_SIZE }>, - #[cfg(feature = "ctaphid")] - ctaphid_dispatch: ctaphid_dispatch::Dispatch<'pipe, 'interrupt, { DEFAULT_MESSAGE_SIZE }>, - #[cfg(feature = "ccid")] - ccid: &'bus mut Ccid<'bus, 'pipe, UsbIpBus, 3072>, - #[cfg(feature = "ccid")] - apdu_dispatch: apdu_dispatch::dispatch::ApduDispatch<'pipe>, - epoch: Instant, - #[cfg(feature = "ctaphid")] - timeout_ctaphid: Timeout, - #[cfg(feature = "ccid")] - timeout_ccid: Timeout, -} - -impl<'bus, 'pipe, 'interrupt> UsbIpTransport<'bus, 'pipe, 'interrupt> { - #[allow(clippy::too_many_arguments)] - pub fn new( - usb_device: &'bus mut UsbDevice<'bus, UsbIpBus>, - #[cfg(feature = "ctaphid")] ctaphid: &'bus mut CtapHid< - 'bus, - 'pipe, - 'interrupt, - UsbIpBus, - { DEFAULT_MESSAGE_SIZE }, - >, - #[cfg(feature = "ctaphid")] ctaphid_dispatch: ctaphid_dispatch::Dispatch< - 'pipe, - 'interrupt, - { DEFAULT_MESSAGE_SIZE }, - >, - #[cfg(feature = "ccid")] ccid: &'bus mut Ccid<'bus, 'pipe, UsbIpBus, 3072>, - #[cfg(feature = "ccid")] apdu_dispatch: apdu_dispatch::dispatch::ApduDispatch<'pipe>, - ) -> Self { - Self { - usb_device, - #[cfg(feature = "ctaphid")] - ctaphid, - #[cfg(feature = "ctaphid")] - ctaphid_dispatch, - #[cfg(feature = "ccid")] - ccid, - #[cfg(feature = "ccid")] - apdu_dispatch, - epoch: Instant::now(), - #[cfg(feature = "ctaphid")] - timeout_ctaphid: Timeout::new(), - #[cfg(feature = "ccid")] - timeout_ccid: Timeout::new(), - } - } -} - -impl<'interrupt, D> Transport<'interrupt, D> for UsbIpTransport<'_, '_, 'interrupt> -where - D: Dispatch, -{ - fn poll>(&mut self, apps: &mut A) -> io::Result { - let mut handled_usb_event = false; - while self.usb_device.poll(&mut [ - #[cfg(feature = "ctaphid")] - &mut *self.ctaphid, - #[cfg(feature = "ccid")] - &mut *self.ccid, - ]) { - handled_usb_event = true; - } - - let mut dispatched = false; - - #[cfg(feature = "ctaphid")] - { - let ctaphid_did_work = apps.with_ctaphid_apps(|apps| { - let mut did_work = false; - while self.ctaphid_dispatch.poll(apps) { - did_work = true; - } - did_work - }); - dispatched |= ctaphid_did_work; - } - - #[cfg(feature = "ccid")] - { - let ccid_did_work = apps.with_ccid_apps(|apps| { - let mut did_work = false; - while self.apdu_dispatch.poll(apps).is_some() { - did_work = true; - } - did_work - }); - dispatched |= ccid_did_work; - } - - Ok(handled_usb_event || dispatched) - } - - fn send(&mut self, waiting_for_user: bool) -> io::Result { - let mut keepalive_sent = false; - - #[cfg(feature = "ctaphid")] - { - keepalive_sent |= ctaphid::keepalive( - self.ctaphid, - &mut self.timeout_ctaphid, - self.epoch, - waiting_for_user, - ); - } - - #[cfg(feature = "ccid")] - { - keepalive_sent |= ccid::keepalive(self.ccid, &mut self.timeout_ccid, self.epoch); - } - - Ok(keepalive_sent) - } - - fn wait(&mut self) -> io::Result<()> { - thread::yield_now(); - Ok(()) - } -} - -pub fn exec<'interrupt, D, A>( - runner: Runner, - platform: Platform, - data: A::Data, -) -> io::Result<()> -where - D: Dispatch, - D::BackendId: Send + Sync, - D::Context: Send + Sync, - A: Apps<'interrupt, D>, -{ - let usbip_bus = UsbIpBus::new(); - usbip_bus.set_device_speed(2); - let bus_allocator = UsbBusAllocator::new(usbip_bus); - - #[cfg(feature = "ctaphid")] - let ctap_channel: Channel<{ DEFAULT_MESSAGE_SIZE }> = Channel::new(); - #[cfg(feature = "ctaphid")] - let (mut ctaphid, ctaphid_dispatch) = - ctaphid::setup::<_, { DEFAULT_MESSAGE_SIZE }>(&bus_allocator, &ctap_channel); - - #[cfg(feature = "ccid")] - let (contact, contactless) = Default::default(); - #[cfg(feature = "ccid")] - let (mut ccid, apdu_dispatch) = ccid::setup(&bus_allocator, &contact, &contactless); - - let device_options = runner.options().clone(); - let mut usb_device = build_device(&bus_allocator, &device_options); - - let transport = UsbIpTransport::new( - &mut usb_device, - #[cfg(feature = "ctaphid")] - &mut ctaphid, - #[cfg(feature = "ctaphid")] - ctaphid_dispatch, - #[cfg(feature = "ccid")] - &mut ccid, - #[cfg(feature = "ccid")] - apdu_dispatch, - ); - - runner.exec(platform, data, transport) -} - -fn build_device<'a>( - bus_allocator: &'a UsbBusAllocator, - options: &'a Options, -) -> UsbDevice<'a, UsbIpBus> { - let mut usb_builder = UsbDeviceBuilder::new(bus_allocator, UsbVidPid(options.vid, options.pid)); - if let Some(manufacturer) = &options.manufacturer { - usb_builder = usb_builder.manufacturer(manufacturer); - } - if let Some(product) = &options.product { - usb_builder = usb_builder.product(product); - } - if let Some(serial_number) = &options.serial_number { - usb_builder = usb_builder.serial_number(serial_number); - } - let ctaphid_enabled = cfg!(feature = "ctaphid"); - let ccid_enabled = cfg!(feature = "ccid"); - let device_class = options.resolved_device_class(ctaphid_enabled, ccid_enabled); - - log::debug!( - "USB device descriptor class {:02x}/{:02x}/{:02x} (ctaphid: {}, ccid: {}, override: {})", - device_class.class, - device_class.sub_class, - device_class.protocol, - ctaphid_enabled, - ccid_enabled, - options.device_class.is_some() - ); - - usb_builder - .device_class(device_class.class) - .device_sub_class(device_class.sub_class) - .device_protocol(device_class.protocol) - .build() -} diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/aes.h b/prebuilt_liboqs/linux-aarch64/include/oqs/aes.h deleted file mode 100644 index d0d6d63..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/aes.h +++ /dev/null @@ -1,202 +0,0 @@ -/** - * \file aes.h - * \brief Header defining the API for OQS AES; not part of the public OQS API - * - * Note this is not part of the OQS public API: implementations within liboqs can use these - * functions, but external consumers of liboqs should not use these functions. - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_AES_H -#define OQS_AES_H - -#include -#include - -#include - -#if defined(__cplusplus) -extern "C" { -#endif - -/** - * Function to fill a key schedule given an initial key for use in ECB mode. - * - * @param key Initial Key. - * @param ctx Abstract data structure for a key schedule. - */ -void OQS_AES128_ECB_load_schedule(const uint8_t *key, void **ctx); - -/** - * Function to initialize a context and fill a key schedule given an initial key for - * use in CTR mode. - * - * @param key Initial Key. - * @param ctx Abstract data structure for a key schedule. - */ -void OQS_AES128_CTR_inc_init(const uint8_t *key, void **ctx); - -/** - * Function to fill a context given an IV for use in CTR mode. - * - * Handles a 12- or 16-byte IV. If a 12-byte IV is given, then 4 counter - * bytes are initialized to all zeros. - * - * @param iv Initialization Vector. - * @param iv_len Length of the initialization vector. - * @param ctx Abstract data structure for IV. - */ -void OQS_AES128_CTR_inc_iv(const uint8_t *iv, size_t iv_len, void *ctx); - -/** - * Function to fill a context given an IV for use in CTR mode. - * Handles an 8-byte IV passed as a 64-bit unsigned integer, - * counter bytes are initialized to zero. - * - * @param iv Initialization Vector as 64-bit integer. - * @param ctx Abstract data structure for IV. - */ -void OQS_AES128_CTR_inc_ivu64(uint64_t iv, void *ctx); - -/** - * Function to free a key schedule. - * - * @param ctx Context generated with OQS_AES128_ECB_load_schedule(). - */ -void OQS_AES128_free_schedule(void *ctx); - -/** - * Function to encrypt blocks of plaintext using ECB mode. - * A schedule based on the key is generated and used internally. - * - * @param plaintext Plaintext to be encrypted. - * @param plaintext_len Length on the plaintext in bytes. Must be a multiple of 16. - * @param key Key to be used for encryption. - * @param ciphertext Pointer to a block of memory which >= in size to the plaintext block. The result will be written here. - * @warning plaintext_len must be a multiple of 16. - */ -void OQS_AES128_ECB_enc(const uint8_t *plaintext, const size_t plaintext_len, const uint8_t *key, uint8_t *ciphertext); - -/** - * Same as OQS_AES128_ECB_enc() except a schedule generated by - * OQS_AES128_ECB_load_schedule() is passed rather then a key. This is faster - * if the same schedule is used for multiple encryptions since it does - * not have to be regenerated from the key. - */ -void OQS_AES128_ECB_enc_sch(const uint8_t *plaintext, const size_t plaintext_len, const void *schedule, uint8_t *ciphertext); - -/** - * AES counter mode keystream generator. A context generated by - * OQS_AES128_CTR_inc_init() is passed rather then a key. - * - * Handles a 12- or 16-byte IV. If a 12-byte IV is given, then 4 counter - * bytes are initialized to all zeros. - * - * @param iv 12- or 16-byte initialization vector. - * @param iv_len Lengh of IV in bytes. - * @param ctx Abstract data structure for a key schedule. - * @param out Pointer to a block of memory which is big enough to contain out_len bytes; the result will be written here. - * @param out_len Length of output bytes to generate. - */ -void OQS_AES128_CTR_inc_stream_iv(const uint8_t *iv, size_t iv_len, const void *ctx, uint8_t *out, size_t out_len); - -/** - * Function to fill a key schedule given an initial key for use in ECB mode encryption. - * - * @param key Initial Key. - * @param ctx Abstract data structure for a key schedule. - */ -void OQS_AES256_ECB_load_schedule(const uint8_t *key, void **ctx); - -/** - * Function to initialize a context and fill a key schedule given an initial key for - * use in CTR mode. - * - * @param key Initial Key. - * @param ctx Abstract data structure for a key schedule. - */ -void OQS_AES256_CTR_inc_init(const uint8_t *key, void **ctx); - -/** - * Function to fill a context given an IV for use in CTR mode. - * - * Handles a 12- or 16-byte IV. If a 12-byte IV is given, then 4 counter - * bytes are initialized to all zeros. - * - * @param iv Initialization Vector. - * @param iv_len Length of the initialization vector. - * @param ctx Abstract data structure for IV. - */ -void OQS_AES256_CTR_inc_iv(const uint8_t *iv, size_t iv_len, void *ctx); - -/** - * Function to fill a context given an IV for use in CTR mode. - * Handles an 8-byte IV passed as a 64-bit unsigned integer, - * counter bytes are initialized to zero. - * - * @param iv Initialization Vector as 64-bit integer. - * @param ctx Abstract data structure for IV. - */ -void OQS_AES256_CTR_inc_ivu64(uint64_t iv, void *ctx); - -/** - * Function to free a key schedule. - * - * @param ctx Schedule generated with OQS_AES256_ECB_load_schedule - * or OQS_AES256_CTR_inc_init. - */ -void OQS_AES256_free_schedule(void *ctx); - -/** - * Function to encrypt blocks of plaintext using ECB mode. - * A schedule based on the key is generated and used internally. - * - * @param plaintext Plaintext to be encrypted. - * @param plaintext_len Length on the plaintext in bytes. Must be a multiple of 16. - * @param key Key to be used for encryption. - * @param ciphertext Pointer to a block of memory which >= in size to the plaintext block. The result will be written here. - * @warning plaintext_len must be a multiple of 16. - */ -void OQS_AES256_ECB_enc(const uint8_t *plaintext, const size_t plaintext_len, const uint8_t *key, uint8_t *ciphertext); - -/** - * Same as OQS_AES256_ECB_enc() except a schedule generated by - * OQS_AES256_ECB_load_schedule() is passed rather then a key. This is faster - * if the same schedule is used for multiple encryptions since it does - * not have to be regenerated from the key. - */ -void OQS_AES256_ECB_enc_sch(const uint8_t *plaintext, const size_t plaintext_len, const void *schedule, uint8_t *ciphertext); - -/** - * AES counter mode keystream generator. A context generated by - * OQS_AES256_CTR_inc_init() is passed rather then a key. - * - * Handles a 12- or 16-byte IV. If a 12-byte IV is given, then 4 counter - * bytes are initialized to all zeros. - * - * @param iv 12- or 16-byte initialization vector. - * @param iv_len Lengh of IV in bytes. - * @param ctx Abstract data structure for a key schedule. - * @param out Pointer to a block of memory which is big enough to contain out_len bytes; the result will be written here. - * @param out_len Length of output bytes to generate. - */ -void OQS_AES256_CTR_inc_stream_iv(const uint8_t *iv, size_t iv_len, const void *ctx, uint8_t *out, size_t out_len); - -/** - * AES counter mode keystream generator. A context generated by - * OQS_AES256_CTR_inc_init() and OQS_AES256_CTR_inc_iv() is passed - * rather than a key and an IV. The counter is internally updated, which allows - * the function to be called multiple times. - * - * @param ctx Abstract data structure for key schedule and IV. - * @param out Pointer to a block of memory which is big enough to contain out_blks*16 bytes; the result will be written here. - * @param out_blks Length of output blocks to generate, where one block is 16 bytes. - */ -void OQS_AES256_CTR_inc_stream_blks(void *ctx, uint8_t *out, size_t out_blks); - -#if defined(__cplusplus) -} // extern "C" -#endif - -#endif // OQS_AES_H diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/aes_ops.h b/prebuilt_liboqs/linux-aarch64/include/oqs/aes_ops.h deleted file mode 100644 index a64c47d..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/aes_ops.h +++ /dev/null @@ -1,124 +0,0 @@ -/** - * \file aes_ops.h - * \brief Header defining the callback API for OQS AES - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_AES_OPS_H -#define OQS_AES_OPS_H - -#include -#include - -#include - -#if defined(__cplusplus) -extern "C" { -#endif - -/** Data structure implemented by cryptographic provider for AES operations. - */ -struct OQS_AES_callbacks { - /** - * Implementation of function OQS_AES128_ECB_load_schedule. - */ - void (*AES128_ECB_load_schedule)(const uint8_t *key, void **ctx); - - /** - * Implementation of function OQS_AES256_CTR_inc_init. - */ - void (*AES128_CTR_inc_init)(const uint8_t *key, void **ctx); - - /** - * Implementation of function OQS_AES256_CTR_inc_iv. - */ - void (*AES128_CTR_inc_iv)(const uint8_t *iv, size_t iv_len, void *ctx); - - /** - * Implementation of function OQS_AES256_CTR_inc_ivu64. - */ - void (*AES128_CTR_inc_ivu64)(uint64_t iv, void *ctx); - - /** - * Implementation of function OQS_AES128_free_schedule. - */ - void (*AES128_free_schedule)(void *ctx); - - /** - * Implementation of function OQS_AES128_ECB_enc. - */ - void (*AES128_ECB_enc)(const uint8_t *plaintext, const size_t plaintext_len, const uint8_t *key, uint8_t *ciphertext); - - /** - * Implementation of function OQS_AES128_ECB_enc_sch. - */ - void (*AES128_ECB_enc_sch)(const uint8_t *plaintext, const size_t plaintext_len, const void *schedule, uint8_t *ciphertext); - - /** - * Implementation of function OQS_AES128_CTR_inc_stream_iv. - */ - void (*AES128_CTR_inc_stream_iv)(const uint8_t *iv, size_t iv_len, const void *ctx, uint8_t *out, size_t out_len); - - /** - * Implementation of function OQS_AES256_ECB_load_schedule. - */ - void (*AES256_ECB_load_schedule)(const uint8_t *key, void **ctx); - - /** - * Implementation of function OQS_AES256_CTR_inc_init. - */ - void (*AES256_CTR_inc_init)(const uint8_t *key, void **ctx); - - /** - * Implementation of function OQS_AES256_CTR_inc_iv. - */ - void (*AES256_CTR_inc_iv)(const uint8_t *iv, size_t iv_len, void *ctx); - - /** - * Implementation of function OQS_AES256_CTR_inc_ivu64. - */ - void (*AES256_CTR_inc_ivu64)(uint64_t iv, void *ctx); - - /** - * Implementation of function OQS_AES256_free_schedule. - */ - void (*AES256_free_schedule)(void *ctx); - - /** - * Implementation of function OQS_AES256_ECB_enc. - */ - void (*AES256_ECB_enc)(const uint8_t *plaintext, const size_t plaintext_len, const uint8_t *key, uint8_t *ciphertext); - - /** - * Implementation of function OQS_AES256_ECB_enc_sch. - */ - void (*AES256_ECB_enc_sch)(const uint8_t *plaintext, const size_t plaintext_len, const void *schedule, uint8_t *ciphertext); - - /** - * Implementation of function OQS_AES256_CTR_inc_stream_iv. - */ - void (*AES256_CTR_inc_stream_iv)(const uint8_t *iv, size_t iv_len, const void *ctx, uint8_t *out, size_t out_len); - - /** - * Implementation of function OQS_AES256_CTR_inc_stream_blks. - */ - void (*AES256_CTR_inc_stream_blks)(void *ctx, uint8_t *out, size_t out_blks); -}; - -/** - * Set callback functions for AES operations. - * - * This function may be called before OQS_init to switch the - * cryptographic provider for AES operations. If it is not called, the - * default provider determined at build time will be used. - * - * @param[in] new_callbacks Callback functions defined in OQS_AES_callbacks - */ -OQS_API void OQS_AES_set_callbacks(struct OQS_AES_callbacks *new_callbacks); - -#if defined(__cplusplus) -} // extern "C" -#endif - -#endif // OQS_AES_OPS_H diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/common.h b/prebuilt_liboqs/linux-aarch64/include/oqs/common.h deleted file mode 100644 index ee01ff8..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/common.h +++ /dev/null @@ -1,286 +0,0 @@ -/** - * \file common.h - * \brief Utility functions for use in liboqs. - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_COMMON_H -#define OQS_COMMON_H - -#include -#include -#include -#include - -#include - -#if defined(__cplusplus) -extern "C" { -#endif - -/** - * Macro for terminating the program if x is - * a null pointer. - */ -#define OQS_EXIT_IF_NULLPTR(x, loc) \ - do { \ - if ((x) == (void *)0) { \ - fprintf(stderr, "Unexpected NULL returned from %s API. Exiting.\n", \ - loc); \ - exit(EXIT_FAILURE); \ - } \ - } while (0) - -/** - * This macro is intended to replace those assert()s - * involving side-effecting statements in aes/aes_ossl.c. - * - * assert() becomes a no-op when -DNDEBUG is defined, - * which causes compilation failures when the statement - * being checked also results in side-effects. - * - * This is a temporary workaround until a better error - * handling strategy is developed. - */ -#ifdef OQS_USE_OPENSSL -#ifdef OPENSSL_NO_STDIO -#define OQS_OPENSSL_GUARD(x) \ - do { \ - if (1 != (x)) { \ - fprintf(stderr, "Error return value from OpenSSL API: %d. Exiting.\n", \ - x); \ - exit(EXIT_FAILURE); \ - } \ - } while (0) -#else // OPENSSL_NO_STDIO -#define OQS_OPENSSL_GUARD(x) \ - do { \ - if (1 != (x)) { \ - fprintf(stderr, "Error return value from OpenSSL API: %d. Exiting.\n", \ - x); \ - OSSL_FUNC(ERR_print_errors_fp)(stderr); \ - exit(EXIT_FAILURE); \ - } \ - } while (0) -#endif // OPENSSL_NO_STDIO -#endif // OQS_USE_OPENSSL - -/** - * Certain functions (such as OQS_randombytes_openssl in - * src/rand/rand.c) take in a size_t parameter, but can - * only handle values up to INT_MAX for those parameters. - * This macro is a temporary workaround for such functions. - */ -#define SIZE_T_TO_INT_OR_EXIT(size_t_var_name, int_var_name) \ - int int_var_name = 0; \ - if (size_t_var_name <= INT_MAX) { \ - int_var_name = (int)size_t_var_name; \ - } else { \ - exit(EXIT_FAILURE); \ - } - -/** - * Defines which functions should be exposed outside the LibOQS library - * - * By default the visibility of all the symbols is defined to "hidden" - * Only the library API should be marked as default - * - * Example: OQS_API return_value function_name(void); - */ -#if defined(_WIN32) -#define OQS_API __declspec(dllexport) -#else -#define OQS_API __attribute__((visibility("default"))) -#endif - -#if defined(OQS_SYS_UEFI) -#undef OQS_API -#define OQS_API -#endif - -/** - * Represents return values from functions. - * - * Callers should compare with the symbol rather than the individual value. - * For example, - * - * ret = OQS_KEM_encaps(...); - * if (ret == OQS_SUCCESS) { ... } - * - * rather than - * - * if (!OQS_KEM_encaps(...) { ... } - * - */ -typedef enum { - /** Used to indicate that some undefined error occurred. */ - OQS_ERROR = -1, - /** Used to indicate successful return from function. */ - OQS_SUCCESS = 0, - /** Used to indicate failures in external libraries (e.g., OpenSSL). */ - OQS_EXTERNAL_LIB_ERROR_OPENSSL = 50, -} OQS_STATUS; - -/** - * CPU runtime detection flags - */ -typedef enum { - OQS_CPU_EXT_INIT, /* Must be first */ - /* Start extension list */ - OQS_CPU_EXT_ADX, - OQS_CPU_EXT_AES, - OQS_CPU_EXT_AVX, - OQS_CPU_EXT_AVX2, - OQS_CPU_EXT_AVX512, - OQS_CPU_EXT_BMI1, - OQS_CPU_EXT_BMI2, - OQS_CPU_EXT_PCLMULQDQ, - OQS_CPU_EXT_VPCLMULQDQ, - OQS_CPU_EXT_POPCNT, - OQS_CPU_EXT_SSE, - OQS_CPU_EXT_SSE2, - OQS_CPU_EXT_SSE3, - OQS_CPU_EXT_ARM_AES, - OQS_CPU_EXT_ARM_SHA2, - OQS_CPU_EXT_ARM_SHA3, - OQS_CPU_EXT_ARM_NEON, - /* End extension list */ - OQS_CPU_EXT_COUNT, /* Must be last */ -} OQS_CPU_EXT; - -/** - * Checks if the CPU supports a given extension - * - * \return 1 if the given CPU extension is available, 0 otherwise. - */ -OQS_API int OQS_CPU_has_extension(OQS_CPU_EXT ext); - -/** - * This currently sets the values in the OQS_CPU_EXTENSIONS - * and prefetches the OpenSSL objects if necessary. - */ -OQS_API void OQS_init(void); - -/** - * This function stops OpenSSL threads, which allows resources - * to be cleaned up in the correct order. - * @note When liboqs is used in a multithreaded application, - * each thread should call this function prior to stopping. - */ -OQS_API void OQS_thread_stop(void); - -/** - * This function frees prefetched OpenSSL objects - */ -OQS_API void OQS_destroy(void); - -/** - * Return library version string. - */ -OQS_API const char *OQS_version(void); - -/** - * @brief Memory allocation and deallocation functions. - * - * These functions provide a unified interface for memory operations, - * using OpenSSL functions when OQS_USE_OPENSSL is defined, and - * standard C library functions otherwise. - */ - -/** - * Allocates memory of a given size. - * @param size The size of the memory to be allocated in bytes. - * @return A pointer to the allocated memory. - */ -OQS_API void *OQS_MEM_malloc(size_t size); - -/** - * Allocates memory for an array of elements of a given size. - * @param num_elements The number of elements to allocate. - * @param element_size The size of each element in bytes. - * @return A pointer to the allocated memory. - */ -OQS_API void *OQS_MEM_calloc(size_t num_elements, size_t element_size); - -/** - * Duplicates a string. - * @param str The string to be duplicated. - * @return A pointer to the newly allocated string. - */ -OQS_API char *OQS_MEM_strdup(const char *str); - -/** - * Constant time comparison of byte sequences `a` and `b` of length `len`. - * Returns 0 if the byte sequences are equal or if `len`=0. - * Returns 1 otherwise. - * - * @param[in] a A byte sequence of length at least `len`. - * @param[in] b A byte sequence of length at least `len`. - * @param[in] len The number of bytes to compare. - */ -OQS_API int OQS_MEM_secure_bcmp(const void *a, const void *b, size_t len); - -/** - * Zeros out `len` bytes of memory starting at `ptr`. - * - * Designed to be protected against optimizing compilers which try to remove - * "unnecessary" operations. Should be used for all buffers containing secret - * data. - * - * @param[in] ptr The start of the memory to zero out. - * @param[in] len The number of bytes to zero out. - */ -OQS_API void OQS_MEM_cleanse(void *ptr, size_t len); - -/** - * Zeros out `len` bytes of memory starting at `ptr`, then frees `ptr`. - * - * Can be called with `ptr = NULL`, in which case no operation is performed. - * - * Designed to be protected against optimizing compilers which try to remove - * "unnecessary" operations. Should be used for all buffers containing secret - * data. - * - * @param[in] ptr The start of the memory to zero out and free. - * @param[in] len The number of bytes to zero out. - */ -OQS_API void OQS_MEM_secure_free(void *ptr, size_t len); - -/** - * Frees `ptr`. - * - * Can be called with `ptr = NULL`, in which case no operation is performed. - * - * Should only be used on non-secret data. - * - * @param[in] ptr The start of the memory to free. - */ -OQS_API void OQS_MEM_insecure_free(void *ptr); - -/** - * Internal implementation of C11 aligned_alloc to work around compiler quirks. - * - * Allocates size bytes of uninitialized memory with a base pointer that is - * a multiple of alignment. Alignment must be a power of two and a multiple - * of sizeof(void *). Size must be a multiple of alignment. - * @note The allocated memory should be freed with `OQS_MEM_aligned_free` when - * it is no longer needed. - */ -void *OQS_MEM_aligned_alloc(size_t alignment, size_t size); - -/** - * Free memory allocated with OQS_MEM_aligned_alloc. - */ -void OQS_MEM_aligned_free(void *ptr); - -/** - * Free and zeroize memory allocated with OQS_MEM_aligned_alloc. - */ -void OQS_MEM_aligned_secure_free(void *ptr, size_t len); - -#if defined(__cplusplus) -} // extern "C" -#endif - -#endif // OQS_COMMON_H diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/kem.h b/prebuilt_liboqs/linux-aarch64/include/oqs/kem.h deleted file mode 100644 index fe52cd8..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/kem.h +++ /dev/null @@ -1,374 +0,0 @@ -/** - * \file kem.h - * \brief Key encapsulation mechanisms - * - * The file `tests/example_kem.c` contains two examples on using the OQS_KEM API. - * - * The first example uses the individual scheme's algorithms directly and uses - * no dynamic memory allocation -- all buffers are allocated on the stack, with - * sizes indicated using preprocessor macros. Since algorithms can be disabled at - * compile-time, the programmer should wrap the code in \#ifdefs. - * - * The second example uses an OQS_KEM object to use an algorithm specified at - * runtime. Therefore it uses dynamic memory allocation -- all buffers must be - * malloc'ed by the programmer, with sizes indicated using the corresponding length - * member of the OQS_KEM object in question. Since algorithms can be disabled at - * compile-time, the programmer should check that the OQS_KEM object is not `NULL`. - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_KEM_H -#define OQS_KEM_H - -#include -#include -#include - -#include - -#if defined(__cplusplus) -extern "C" { -#endif - -/** Algorithm identifier for BIKE-L1 KEM (Round-4). */ -#define OQS_KEM_alg_bike_l1 "BIKE-L1" -/** Algorithm identifier for BIKE-L3 KEM (Round-4). */ -#define OQS_KEM_alg_bike_l3 "BIKE-L3" -/** Algorithm identifier for BIKE-L5 KEM (Round-4). */ -#define OQS_KEM_alg_bike_l5 "BIKE-L5" -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_ALG_IDENTIFIER_START -/** Algorithm identifier for Classic-McEliece-348864 KEM. */ -#define OQS_KEM_alg_classic_mceliece_348864 "Classic-McEliece-348864" -/** Algorithm identifier for Classic-McEliece-348864f KEM. */ -#define OQS_KEM_alg_classic_mceliece_348864f "Classic-McEliece-348864f" -/** Algorithm identifier for Classic-McEliece-460896 KEM. */ -#define OQS_KEM_alg_classic_mceliece_460896 "Classic-McEliece-460896" -/** Algorithm identifier for Classic-McEliece-460896f KEM. */ -#define OQS_KEM_alg_classic_mceliece_460896f "Classic-McEliece-460896f" -/** Algorithm identifier for Classic-McEliece-6688128 KEM. */ -#define OQS_KEM_alg_classic_mceliece_6688128 "Classic-McEliece-6688128" -/** Algorithm identifier for Classic-McEliece-6688128f KEM. */ -#define OQS_KEM_alg_classic_mceliece_6688128f "Classic-McEliece-6688128f" -/** Algorithm identifier for Classic-McEliece-6960119 KEM. */ -#define OQS_KEM_alg_classic_mceliece_6960119 "Classic-McEliece-6960119" -/** Algorithm identifier for Classic-McEliece-6960119f KEM. */ -#define OQS_KEM_alg_classic_mceliece_6960119f "Classic-McEliece-6960119f" -/** Algorithm identifier for Classic-McEliece-8192128 KEM. */ -#define OQS_KEM_alg_classic_mceliece_8192128 "Classic-McEliece-8192128" -/** Algorithm identifier for Classic-McEliece-8192128f KEM. */ -#define OQS_KEM_alg_classic_mceliece_8192128f "Classic-McEliece-8192128f" -/** Algorithm identifier for HQC-128 KEM. */ -#define OQS_KEM_alg_hqc_128 "HQC-128" -/** Algorithm identifier for HQC-192 KEM. */ -#define OQS_KEM_alg_hqc_192 "HQC-192" -/** Algorithm identifier for HQC-256 KEM. */ -#define OQS_KEM_alg_hqc_256 "HQC-256" -/** Algorithm identifier for Kyber512 KEM. */ -#define OQS_KEM_alg_kyber_512 "Kyber512" -/** Algorithm identifier for Kyber768 KEM. */ -#define OQS_KEM_alg_kyber_768 "Kyber768" -/** Algorithm identifier for Kyber1024 KEM. */ -#define OQS_KEM_alg_kyber_1024 "Kyber1024" -/** Algorithm identifier for ML-KEM-512 KEM. */ -#define OQS_KEM_alg_ml_kem_512 "ML-KEM-512" -/** Algorithm identifier for ML-KEM-768 KEM. */ -#define OQS_KEM_alg_ml_kem_768 "ML-KEM-768" -/** Algorithm identifier for ML-KEM-1024 KEM. */ -#define OQS_KEM_alg_ml_kem_1024 "ML-KEM-1024" -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_ALG_IDENTIFIER_END -/** Algorithm identifier for NTRU-HPS-2048-509 KEM. */ -#define OQS_KEM_alg_ntru_hps2048509 "NTRU-HPS-2048-509" -/** Algorithm identifier for NTRU-HPS-2048-677 KEM. */ -#define OQS_KEM_alg_ntru_hps2048677 "NTRU-HPS-2048-677" -/** Algorithm identifier for NTRU-HPS-4096-821 KEM. */ -#define OQS_KEM_alg_ntru_hps4096821 "NTRU-HPS-4096-821" -/** Algorithm identifier for NTRU-HPS-4096-1229 KEM. */ -#define OQS_KEM_alg_ntru_hps40961229 "NTRU-HPS-4096-1229" -/** Algorithm identifier for NTRU-HRSS-701 KEM. */ -#define OQS_KEM_alg_ntru_hrss701 "NTRU-HRSS-701" -/** Algorithm identifier for NTRU-HRSS-1373 KEM. */ -#define OQS_KEM_alg_ntru_hrss1373 "NTRU-HRSS-1373" -/** Algorithm identifier for sntrup761 KEM. */ -#define OQS_KEM_alg_ntruprime_sntrup761 "sntrup761" -/** Algorithm identifier for FrodoKEM-640-AES KEM. */ -#define OQS_KEM_alg_frodokem_640_aes "FrodoKEM-640-AES" -/** Algorithm identifier for FrodoKEM-640-SHAKE KEM. */ -#define OQS_KEM_alg_frodokem_640_shake "FrodoKEM-640-SHAKE" -/** Algorithm identifier for FrodoKEM-976-AES KEM. */ -#define OQS_KEM_alg_frodokem_976_aes "FrodoKEM-976-AES" -/** Algorithm identifier for FrodoKEM-976-SHAKE KEM. */ -#define OQS_KEM_alg_frodokem_976_shake "FrodoKEM-976-SHAKE" -/** Algorithm identifier for FrodoKEM-1344-AES KEM. */ -#define OQS_KEM_alg_frodokem_1344_aes "FrodoKEM-1344-AES" -/** Algorithm identifier for FrodoKEM-1344-SHAKE KEM. */ -#define OQS_KEM_alg_frodokem_1344_shake "FrodoKEM-1344-SHAKE" -// EDIT-WHEN-ADDING-KEM -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_ALGS_LENGTH_START - -/** Number of algorithm identifiers above. */ -#define OQS_KEM_algs_length 35 -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_ALGS_LENGTH_END - -/** - * Returns identifiers for available key encapsulation mechanisms in liboqs. Used with OQS_KEM_new. - * - * Note that algorithm identifiers are present in this list even when the algorithm is disabled - * at compile time. - * - * @param[in] i Index of the algorithm identifier to return, 0 <= i < OQS_KEM_algs_length - * @return Algorithm identifier as a string, or NULL. - */ -OQS_API const char *OQS_KEM_alg_identifier(size_t i); - -/** - * Returns the number of key encapsulation mechanisms in liboqs. They can be enumerated with - * OQS_KEM_alg_identifier. - * - * Note that some mechanisms may be disabled at compile time. - * - * @return The number of key encapsulation mechanisms. - */ -OQS_API int OQS_KEM_alg_count(void); - -/** - * Indicates whether the specified algorithm was enabled at compile-time or not. - * - * @param[in] method_name Name of the desired algorithm; one of the names in `OQS_KEM_algs`. - * @return 1 if enabled, 0 if disabled or not found - */ -OQS_API int OQS_KEM_alg_is_enabled(const char *method_name); - -/** - * Key encapsulation mechanism object - */ -typedef struct OQS_KEM { - - /** Printable string representing the name of the key encapsulation mechanism. */ - const char *method_name; - - /** - * Printable string representing the version of the cryptographic algorithm. - * - * Implementations with the same method_name and same alg_version will be interoperable. - * See README.md for information about algorithm compatibility. - */ - const char *alg_version; - - /** The NIST security level (1, 2, 3, 4, 5) claimed in this algorithm's original NIST submission. */ - uint8_t claimed_nist_level; - - /** Whether the KEM offers IND-CCA security (TRUE) or IND-CPA security (FALSE). */ - bool ind_cca; - - /** The length, in bytes, of public keys for this KEM. */ - size_t length_public_key; - /** The length, in bytes, of secret keys for this KEM. */ - size_t length_secret_key; - /** The length, in bytes, of ciphertexts for this KEM. */ - size_t length_ciphertext; - /** The length, in bytes, of shared secrets for this KEM. */ - size_t length_shared_secret; - /** The length, in bytes, of seeds for derandomized keypair generation for this KEM. */ - size_t length_keypair_seed; - /** The length, in bytes, of seeds for derandomized encaps generation for this KEM. */ - size_t length_encaps_seed; - - /** - * Derandomized keypair generation algorithm. - * - * Caller is responsible for allocating sufficient memory for `public_key` and - * `secret_key`, based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_KEM_*_length_*`. - * - * @param[out] public_key The public key represented as a byte string. - * @param[out] secret_key The secret key represented as a byte string. - * @param[in] seed The input randomness represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*keypair_derand)(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); - - /** - * Keypair generation algorithm. - * - * Caller is responsible for allocating sufficient memory for `public_key` and - * `secret_key`, based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_KEM_*_length_*`. - * - * @param[out] public_key The public key represented as a byte string. - * @param[out] secret_key The secret key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*keypair)(uint8_t *public_key, uint8_t *secret_key); - - /** - * Derandomized encapsulation algorithm. - * - * Caller is responsible for allocating sufficient memory for `ciphertext` and - * `shared_secret`, based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_KEM_*_length_*`. - * - * @param[out] ciphertext The ciphertext (encapsulation) represented as a byte string. - * @param[out] shared_secret The shared secret represented as a byte string. - * @param[in] public_key The public key represented as a byte string. - * @param[in] seed The input randomness represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*encaps_derand)(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); - - /** - * Encapsulation algorithm. - * - * Caller is responsible for allocating sufficient memory for `ciphertext` and - * `shared_secret`, based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_KEM_*_length_*`. - * - * @param[out] ciphertext The ciphertext (encapsulation) represented as a byte string. - * @param[out] shared_secret The shared secret represented as a byte string. - * @param[in] public_key The public key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*encaps)(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); - - /** - * Decapsulation algorithm. - * - * Caller is responsible for allocating sufficient memory for `shared_secret`, based - * on the `length_*` members in this object or the per-scheme compile-time macros - * `OQS_KEM_*_length_*`. - * - * @param[out] shared_secret The shared secret represented as a byte string. - * @param[in] ciphertext The ciphertext (encapsulation) represented as a byte string. - * @param[in] secret_key The secret key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*decaps)(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); - -} OQS_KEM; - -/** - * Constructs an OQS_KEM object for a particular algorithm. - * - * Callers should always check whether the return value is `NULL`, which indicates either than an - * invalid algorithm name was provided, or that the requested algorithm was disabled at compile-time. - * - * @param[in] method_name Name of the desired algorithm; one of the names in `OQS_KEM_algs`. - * @return An OQS_KEM for the particular algorithm, or `NULL` if the algorithm has been disabled at compile-time. - */ -OQS_API OQS_KEM *OQS_KEM_new(const char *method_name); - -/** - * Derandomized keypair generation algorithm. - * - * Caller is responsible for allocating sufficient memory for `public_key` and - * `secret_key`, based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_KEM_*_length_*`. - * - * @param[in] kem The OQS_KEM object representing the KEM. - * @param[out] public_key The public key represented as a byte string. - * @param[out] secret_key The secret key represented as a byte string. - * @param[in] seed The input randomness represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_KEM_keypair_derand(const OQS_KEM *kem, uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); - -/** - * Keypair generation algorithm. - * - * Caller is responsible for allocating sufficient memory for `public_key` and - * `secret_key`, based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_KEM_*_length_*`. - * - * @param[in] kem The OQS_KEM object representing the KEM. - * @param[out] public_key The public key represented as a byte string. - * @param[out] secret_key The secret key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_KEM_keypair(const OQS_KEM *kem, uint8_t *public_key, uint8_t *secret_key); - -/** - * Derandomized encapsulation algorithm. - * - * Caller is responsible for allocating sufficient memory for `ciphertext` and - * `shared_secret`, based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_KEM_*_length_*`. - * - * @param[in] kem The OQS_KEM object representing the KEM. - * @param[out] ciphertext The ciphertext (encapsulation) represented as a byte string. - * @param[out] shared_secret The shared secret represented as a byte string. - * @param[in] public_key The public key represented as a byte string. - * @param[in] seed The input randomness represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_KEM_encaps_derand(const OQS_KEM *kem, uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); - -/** - * Encapsulation algorithm. - * - * Caller is responsible for allocating sufficient memory for `ciphertext` and - * `shared_secret`, based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_KEM_*_length_*`. - * - * @param[in] kem The OQS_KEM object representing the KEM. - * @param[out] ciphertext The ciphertext (encapsulation) represented as a byte string. - * @param[out] shared_secret The shared secret represented as a byte string. - * @param[in] public_key The public key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_KEM_encaps(const OQS_KEM *kem, uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); - -/** - * Decapsulation algorithm. - * - * Caller is responsible for allocating sufficient memory for `shared_secret`, based - * on the `length_*` members in this object or the per-scheme compile-time macros - * `OQS_KEM_*_length_*`. - * - * @param[in] kem The OQS_KEM object representing the KEM. - * @param[out] shared_secret The shared secret represented as a byte string. - * @param[in] ciphertext The ciphertext (encapsulation) represented as a byte string. - * @param[in] secret_key The secret key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_KEM_decaps(const OQS_KEM *kem, uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); - -/** - * Frees an OQS_KEM object that was constructed by OQS_KEM_new. - * - * @param[in] kem The OQS_KEM object to free. - */ -OQS_API void OQS_KEM_free(OQS_KEM *kem); - -#ifdef OQS_ENABLE_KEM_BIKE -#include -#endif /* OQS_ENABLE_KEM_BIKE */ -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_INCLUDE_START -#ifdef OQS_ENABLE_KEM_CLASSIC_MCELIECE -#include -#endif /* OQS_ENABLE_KEM_CLASSIC_MCELIECE */ -#ifdef OQS_ENABLE_KEM_HQC -#include -#endif /* OQS_ENABLE_KEM_HQC */ -#ifdef OQS_ENABLE_KEM_KYBER -#include -#endif /* OQS_ENABLE_KEM_KYBER */ -#ifdef OQS_ENABLE_KEM_ML_KEM -#include -#endif /* OQS_ENABLE_KEM_ML_KEM */ -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_INCLUDE_END -#ifdef OQS_ENABLE_KEM_NTRU -#include -#endif /* OQS_ENABLE_KEM_NTRU */ -#ifdef OQS_ENABLE_KEM_NTRUPRIME -#include -#endif /* OQS_ENABLE_KEM_NTRUPRIME */ -#ifdef OQS_ENABLE_KEM_FRODOKEM -#include -#endif /* OQS_ENABLE_KEM_FRODOKEM */ -// EDIT-WHEN-ADDING-KEM - -#if defined(__cplusplus) -} // extern "C" -#endif - -#endif // OQS_KEM_H diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/kem_bike.h b/prebuilt_liboqs/linux-aarch64/include/oqs/kem_bike.h deleted file mode 100644 index beac165..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/kem_bike.h +++ /dev/null @@ -1,54 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_KEM_BIKE_H -#define OQS_KEM_BIKE_H - -#include - -// Round-4 KEMs -#ifdef OQS_ENABLE_KEM_bike_l1 -#define OQS_KEM_bike_l1_length_secret_key 5223 -#define OQS_KEM_bike_l1_length_public_key 1541 -#define OQS_KEM_bike_l1_length_ciphertext 1573 -#define OQS_KEM_bike_l1_length_shared_secret 32 -#define OQS_KEM_bike_l1_length_keypair_seed 0 -#define OQS_KEM_bike_l1_length_encaps_seed 0 -OQS_KEM *OQS_KEM_bike_l1_new(void); -OQS_API OQS_STATUS OQS_KEM_bike_l1_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_bike_l1_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_bike_l1_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_bike_l1_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_bike_l1_decaps(uint8_t *shared_secret, const unsigned char *ciphertext, const uint8_t *secret_key); -#endif - -#ifdef OQS_ENABLE_KEM_bike_l3 -#define OQS_KEM_bike_l3_length_secret_key 10105 -#define OQS_KEM_bike_l3_length_public_key 3083 -#define OQS_KEM_bike_l3_length_ciphertext 3115 -#define OQS_KEM_bike_l3_length_shared_secret 32 -#define OQS_KEM_bike_l3_length_keypair_seed 0 -#define OQS_KEM_bike_l3_length_encaps_seed 0 -OQS_KEM *OQS_KEM_bike_l3_new(void); -OQS_API OQS_STATUS OQS_KEM_bike_l3_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_bike_l3_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_bike_l3_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_bike_l3_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_bike_l3_decaps(uint8_t *shared_secret, const unsigned char *ciphertext, const uint8_t *secret_key); -#endif - -#ifdef OQS_ENABLE_KEM_bike_l5 -#define OQS_KEM_bike_l5_length_secret_key 16494 -#define OQS_KEM_bike_l5_length_public_key 5122 -#define OQS_KEM_bike_l5_length_ciphertext 5154 -#define OQS_KEM_bike_l5_length_shared_secret 32 -#define OQS_KEM_bike_l5_length_keypair_seed 0 -#define OQS_KEM_bike_l5_length_encaps_seed 0 -OQS_KEM *OQS_KEM_bike_l5_new(void); -OQS_API OQS_STATUS OQS_KEM_bike_l5_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_bike_l5_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_bike_l5_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_bike_l5_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_bike_l5_decaps(uint8_t *shared_secret, const unsigned char *ciphertext, const uint8_t *secret_key); -#endif - -#endif // OQS_KEM_BIKE_H diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/kem_classic_mceliece.h b/prebuilt_liboqs/linux-aarch64/include/oqs/kem_classic_mceliece.h deleted file mode 100644 index 13613e7..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/kem_classic_mceliece.h +++ /dev/null @@ -1,159 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_KEM_CLASSIC_MCELIECE_H -#define OQS_KEM_CLASSIC_MCELIECE_H - -#include - -#if defined(OQS_ENABLE_KEM_classic_mceliece_348864) -#define OQS_KEM_classic_mceliece_348864_length_public_key 261120 -#define OQS_KEM_classic_mceliece_348864_length_secret_key 6492 -#define OQS_KEM_classic_mceliece_348864_length_ciphertext 96 -#define OQS_KEM_classic_mceliece_348864_length_shared_secret 32 -#define OQS_KEM_classic_mceliece_348864_length_keypair_seed 0 -#define OQS_KEM_classic_mceliece_348864_length_encaps_seed 0 -OQS_KEM *OQS_KEM_classic_mceliece_348864_new(void); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_348864_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_348864_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_348864_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_348864_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_348864_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_classic_mceliece_348864f) -#define OQS_KEM_classic_mceliece_348864f_length_public_key 261120 -#define OQS_KEM_classic_mceliece_348864f_length_secret_key 6492 -#define OQS_KEM_classic_mceliece_348864f_length_ciphertext 96 -#define OQS_KEM_classic_mceliece_348864f_length_shared_secret 32 -#define OQS_KEM_classic_mceliece_348864f_length_keypair_seed 0 -#define OQS_KEM_classic_mceliece_348864f_length_encaps_seed 0 -OQS_KEM *OQS_KEM_classic_mceliece_348864f_new(void); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_348864f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_348864f_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_348864f_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_348864f_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_348864f_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_classic_mceliece_460896) -#define OQS_KEM_classic_mceliece_460896_length_public_key 524160 -#define OQS_KEM_classic_mceliece_460896_length_secret_key 13608 -#define OQS_KEM_classic_mceliece_460896_length_ciphertext 156 -#define OQS_KEM_classic_mceliece_460896_length_shared_secret 32 -#define OQS_KEM_classic_mceliece_460896_length_keypair_seed 0 -#define OQS_KEM_classic_mceliece_460896_length_encaps_seed 0 -OQS_KEM *OQS_KEM_classic_mceliece_460896_new(void); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_460896_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_460896_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_460896_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_460896_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_460896_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_classic_mceliece_460896f) -#define OQS_KEM_classic_mceliece_460896f_length_public_key 524160 -#define OQS_KEM_classic_mceliece_460896f_length_secret_key 13608 -#define OQS_KEM_classic_mceliece_460896f_length_ciphertext 156 -#define OQS_KEM_classic_mceliece_460896f_length_shared_secret 32 -#define OQS_KEM_classic_mceliece_460896f_length_keypair_seed 0 -#define OQS_KEM_classic_mceliece_460896f_length_encaps_seed 0 -OQS_KEM *OQS_KEM_classic_mceliece_460896f_new(void); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_460896f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_460896f_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_460896f_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_460896f_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_460896f_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_classic_mceliece_6688128) -#define OQS_KEM_classic_mceliece_6688128_length_public_key 1044992 -#define OQS_KEM_classic_mceliece_6688128_length_secret_key 13932 -#define OQS_KEM_classic_mceliece_6688128_length_ciphertext 208 -#define OQS_KEM_classic_mceliece_6688128_length_shared_secret 32 -#define OQS_KEM_classic_mceliece_6688128_length_keypair_seed 0 -#define OQS_KEM_classic_mceliece_6688128_length_encaps_seed 0 -OQS_KEM *OQS_KEM_classic_mceliece_6688128_new(void); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6688128_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6688128_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6688128_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6688128_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6688128_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_classic_mceliece_6688128f) -#define OQS_KEM_classic_mceliece_6688128f_length_public_key 1044992 -#define OQS_KEM_classic_mceliece_6688128f_length_secret_key 13932 -#define OQS_KEM_classic_mceliece_6688128f_length_ciphertext 208 -#define OQS_KEM_classic_mceliece_6688128f_length_shared_secret 32 -#define OQS_KEM_classic_mceliece_6688128f_length_keypair_seed 0 -#define OQS_KEM_classic_mceliece_6688128f_length_encaps_seed 0 -OQS_KEM *OQS_KEM_classic_mceliece_6688128f_new(void); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6688128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6688128f_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6688128f_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6688128f_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6688128f_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_classic_mceliece_6960119) -#define OQS_KEM_classic_mceliece_6960119_length_public_key 1047319 -#define OQS_KEM_classic_mceliece_6960119_length_secret_key 13948 -#define OQS_KEM_classic_mceliece_6960119_length_ciphertext 194 -#define OQS_KEM_classic_mceliece_6960119_length_shared_secret 32 -#define OQS_KEM_classic_mceliece_6960119_length_keypair_seed 0 -#define OQS_KEM_classic_mceliece_6960119_length_encaps_seed 0 -OQS_KEM *OQS_KEM_classic_mceliece_6960119_new(void); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6960119_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6960119_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6960119_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6960119_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6960119_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_classic_mceliece_6960119f) -#define OQS_KEM_classic_mceliece_6960119f_length_public_key 1047319 -#define OQS_KEM_classic_mceliece_6960119f_length_secret_key 13948 -#define OQS_KEM_classic_mceliece_6960119f_length_ciphertext 194 -#define OQS_KEM_classic_mceliece_6960119f_length_shared_secret 32 -#define OQS_KEM_classic_mceliece_6960119f_length_keypair_seed 0 -#define OQS_KEM_classic_mceliece_6960119f_length_encaps_seed 0 -OQS_KEM *OQS_KEM_classic_mceliece_6960119f_new(void); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6960119f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6960119f_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6960119f_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6960119f_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6960119f_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_classic_mceliece_8192128) -#define OQS_KEM_classic_mceliece_8192128_length_public_key 1357824 -#define OQS_KEM_classic_mceliece_8192128_length_secret_key 14120 -#define OQS_KEM_classic_mceliece_8192128_length_ciphertext 208 -#define OQS_KEM_classic_mceliece_8192128_length_shared_secret 32 -#define OQS_KEM_classic_mceliece_8192128_length_keypair_seed 0 -#define OQS_KEM_classic_mceliece_8192128_length_encaps_seed 0 -OQS_KEM *OQS_KEM_classic_mceliece_8192128_new(void); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_8192128_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_8192128_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_8192128_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_8192128_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_8192128_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_classic_mceliece_8192128f) -#define OQS_KEM_classic_mceliece_8192128f_length_public_key 1357824 -#define OQS_KEM_classic_mceliece_8192128f_length_secret_key 14120 -#define OQS_KEM_classic_mceliece_8192128f_length_ciphertext 208 -#define OQS_KEM_classic_mceliece_8192128f_length_shared_secret 32 -#define OQS_KEM_classic_mceliece_8192128f_length_keypair_seed 0 -#define OQS_KEM_classic_mceliece_8192128f_length_encaps_seed 0 -OQS_KEM *OQS_KEM_classic_mceliece_8192128f_new(void); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_8192128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_8192128f_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_8192128f_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_8192128f_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_8192128f_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#endif - diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/kem_frodokem.h b/prebuilt_liboqs/linux-aarch64/include/oqs/kem_frodokem.h deleted file mode 100644 index 56a38c9..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/kem_frodokem.h +++ /dev/null @@ -1,98 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_KEM_FRODOKEM_H -#define OQS_KEM_FRODOKEM_H - -#include - -#ifdef OQS_ENABLE_KEM_frodokem_640_aes -#define OQS_KEM_frodokem_640_aes_length_public_key 9616 -#define OQS_KEM_frodokem_640_aes_length_secret_key 19888 -#define OQS_KEM_frodokem_640_aes_length_ciphertext 9720 -#define OQS_KEM_frodokem_640_aes_length_shared_secret 16 -#define OQS_KEM_frodokem_640_aes_length_keypair_seed 0 -#define OQS_KEM_frodokem_640_aes_length_encaps_seed 0 -OQS_KEM *OQS_KEM_frodokem_640_aes_new(void); -OQS_API OQS_STATUS OQS_KEM_frodokem_640_aes_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_frodokem_640_aes_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_frodokem_640_aes_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_frodokem_640_aes_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_frodokem_640_aes_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#ifdef OQS_ENABLE_KEM_frodokem_640_shake -#define OQS_KEM_frodokem_640_shake_length_public_key 9616 -#define OQS_KEM_frodokem_640_shake_length_secret_key 19888 -#define OQS_KEM_frodokem_640_shake_length_ciphertext 9720 -#define OQS_KEM_frodokem_640_shake_length_shared_secret 16 -#define OQS_KEM_frodokem_640_shake_length_keypair_seed 0 -#define OQS_KEM_frodokem_640_shake_length_encaps_seed 0 -OQS_KEM *OQS_KEM_frodokem_640_shake_new(void); -OQS_API OQS_STATUS OQS_KEM_frodokem_640_shake_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_frodokem_640_shake_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_frodokem_640_shake_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_frodokem_640_shake_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_frodokem_640_shake_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#ifdef OQS_ENABLE_KEM_frodokem_976_aes -#define OQS_KEM_frodokem_976_aes_length_public_key 15632 -#define OQS_KEM_frodokem_976_aes_length_secret_key 31296 -#define OQS_KEM_frodokem_976_aes_length_ciphertext 15744 -#define OQS_KEM_frodokem_976_aes_length_shared_secret 24 -#define OQS_KEM_frodokem_976_aes_length_keypair_seed 0 -#define OQS_KEM_frodokem_976_aes_length_encaps_seed 0 -OQS_KEM *OQS_KEM_frodokem_976_aes_new(void); -OQS_API OQS_STATUS OQS_KEM_frodokem_976_aes_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_frodokem_976_aes_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_frodokem_976_aes_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_frodokem_976_aes_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_frodokem_976_aes_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#ifdef OQS_ENABLE_KEM_frodokem_976_shake -#define OQS_KEM_frodokem_976_shake_length_public_key 15632 -#define OQS_KEM_frodokem_976_shake_length_secret_key 31296 -#define OQS_KEM_frodokem_976_shake_length_ciphertext 15744 -#define OQS_KEM_frodokem_976_shake_length_shared_secret 24 -#define OQS_KEM_frodokem_976_shake_length_keypair_seed 0 -#define OQS_KEM_frodokem_976_shake_length_encaps_seed 0 -OQS_KEM *OQS_KEM_frodokem_976_shake_new(void); -OQS_API OQS_STATUS OQS_KEM_frodokem_976_shake_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_frodokem_976_shake_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_frodokem_976_shake_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_frodokem_976_shake_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_frodokem_976_shake_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#ifdef OQS_ENABLE_KEM_frodokem_1344_aes -#define OQS_KEM_frodokem_1344_aes_length_public_key 21520 -#define OQS_KEM_frodokem_1344_aes_length_secret_key 43088 -#define OQS_KEM_frodokem_1344_aes_length_ciphertext 21632 -#define OQS_KEM_frodokem_1344_aes_length_shared_secret 32 -#define OQS_KEM_frodokem_1344_aes_length_keypair_seed 0 -#define OQS_KEM_frodokem_1344_aes_length_encaps_seed 0 -OQS_KEM *OQS_KEM_frodokem_1344_aes_new(void); -OQS_API OQS_STATUS OQS_KEM_frodokem_1344_aes_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_frodokem_1344_aes_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_frodokem_1344_aes_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_frodokem_1344_aes_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_frodokem_1344_aes_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#ifdef OQS_ENABLE_KEM_frodokem_1344_shake -#define OQS_KEM_frodokem_1344_shake_length_public_key 21520 -#define OQS_KEM_frodokem_1344_shake_length_secret_key 43088 -#define OQS_KEM_frodokem_1344_shake_length_ciphertext 21632 -#define OQS_KEM_frodokem_1344_shake_length_shared_secret 32 -#define OQS_KEM_frodokem_1344_shake_length_keypair_seed 0 -#define OQS_KEM_frodokem_1344_shake_length_encaps_seed 0 -OQS_KEM *OQS_KEM_frodokem_1344_shake_new(void); -OQS_API OQS_STATUS OQS_KEM_frodokem_1344_shake_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_frodokem_1344_shake_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_frodokem_1344_shake_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_frodokem_1344_shake_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_frodokem_1344_shake_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#endif // OQS_KEM_FRODOKEM_H diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/kem_kyber.h b/prebuilt_liboqs/linux-aarch64/include/oqs/kem_kyber.h deleted file mode 100644 index 7915704..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/kem_kyber.h +++ /dev/null @@ -1,54 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_KEM_KYBER_H -#define OQS_KEM_KYBER_H - -#include - -#if defined(OQS_ENABLE_KEM_kyber_512) -#define OQS_KEM_kyber_512_length_public_key 800 -#define OQS_KEM_kyber_512_length_secret_key 1632 -#define OQS_KEM_kyber_512_length_ciphertext 768 -#define OQS_KEM_kyber_512_length_shared_secret 32 -#define OQS_KEM_kyber_512_length_keypair_seed 0 -#define OQS_KEM_kyber_512_length_encaps_seed 0 -OQS_KEM *OQS_KEM_kyber_512_new(void); -OQS_API OQS_STATUS OQS_KEM_kyber_512_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_kyber_512_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_kyber_512_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_kyber_512_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_kyber_512_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_kyber_768) -#define OQS_KEM_kyber_768_length_public_key 1184 -#define OQS_KEM_kyber_768_length_secret_key 2400 -#define OQS_KEM_kyber_768_length_ciphertext 1088 -#define OQS_KEM_kyber_768_length_shared_secret 32 -#define OQS_KEM_kyber_768_length_keypair_seed 0 -#define OQS_KEM_kyber_768_length_encaps_seed 0 -OQS_KEM *OQS_KEM_kyber_768_new(void); -OQS_API OQS_STATUS OQS_KEM_kyber_768_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_kyber_768_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_kyber_768_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_kyber_768_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_kyber_768_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_kyber_1024) -#define OQS_KEM_kyber_1024_length_public_key 1568 -#define OQS_KEM_kyber_1024_length_secret_key 3168 -#define OQS_KEM_kyber_1024_length_ciphertext 1568 -#define OQS_KEM_kyber_1024_length_shared_secret 32 -#define OQS_KEM_kyber_1024_length_keypair_seed 0 -#define OQS_KEM_kyber_1024_length_encaps_seed 0 -OQS_KEM *OQS_KEM_kyber_1024_new(void); -OQS_API OQS_STATUS OQS_KEM_kyber_1024_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_kyber_1024_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_kyber_1024_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_kyber_1024_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_kyber_1024_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#endif - diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/kem_ml_kem.h b/prebuilt_liboqs/linux-aarch64/include/oqs/kem_ml_kem.h deleted file mode 100644 index be45e17..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/kem_ml_kem.h +++ /dev/null @@ -1,54 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_KEM_ML_KEM_H -#define OQS_KEM_ML_KEM_H - -#include - -#if defined(OQS_ENABLE_KEM_ml_kem_512) -#define OQS_KEM_ml_kem_512_length_public_key 800 -#define OQS_KEM_ml_kem_512_length_secret_key 1632 -#define OQS_KEM_ml_kem_512_length_ciphertext 768 -#define OQS_KEM_ml_kem_512_length_shared_secret 32 -#define OQS_KEM_ml_kem_512_length_keypair_seed 64 -#define OQS_KEM_ml_kem_512_length_encaps_seed 32 -OQS_KEM *OQS_KEM_ml_kem_512_new(void); -OQS_API OQS_STATUS OQS_KEM_ml_kem_512_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_ml_kem_512_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ml_kem_512_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_ml_kem_512_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ml_kem_512_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_ml_kem_768) -#define OQS_KEM_ml_kem_768_length_public_key 1184 -#define OQS_KEM_ml_kem_768_length_secret_key 2400 -#define OQS_KEM_ml_kem_768_length_ciphertext 1088 -#define OQS_KEM_ml_kem_768_length_shared_secret 32 -#define OQS_KEM_ml_kem_768_length_keypair_seed 64 -#define OQS_KEM_ml_kem_768_length_encaps_seed 32 -OQS_KEM *OQS_KEM_ml_kem_768_new(void); -OQS_API OQS_STATUS OQS_KEM_ml_kem_768_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_ml_kem_768_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ml_kem_768_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_ml_kem_768_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ml_kem_768_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_ml_kem_1024) -#define OQS_KEM_ml_kem_1024_length_public_key 1568 -#define OQS_KEM_ml_kem_1024_length_secret_key 3168 -#define OQS_KEM_ml_kem_1024_length_ciphertext 1568 -#define OQS_KEM_ml_kem_1024_length_shared_secret 32 -#define OQS_KEM_ml_kem_1024_length_keypair_seed 64 -#define OQS_KEM_ml_kem_1024_length_encaps_seed 32 -OQS_KEM *OQS_KEM_ml_kem_1024_new(void); -OQS_API OQS_STATUS OQS_KEM_ml_kem_1024_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_ml_kem_1024_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ml_kem_1024_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_ml_kem_1024_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ml_kem_1024_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#endif - diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/kem_ntru.h b/prebuilt_liboqs/linux-aarch64/include/oqs/kem_ntru.h deleted file mode 100644 index 93f7999..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/kem_ntru.h +++ /dev/null @@ -1,93 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_KEM_NTRU_H -#define OQS_KEM_NTRU_H - -#include - -#ifdef OQS_ENABLE_KEM_ntru_hps2048509 -#define OQS_KEM_ntru_hps2048509_length_public_key 699 -#define OQS_KEM_ntru_hps2048509_length_secret_key 935 -#define OQS_KEM_ntru_hps2048509_length_ciphertext 699 -#define OQS_KEM_ntru_hps2048509_length_shared_secret 32 -#define OQS_KEM_ntru_hps2048509_length_keypair_seed 0 -#define OQS_KEM_ntru_hps2048509_length_encaps_seed 0 -OQS_KEM *OQS_KEM_ntru_hps2048509_new(void); -OQS_API OQS_STATUS OQS_KEM_ntru_hps2048509_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_ntru_hps2048509_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ntru_hps2048509_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_ntru_hps2048509_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#ifdef OQS_ENABLE_KEM_ntru_hps2048677 -#define OQS_KEM_ntru_hps2048677_length_public_key 930 -#define OQS_KEM_ntru_hps2048677_length_secret_key 1234 -#define OQS_KEM_ntru_hps2048677_length_ciphertext 930 -#define OQS_KEM_ntru_hps2048677_length_shared_secret 32 -#define OQS_KEM_ntru_hps2048677_length_keypair_seed 0 -#define OQS_KEM_ntru_hps2048677_length_encaps_seed 0 -OQS_KEM *OQS_KEM_ntru_hps2048677_new(void); -OQS_API OQS_STATUS OQS_KEM_ntru_hps2048677_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_ntru_hps2048677_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ntru_hps2048677_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_ntru_hps2048677_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#ifdef OQS_ENABLE_KEM_ntru_hps4096821 -#define OQS_KEM_ntru_hps4096821_length_public_key 1230 -#define OQS_KEM_ntru_hps4096821_length_secret_key 1590 -#define OQS_KEM_ntru_hps4096821_length_ciphertext 1230 -#define OQS_KEM_ntru_hps4096821_length_shared_secret 32 -#define OQS_KEM_ntru_hps4096821_length_keypair_seed 0 -#define OQS_KEM_ntru_hps4096821_length_encaps_seed 0 -OQS_KEM *OQS_KEM_ntru_hps4096821_new(void); -OQS_API OQS_STATUS OQS_KEM_ntru_hps4096821_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_ntru_hps4096821_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ntru_hps4096821_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_ntru_hps4096821_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#ifdef OQS_ENABLE_KEM_ntru_hps40961229 -#define OQS_KEM_ntru_hps40961229_length_public_key 1842 -#define OQS_KEM_ntru_hps40961229_length_secret_key 2366 -#define OQS_KEM_ntru_hps40961229_length_ciphertext 1842 -#define OQS_KEM_ntru_hps40961229_length_shared_secret 32 -#define OQS_KEM_ntru_hps40961229_length_keypair_seed 0 -#define OQS_KEM_ntru_hps40961229_length_encaps_seed 0 -OQS_KEM *OQS_KEM_ntru_hps40961229_new(void); -OQS_API OQS_STATUS OQS_KEM_ntru_hps40961229_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_ntru_hps40961229_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ntru_hps40961229_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_ntru_hps40961229_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#ifdef OQS_ENABLE_KEM_ntru_hrss701 -#define OQS_KEM_ntru_hrss701_length_public_key 1138 -#define OQS_KEM_ntru_hrss701_length_secret_key 1450 -#define OQS_KEM_ntru_hrss701_length_ciphertext 1138 -#define OQS_KEM_ntru_hrss701_length_shared_secret 32 -#define OQS_KEM_ntru_hrss701_length_keypair_seed 0 -#define OQS_KEM_ntru_hrss701_length_encaps_seed 0 -OQS_KEM *OQS_KEM_ntru_hrss701_new(void); -OQS_API OQS_STATUS OQS_KEM_ntru_hrss701_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_ntru_hrss701_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ntru_hrss701_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_ntru_hrss701_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#ifdef OQS_ENABLE_KEM_ntru_hrss1373 -#define OQS_KEM_ntru_hrss1373_length_public_key 2401 -#define OQS_KEM_ntru_hrss1373_length_secret_key 2983 -#define OQS_KEM_ntru_hrss1373_length_ciphertext 2401 -#define OQS_KEM_ntru_hrss1373_length_shared_secret 32 -#define OQS_KEM_ntru_hrss1373_length_keypair_seed 0 -#define OQS_KEM_ntru_hrss1373_length_encaps_seed 0 -OQS_KEM *OQS_KEM_ntru_hrss1373_new(void); -OQS_API OQS_STATUS OQS_KEM_ntru_hrss1373_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_ntru_hrss1373_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ntru_hrss1373_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_ntru_hrss1373_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#endif - diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/kem_ntruprime.h b/prebuilt_liboqs/linux-aarch64/include/oqs/kem_ntruprime.h deleted file mode 100644 index fbb5e61..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/kem_ntruprime.h +++ /dev/null @@ -1,24 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_KEM_NTRUPRIME_H -#define OQS_KEM_NTRUPRIME_H - -#include - -#ifdef OQS_ENABLE_KEM_ntruprime_sntrup761 -#define OQS_KEM_ntruprime_sntrup761_length_public_key 1158 -#define OQS_KEM_ntruprime_sntrup761_length_secret_key 1763 -#define OQS_KEM_ntruprime_sntrup761_length_ciphertext 1039 -#define OQS_KEM_ntruprime_sntrup761_length_shared_secret 32 -#define OQS_KEM_ntruprime_sntrup761_length_keypair_seed 0 -#define OQS_KEM_ntruprime_sntrup761_length_encaps_seed 0 -OQS_KEM *OQS_KEM_ntruprime_sntrup761_new(void); -OQS_API OQS_STATUS OQS_KEM_ntruprime_sntrup761_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_ntruprime_sntrup761_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ntruprime_sntrup761_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_ntruprime_sntrup761_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ntruprime_sntrup761_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#endif - diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/oqs.h b/prebuilt_liboqs/linux-aarch64/include/oqs/oqs.h deleted file mode 100644 index d6833bc..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/oqs.h +++ /dev/null @@ -1,26 +0,0 @@ -/** - * \file oqs.h - * \brief Overall header file for the liboqs public API. - * - * C programs using liboqs can include just this one file, and it will include all - * other necessary headers from liboqs. - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_H -#define OQS_H - -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#endif // OQS_H diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/oqsconfig.h b/prebuilt_liboqs/linux-aarch64/include/oqs/oqsconfig.h deleted file mode 100644 index 1a4e16f..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/oqsconfig.h +++ /dev/null @@ -1,569 +0,0 @@ -// SPDX-License-Identifier: MIT - -/** - * Version of liboqs as a string. Equivalent to {MAJOR}.{MINOR}.{PATCH}{PRE_RELEASE} - */ -#define OQS_VERSION_TEXT "0.15.0-rc1" -/** - * Version levels of liboqs as integers. - */ -#define OQS_VERSION_MAJOR 0 -#define OQS_VERSION_MINOR 15 -#define OQS_VERSION_PATCH 0 -/** - * OQS_VERSION_PRE_RELEASE is defined if this is a pre-release version of liboqs, otherwise it is undefined. - * Examples: "-dev" or "-rc1". - */ -#define OQS_VERSION_PRE_RELEASE "-rc1" - -#define OQS_COMPILE_BUILD_TARGET "aarch64-Linux-6.8.0-86-generic" -/* #undef OQS_DIST_BUILD */ -/* #undef OQS_DIST_X86_64_BUILD */ -/* #undef OQS_DIST_X86_BUILD */ -/* #undef OQS_DIST_ARM64_V8_BUILD */ -/* #undef OQS_DIST_ARM32_V7_BUILD */ -/* #undef OQS_DIST_PPC64LE_BUILD */ -/* #undef OQS_DEBUG_BUILD */ -/* #undef ARCH_X86_64 */ -#define ARCH_ARM64v8 1 -/* #undef ARCH_ARM32v7 */ -#define BUILD_SHARED_LIBS 1 -/* #undef OQS_BUILD_ONLY_LIB */ -#define OQS_OPT_TARGET "auto" -/* #undef USE_COVERAGE */ -/* #undef USE_SANITIZER */ -#define CMAKE_BUILD_TYPE "Release" - -/* #undef OQS_USE_OPENSSL */ -/* #undef OQS_USE_AES_OPENSSL */ -/* #undef OQS_USE_SHA2_OPENSSL */ -/* #undef OQS_USE_SHA3_OPENSSL */ -/* #undef OQS_DLOPEN_OPENSSL */ -/* #undef OQS_OPENSSL_CRYPTO_SONAME */ - -/* #undef OQS_EMBEDDED_BUILD */ - -#define OQS_USE_PTHREADS 1 - -/* #undef OQS_USE_ADX_INSTRUCTIONS */ -/* #undef OQS_USE_AES_INSTRUCTIONS */ -/* #undef OQS_USE_AVX_INSTRUCTIONS */ -/* #undef OQS_USE_AVX2_INSTRUCTIONS */ -/* #undef OQS_USE_AVX512_INSTRUCTIONS */ -/* #undef OQS_USE_BMI1_INSTRUCTIONS */ -/* #undef OQS_USE_BMI2_INSTRUCTIONS */ -/* #undef OQS_USE_PCLMULQDQ_INSTRUCTIONS */ -/* #undef OQS_USE_VPCLMULQDQ_INSTRUCTIONS */ -/* #undef OQS_USE_POPCNT_INSTRUCTIONS */ -/* #undef OQS_USE_SSE_INSTRUCTIONS */ -/* #undef OQS_USE_SSE2_INSTRUCTIONS */ -/* #undef OQS_USE_SSE3_INSTRUCTIONS */ - -/* #undef OQS_USE_ARM_AES_INSTRUCTIONS */ -/* #undef OQS_USE_ARM_SHA2_INSTRUCTIONS */ -/* #undef OQS_USE_ARM_SHA3_INSTRUCTIONS */ -#define OQS_USE_ARM_NEON_INSTRUCTIONS 1 - -/* #undef OQS_SPEED_USE_ARM_PMU */ - -/* #undef OQS_ENABLE_TEST_CONSTANT_TIME */ - -/* #undef OQS_ENABLE_SHA3_xkcp_low_avx2 */ -/* #undef OQS_USE_SHA3_AVX512VL */ - -#define OQS_USE_CUPQC 0 -#define OQS_USE_ICICLE 0 - -#define OQS_ENABLE_KEM_BIKE 1 -#define OQS_ENABLE_KEM_bike_l1 1 -#define OQS_ENABLE_KEM_bike_l3 1 -#define OQS_ENABLE_KEM_bike_l5 1 - -#define OQS_ENABLE_KEM_FRODOKEM 1 -#define OQS_ENABLE_KEM_frodokem_640_aes 1 -#define OQS_ENABLE_KEM_frodokem_640_shake 1 -#define OQS_ENABLE_KEM_frodokem_976_aes 1 -#define OQS_ENABLE_KEM_frodokem_976_shake 1 -#define OQS_ENABLE_KEM_frodokem_1344_aes 1 -#define OQS_ENABLE_KEM_frodokem_1344_shake 1 - -#define OQS_ENABLE_KEM_NTRUPRIME 1 -#define OQS_ENABLE_KEM_ntruprime_sntrup761 1 -/* #undef OQS_ENABLE_KEM_ntruprime_sntrup761_avx2 */ - -#define OQS_ENABLE_KEM_NTRU 1 -#define OQS_ENABLE_KEM_ntru_hps2048509 1 -/* #undef OQS_ENABLE_KEM_ntru_hps2048509_avx2 */ -#define OQS_ENABLE_KEM_ntru_hps2048677 1 -/* #undef OQS_ENABLE_KEM_ntru_hps2048677_avx2 */ -#define OQS_ENABLE_KEM_ntru_hps4096821 1 -/* #undef OQS_ENABLE_KEM_ntru_hps4096821_avx2 */ -#define OQS_ENABLE_KEM_ntru_hps40961229 1 -#define OQS_ENABLE_KEM_ntru_hrss701 1 -/* #undef OQS_ENABLE_KEM_ntru_hrss701_avx2 */ -#define OQS_ENABLE_KEM_ntru_hrss1373 1 - -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_ADD_ALG_ENABLE_DEFINES_START - -#define OQS_ENABLE_KEM_CLASSIC_MCELIECE 1 -#define OQS_ENABLE_KEM_classic_mceliece_348864 1 -/* #undef OQS_ENABLE_KEM_classic_mceliece_348864_avx2 */ -#define OQS_ENABLE_KEM_classic_mceliece_348864f 1 -/* #undef OQS_ENABLE_KEM_classic_mceliece_348864f_avx2 */ -#define OQS_ENABLE_KEM_classic_mceliece_460896 1 -/* #undef OQS_ENABLE_KEM_classic_mceliece_460896_avx2 */ -#define OQS_ENABLE_KEM_classic_mceliece_460896f 1 -/* #undef OQS_ENABLE_KEM_classic_mceliece_460896f_avx2 */ -#define OQS_ENABLE_KEM_classic_mceliece_6688128 1 -/* #undef OQS_ENABLE_KEM_classic_mceliece_6688128_avx2 */ -#define OQS_ENABLE_KEM_classic_mceliece_6688128f 1 -/* #undef OQS_ENABLE_KEM_classic_mceliece_6688128f_avx2 */ -#define OQS_ENABLE_KEM_classic_mceliece_6960119 1 -/* #undef OQS_ENABLE_KEM_classic_mceliece_6960119_avx2 */ -#define OQS_ENABLE_KEM_classic_mceliece_6960119f 1 -/* #undef OQS_ENABLE_KEM_classic_mceliece_6960119f_avx2 */ -#define OQS_ENABLE_KEM_classic_mceliece_8192128 1 -/* #undef OQS_ENABLE_KEM_classic_mceliece_8192128_avx2 */ -#define OQS_ENABLE_KEM_classic_mceliece_8192128f 1 -/* #undef OQS_ENABLE_KEM_classic_mceliece_8192128f_avx2 */ - -/* #undef OQS_ENABLE_KEM_HQC */ -/* #undef OQS_ENABLE_KEM_hqc_128 */ -/* #undef OQS_ENABLE_KEM_hqc_192 */ -/* #undef OQS_ENABLE_KEM_hqc_256 */ - -#define OQS_ENABLE_KEM_KYBER 1 -#define OQS_ENABLE_KEM_kyber_512 1 -/* #undef OQS_ENABLE_KEM_kyber_512_avx2 */ -#define OQS_ENABLE_KEM_kyber_512_aarch64 1 -#define OQS_ENABLE_KEM_kyber_768 1 -/* #undef OQS_ENABLE_KEM_kyber_768_avx2 */ -#define OQS_ENABLE_KEM_kyber_768_aarch64 1 -#define OQS_ENABLE_KEM_kyber_1024 1 -/* #undef OQS_ENABLE_KEM_kyber_1024_avx2 */ -#define OQS_ENABLE_KEM_kyber_1024_aarch64 1 - -#define OQS_ENABLE_KEM_ML_KEM 1 -#define OQS_ENABLE_KEM_ml_kem_512 1 -/* #undef OQS_ENABLE_KEM_ml_kem_512_x86_64 */ -#define OQS_ENABLE_KEM_ml_kem_512_aarch64 1 -/* #undef OQS_ENABLE_KEM_ml_kem_512_cuda */ -/* #undef OQS_ENABLE_KEM_ml_kem_512_icicle_cuda */ -#define OQS_ENABLE_KEM_ml_kem_768 1 -/* #undef OQS_ENABLE_KEM_ml_kem_768_x86_64 */ -#define OQS_ENABLE_KEM_ml_kem_768_aarch64 1 -/* #undef OQS_ENABLE_KEM_ml_kem_768_cuda */ -/* #undef OQS_ENABLE_KEM_ml_kem_768_icicle_cuda */ -#define OQS_ENABLE_KEM_ml_kem_1024 1 -/* #undef OQS_ENABLE_KEM_ml_kem_1024_x86_64 */ -#define OQS_ENABLE_KEM_ml_kem_1024_aarch64 1 -/* #undef OQS_ENABLE_KEM_ml_kem_1024_cuda */ -/* #undef OQS_ENABLE_KEM_ml_kem_1024_icicle_cuda */ - -#define OQS_ENABLE_SIG_ML_DSA 1 -#define OQS_ENABLE_SIG_ml_dsa_44 1 -/* #undef OQS_ENABLE_SIG_ml_dsa_44_avx2 */ -#define OQS_ENABLE_SIG_ml_dsa_65 1 -/* #undef OQS_ENABLE_SIG_ml_dsa_65_avx2 */ -#define OQS_ENABLE_SIG_ml_dsa_87 1 -/* #undef OQS_ENABLE_SIG_ml_dsa_87_avx2 */ - -#define OQS_ENABLE_SIG_FALCON 1 -#define OQS_ENABLE_SIG_falcon_512 1 -/* #undef OQS_ENABLE_SIG_falcon_512_avx2 */ -#define OQS_ENABLE_SIG_falcon_512_aarch64 1 -#define OQS_ENABLE_SIG_falcon_1024 1 -/* #undef OQS_ENABLE_SIG_falcon_1024_avx2 */ -#define OQS_ENABLE_SIG_falcon_1024_aarch64 1 -#define OQS_ENABLE_SIG_falcon_padded_512 1 -/* #undef OQS_ENABLE_SIG_falcon_padded_512_avx2 */ -#define OQS_ENABLE_SIG_falcon_padded_512_aarch64 1 -#define OQS_ENABLE_SIG_falcon_padded_1024 1 -/* #undef OQS_ENABLE_SIG_falcon_padded_1024_avx2 */ -#define OQS_ENABLE_SIG_falcon_padded_1024_aarch64 1 - -#define OQS_ENABLE_SIG_SPHINCS 1 -#define OQS_ENABLE_SIG_sphincs_sha2_128f_simple 1 -/* #undef OQS_ENABLE_SIG_sphincs_sha2_128f_simple_avx2 */ -#define OQS_ENABLE_SIG_sphincs_sha2_128s_simple 1 -/* #undef OQS_ENABLE_SIG_sphincs_sha2_128s_simple_avx2 */ -#define OQS_ENABLE_SIG_sphincs_sha2_192f_simple 1 -/* #undef OQS_ENABLE_SIG_sphincs_sha2_192f_simple_avx2 */ -#define OQS_ENABLE_SIG_sphincs_sha2_192s_simple 1 -/* #undef OQS_ENABLE_SIG_sphincs_sha2_192s_simple_avx2 */ -#define OQS_ENABLE_SIG_sphincs_sha2_256f_simple 1 -/* #undef OQS_ENABLE_SIG_sphincs_sha2_256f_simple_avx2 */ -#define OQS_ENABLE_SIG_sphincs_sha2_256s_simple 1 -/* #undef OQS_ENABLE_SIG_sphincs_sha2_256s_simple_avx2 */ -#define OQS_ENABLE_SIG_sphincs_shake_128f_simple 1 -/* #undef OQS_ENABLE_SIG_sphincs_shake_128f_simple_avx2 */ -#define OQS_ENABLE_SIG_sphincs_shake_128s_simple 1 -/* #undef OQS_ENABLE_SIG_sphincs_shake_128s_simple_avx2 */ -#define OQS_ENABLE_SIG_sphincs_shake_192f_simple 1 -/* #undef OQS_ENABLE_SIG_sphincs_shake_192f_simple_avx2 */ -#define OQS_ENABLE_SIG_sphincs_shake_192s_simple 1 -/* #undef OQS_ENABLE_SIG_sphincs_shake_192s_simple_avx2 */ -#define OQS_ENABLE_SIG_sphincs_shake_256f_simple 1 -/* #undef OQS_ENABLE_SIG_sphincs_shake_256f_simple_avx2 */ -#define OQS_ENABLE_SIG_sphincs_shake_256s_simple 1 -/* #undef OQS_ENABLE_SIG_sphincs_shake_256s_simple_avx2 */ - -#define OQS_ENABLE_SIG_MAYO 1 -#define OQS_ENABLE_SIG_mayo_1 1 -/* #undef OQS_ENABLE_SIG_mayo_1_avx2 */ -#define OQS_ENABLE_SIG_mayo_1_neon 1 -#define OQS_ENABLE_SIG_mayo_2 1 -/* #undef OQS_ENABLE_SIG_mayo_2_avx2 */ -#define OQS_ENABLE_SIG_mayo_2_neon 1 -#define OQS_ENABLE_SIG_mayo_3 1 -/* #undef OQS_ENABLE_SIG_mayo_3_avx2 */ -#define OQS_ENABLE_SIG_mayo_3_neon 1 -#define OQS_ENABLE_SIG_mayo_5 1 -/* #undef OQS_ENABLE_SIG_mayo_5_avx2 */ -#define OQS_ENABLE_SIG_mayo_5_neon 1 - -#define OQS_ENABLE_SIG_CROSS 1 -#define OQS_ENABLE_SIG_cross_rsdp_128_balanced 1 -/* #undef OQS_ENABLE_SIG_cross_rsdp_128_balanced_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdp_128_fast 1 -/* #undef OQS_ENABLE_SIG_cross_rsdp_128_fast_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdp_128_small 1 -/* #undef OQS_ENABLE_SIG_cross_rsdp_128_small_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdp_192_balanced 1 -/* #undef OQS_ENABLE_SIG_cross_rsdp_192_balanced_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdp_192_fast 1 -/* #undef OQS_ENABLE_SIG_cross_rsdp_192_fast_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdp_192_small 1 -/* #undef OQS_ENABLE_SIG_cross_rsdp_192_small_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdp_256_balanced 1 -/* #undef OQS_ENABLE_SIG_cross_rsdp_256_balanced_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdp_256_fast 1 -/* #undef OQS_ENABLE_SIG_cross_rsdp_256_fast_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdp_256_small 1 -/* #undef OQS_ENABLE_SIG_cross_rsdp_256_small_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdpg_128_balanced 1 -/* #undef OQS_ENABLE_SIG_cross_rsdpg_128_balanced_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdpg_128_fast 1 -/* #undef OQS_ENABLE_SIG_cross_rsdpg_128_fast_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdpg_128_small 1 -/* #undef OQS_ENABLE_SIG_cross_rsdpg_128_small_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdpg_192_balanced 1 -/* #undef OQS_ENABLE_SIG_cross_rsdpg_192_balanced_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdpg_192_fast 1 -/* #undef OQS_ENABLE_SIG_cross_rsdpg_192_fast_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdpg_192_small 1 -/* #undef OQS_ENABLE_SIG_cross_rsdpg_192_small_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdpg_256_balanced 1 -/* #undef OQS_ENABLE_SIG_cross_rsdpg_256_balanced_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdpg_256_fast 1 -/* #undef OQS_ENABLE_SIG_cross_rsdpg_256_fast_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdpg_256_small 1 -/* #undef OQS_ENABLE_SIG_cross_rsdpg_256_small_avx2 */ - -#define OQS_ENABLE_SIG_UOV 1 -#define OQS_ENABLE_SIG_uov_ov_Is 1 -#define OQS_ENABLE_SIG_uov_ov_Is_neon 1 -/* #undef OQS_ENABLE_SIG_uov_ov_Is_avx2 */ -#define OQS_ENABLE_SIG_uov_ov_Ip 1 -#define OQS_ENABLE_SIG_uov_ov_Ip_neon 1 -/* #undef OQS_ENABLE_SIG_uov_ov_Ip_avx2 */ -#define OQS_ENABLE_SIG_uov_ov_III 1 -#define OQS_ENABLE_SIG_uov_ov_III_neon 1 -/* #undef OQS_ENABLE_SIG_uov_ov_III_avx2 */ -#define OQS_ENABLE_SIG_uov_ov_V 1 -#define OQS_ENABLE_SIG_uov_ov_V_neon 1 -/* #undef OQS_ENABLE_SIG_uov_ov_V_avx2 */ -#define OQS_ENABLE_SIG_uov_ov_Is_pkc 1 -#define OQS_ENABLE_SIG_uov_ov_Is_pkc_neon 1 -/* #undef OQS_ENABLE_SIG_uov_ov_Is_pkc_avx2 */ -#define OQS_ENABLE_SIG_uov_ov_Ip_pkc 1 -#define OQS_ENABLE_SIG_uov_ov_Ip_pkc_neon 1 -/* #undef OQS_ENABLE_SIG_uov_ov_Ip_pkc_avx2 */ -#define OQS_ENABLE_SIG_uov_ov_III_pkc 1 -#define OQS_ENABLE_SIG_uov_ov_III_pkc_neon 1 -/* #undef OQS_ENABLE_SIG_uov_ov_III_pkc_avx2 */ -#define OQS_ENABLE_SIG_uov_ov_V_pkc 1 -#define OQS_ENABLE_SIG_uov_ov_V_pkc_neon 1 -/* #undef OQS_ENABLE_SIG_uov_ov_V_pkc_avx2 */ -#define OQS_ENABLE_SIG_uov_ov_Is_pkc_skc 1 -#define OQS_ENABLE_SIG_uov_ov_Is_pkc_skc_neon 1 -/* #undef OQS_ENABLE_SIG_uov_ov_Is_pkc_skc_avx2 */ -#define OQS_ENABLE_SIG_uov_ov_Ip_pkc_skc 1 -#define OQS_ENABLE_SIG_uov_ov_Ip_pkc_skc_neon 1 -/* #undef OQS_ENABLE_SIG_uov_ov_Ip_pkc_skc_avx2 */ -#define OQS_ENABLE_SIG_uov_ov_III_pkc_skc 1 -#define OQS_ENABLE_SIG_uov_ov_III_pkc_skc_neon 1 -/* #undef OQS_ENABLE_SIG_uov_ov_III_pkc_skc_avx2 */ -#define OQS_ENABLE_SIG_uov_ov_V_pkc_skc 1 -#define OQS_ENABLE_SIG_uov_ov_V_pkc_skc_neon 1 -/* #undef OQS_ENABLE_SIG_uov_ov_V_pkc_skc_avx2 */ - -#define OQS_ENABLE_SIG_SNOVA 1 -#define OQS_ENABLE_SIG_snova_SNOVA_24_5_4 1 -/* #undef OQS_ENABLE_SIG_snova_SNOVA_24_5_4_avx2 */ -#define OQS_ENABLE_SIG_snova_SNOVA_24_5_4_neon 1 -#define OQS_ENABLE_SIG_snova_SNOVA_24_5_4_SHAKE 1 -/* #undef OQS_ENABLE_SIG_snova_SNOVA_24_5_4_SHAKE_avx2 */ -#define OQS_ENABLE_SIG_snova_SNOVA_24_5_4_SHAKE_neon 1 -#define OQS_ENABLE_SIG_snova_SNOVA_24_5_4_esk 1 -/* #undef OQS_ENABLE_SIG_snova_SNOVA_24_5_4_esk_avx2 */ -#define OQS_ENABLE_SIG_snova_SNOVA_24_5_4_esk_neon 1 -#define OQS_ENABLE_SIG_snova_SNOVA_24_5_4_SHAKE_esk 1 -/* #undef OQS_ENABLE_SIG_snova_SNOVA_24_5_4_SHAKE_esk_avx2 */ -#define OQS_ENABLE_SIG_snova_SNOVA_24_5_4_SHAKE_esk_neon 1 -#define OQS_ENABLE_SIG_snova_SNOVA_37_17_2 1 -/* #undef OQS_ENABLE_SIG_snova_SNOVA_37_17_2_avx2 */ -#define OQS_ENABLE_SIG_snova_SNOVA_37_17_2_neon 1 -#define OQS_ENABLE_SIG_snova_SNOVA_25_8_3 1 -/* #undef OQS_ENABLE_SIG_snova_SNOVA_25_8_3_avx2 */ -#define OQS_ENABLE_SIG_snova_SNOVA_25_8_3_neon 1 -#define OQS_ENABLE_SIG_snova_SNOVA_56_25_2 1 -/* #undef OQS_ENABLE_SIG_snova_SNOVA_56_25_2_avx2 */ -#define OQS_ENABLE_SIG_snova_SNOVA_56_25_2_neon 1 -#define OQS_ENABLE_SIG_snova_SNOVA_49_11_3 1 -/* #undef OQS_ENABLE_SIG_snova_SNOVA_49_11_3_avx2 */ -#define OQS_ENABLE_SIG_snova_SNOVA_49_11_3_neon 1 -#define OQS_ENABLE_SIG_snova_SNOVA_37_8_4 1 -/* #undef OQS_ENABLE_SIG_snova_SNOVA_37_8_4_avx2 */ -#define OQS_ENABLE_SIG_snova_SNOVA_37_8_4_neon 1 -#define OQS_ENABLE_SIG_snova_SNOVA_24_5_5 1 -/* #undef OQS_ENABLE_SIG_snova_SNOVA_24_5_5_avx2 */ -#define OQS_ENABLE_SIG_snova_SNOVA_24_5_5_neon 1 -#define OQS_ENABLE_SIG_snova_SNOVA_60_10_4 1 -/* #undef OQS_ENABLE_SIG_snova_SNOVA_60_10_4_avx2 */ -#define OQS_ENABLE_SIG_snova_SNOVA_60_10_4_neon 1 -#define OQS_ENABLE_SIG_snova_SNOVA_29_6_5 1 -/* #undef OQS_ENABLE_SIG_snova_SNOVA_29_6_5_avx2 */ -#define OQS_ENABLE_SIG_snova_SNOVA_29_6_5_neon 1 -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_ADD_ALG_ENABLE_DEFINES_END -///// OQS_COPY_FROM_SLH_DSA_FRAGMENT_ADD_ALG_ENABLE_DEFINES_START -#define OQS_ENABLE_SIG_SLH_DSA 1 -#define OQS_ENABLE_SIG_slh_dsa_pure_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_pure_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_pure_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_pure_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_pure_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_pure_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_pure_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_pure_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_pure_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_pure_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_pure_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_pure_shake_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_256f 1 -///// OQS_COPY_FROM_SLH_DSA_FRAGMENT_ADD_ALG_ENABLE_DEFINES_END - -///// OQS_COPY_FROM_LIBJADE_FRAGMENT_ADD_ALG_ENABLE_DEFINES_START - -#define OQS_LIBJADE_BUILD 0 - -/* #undef OQS_ENABLE_LIBJADE_KEM_KYBER */ -/* #undef OQS_ENABLE_LIBJADE_KEM_kyber_512 */ -/* #undef OQS_ENABLE_LIBJADE_KEM_kyber_512_avx2 */ -/* #undef OQS_ENABLE_LIBJADE_KEM_kyber_768 */ -/* #undef OQS_ENABLE_LIBJADE_KEM_kyber_768_avx2 */ -///// OQS_COPY_FROM_LIBJADE_FRAGMENT_ADD_ALG_ENABLE_DEFINES_END - -/* #undef OQS_ENABLE_SIG_STFL_XMSS */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_sha256_h10 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_sha256_h16 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_sha256_h20 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_shake128_h10 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_shake128_h16 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_shake128_h20 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_sha512_h10 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_sha512_h16 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_sha512_h20 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_shake256_h10 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_shake256_h16 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_shake256_h20 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_sha256_h10_192 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_sha256_h16_192 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_sha256_h20_192 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_shake256_h10_192 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_shake256_h16_192 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_shake256_h20_192 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_shake256_h10_256 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_shake256_h16_256 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_shake256_h20_256 */ - -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_sha256_h20_2 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_sha256_h20_4 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_sha256_h40_2 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_sha256_h40_4 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_sha256_h40_8 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_sha256_h60_3 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_sha256_h60_6 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_sha256_h60_12 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_shake128_h20_2 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_shake128_h20_4 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_shake128_h40_2 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_shake128_h40_4 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_shake128_h40_8 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_shake128_h60_3 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_shake128_h60_6 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_shake128_h60_12 */ - - -/* #undef OQS_ENABLE_SIG_STFL_LMS */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h5_w1 */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h5_w2 */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h5_w4 */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h5_w8 */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h10_w1 */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h10_w2 */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h10_w4 */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h10_w8 */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h15_w1 */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h15_w2 */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h15_w4 */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h5_w8_h5_w8 */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h10_w4_h5_w8 */ - -/* #undef OQS_HAZARDOUS_EXPERIMENTAL_ENABLE_SIG_STFL_KEY_SIG_GEN */ -/* #undef OQS_ALLOW_STFL_KEY_AND_SIG_GEN */ -/* #undef OQS_ALLOW_XMSS_KEY_AND_SIG_GEN */ -/* #undef OQS_ALLOW_LMS_KEY_AND_SIG_GEN */ diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/rand.h b/prebuilt_liboqs/linux-aarch64/include/oqs/rand.h deleted file mode 100644 index 962ce6c..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/rand.h +++ /dev/null @@ -1,66 +0,0 @@ -/** - * \file rand.h - * \brief Random number generator. - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_RANDOM_H -#define OQS_RANDOM_H - -#include -#include -#include - -#include - -#if defined(__cplusplus) -extern "C" { -#endif - -/** Algorithm identifier for system PRNG. */ -#define OQS_RAND_alg_system "system" -/** Algorithm identifier for using OpenSSL's PRNG. */ -#define OQS_RAND_alg_openssl "OpenSSL" - -/** - * Switches OQS_randombytes to use the specified algorithm. - * - * @warning In case you have set a custom algorithm using `OQS_randombytes_custom_algorithm` - * before, this function will overwrite it again. Hence, you have to set your custom - * algorithm again after calling this function. - * - * @param[in] algorithm The name of the algorithm to use. - * @return OQS_SUCCESS if `algorithm` is a supported algorithm name, OQS_ERROR otherwise. - */ -OQS_API OQS_STATUS OQS_randombytes_switch_algorithm(const char *algorithm); - -/** - * Switches OQS_randombytes to use the given function. - * - * This allows additional custom RNGs besides the provided ones. The provided RNG - * function must have the same signature as `OQS_randombytes`. - * - * @param[in] algorithm_ptr Pointer to the RNG function to use. - */ -OQS_API void OQS_randombytes_custom_algorithm(void (*algorithm_ptr)(uint8_t *, size_t)); - -/** - * Fills the given memory with the requested number of (pseudo)random bytes. - * - * This implementation uses whichever algorithm has been selected by - * OQS_randombytes_switch_algorithm. The default is OQS_randombytes_system, which - * reads bytes from a system specific default source. - * - * The caller is responsible for providing a buffer allocated with sufficient room. - * - * @param[out] random_array Pointer to the memory to fill with (pseudo)random bytes - * @param[in] bytes_to_read The number of random bytes to read into memory - */ -OQS_API void OQS_randombytes(uint8_t *random_array, size_t bytes_to_read); - -#if defined(__cplusplus) -} // extern "C" -#endif - -#endif // OQS_RANDOM_H diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/rand_nist.h b/prebuilt_liboqs/linux-aarch64/include/oqs/rand_nist.h deleted file mode 100644 index d124773..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/rand_nist.h +++ /dev/null @@ -1,47 +0,0 @@ -/** - * \file rand_nist.h - * \brief NIST DRBG - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_RAND_NIST_H -#define OQS_RAND_NIST_H - -#include -#include - -typedef struct { - unsigned char Key[32]; - unsigned char V[16]; - int reseed_counter; -} OQS_NIST_DRBG_struct; - -/** - * Initializes the NIST DRBG with a given seed and with 256-bit security. - * - * @param[in] entropy_input The seed; must be exactly 48 bytes - * @param[in] personalization_string An optional personalization string; - * may be NULL; if not NULL, must be at least 48 bytes long - */ -void OQS_randombytes_nist_kat_init_256bit(const uint8_t *entropy_input, const uint8_t *personalization_string); - -/** - * Fills the given memory with the requested number of pseudorandom bytes using the NIST DRBG. - * - * @param[out] random_array Pointer to the memory to fill with (pseudo)random bytes - * @param[in] bytes_to_read The number of random bytes to read into memory - */ -void OQS_randombytes_nist_kat(uint8_t *random_array, size_t bytes_to_read); - -/** - * Writes the current state of the NIST DRBG into the provided memory. - */ -void OQS_randombytes_nist_kat_get_state(void *out); - -/** - * Overwrites the current state of the NIST DRBG from the provided memory. - */ -void OQS_randombytes_nist_kat_set_state(const void *in); - -#endif // OQS_RAND_NIST_H diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/sha2.h b/prebuilt_liboqs/linux-aarch64/include/oqs/sha2.h deleted file mode 100644 index e7aaf54..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/sha2.h +++ /dev/null @@ -1,246 +0,0 @@ -/** - * \file sha2.h - * \brief SHA2 functions; not part of the OQS public API - * - * Contains the API and documentation for SHA2 digest implementation - * - * Note this is not part of the OQS public API: implementations within liboqs can use these - * functions, but external consumers of liboqs should not use these functions. - * - * \author Douglas Stebila - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_SHA2_H -#define OQS_SHA2_H - -#include -#include - -#include - -#if defined(__cplusplus) -extern "C" { -#endif - -/** - * \brief Process a message with SHA-256 and return the hash code in the output byte array. - * - * \warning The output array must be at least 32 bytes in length. - * - * \param output The output byte array - * \param input The message input byte array - * \param inplen The number of message bytes to process - */ -void OQS_SHA2_sha256(uint8_t *output, const uint8_t *input, size_t inplen); - -/** - * \brief Allocate and initialize the state for the SHA-256 incremental hashing API. - * - * \warning The state must be released by OQS_SHA2_sha256_inc_finalize - * or OQS_SHA2_sha256_inc_ctx_release. - * - * \param state Pointer to the state - */ -void OQS_SHA2_sha256_inc_init(OQS_SHA2_sha256_ctx *state); - -/** - * \brief Duplicate state for the SHA-256 incremental hashing API. - * - * \warning dest must be allocated by the caller. Caller is responsible - * for releasing dest by calling either OQS_SHA2_sha256_inc_finalize or - * OQS_SHA2_sha256_inc_ctx_release. - * - * \param dest The function state to copy into; must be initialized - * \param src The function state to copy; must be initialized - */ -void OQS_SHA2_sha256_inc_ctx_clone(OQS_SHA2_sha256_ctx *dest, const OQS_SHA2_sha256_ctx *src); - -/** - * \brief Process blocks with SHA-256 and update the state. - * - * \warning The state must be initialized by OQS_SHA2_sha256_inc_init or OQS_SHA2_sha256_inc_ctx_clone. - * - * \param state The state to update - * \param in Message input byte array - * \param inblocks The number of 64-byte blocks of message bytes to process - */ -void OQS_SHA2_sha256_inc_blocks(OQS_SHA2_sha256_ctx *state, const uint8_t *in, size_t inblocks); - -/** - * \brief Process message bytes with SHA-256 and update the state. - * - * \warning The state must be initialized by OQS_SHA2_sha256_inc_init or OQS_SHA2_sha256_inc_ctx_clone. - * - * \param state The state to update - * \param in Message input byte array - * \param len The number of bytes of message to process - */ -void OQS_SHA2_sha256_inc(OQS_SHA2_sha256_ctx *state, const uint8_t *in, size_t len); - -/** - * \brief Process more message bytes with SHA-256 and return the hash code in the output byte array. - * - * \warning The output array must be at least 32 bytes in length. The state is - * deallocated by this function and can not be used again after calling - * this function without calling OQS_SHA2_sha256_inc_init again. - * - * \param out The output byte array - * \param state The state - * \param in Additional message input byte array - * \param inlen The number of additional message bytes to process - */ -void OQS_SHA2_sha256_inc_finalize(uint8_t *out, OQS_SHA2_sha256_ctx *state, const uint8_t *in, size_t inlen); - -/** - * \brief Destroy state. - * - * \warning The state is deallocated by this function and can not be used again after calling - * this function without calling OQS_SHA2_sha256_inc_init again. - * - * \param state The state - */ -void OQS_SHA2_sha256_inc_ctx_release(OQS_SHA2_sha256_ctx *state); - -/** - * \brief Process a message with SHA-384 and return the hash code in the output byte array. - * - * \warning The output array must be at least 48 bytes in length. - * - * \param output The output byte array - * \param input The message input byte array - * \param inplen The number of message bytes to process - */ -void OQS_SHA2_sha384(uint8_t *output, const uint8_t *input, size_t inplen); - -/** - * \brief Allocate and initialize the state for the SHA-384 incremental hashing API. - * - * \warning The state must be released by OQS_SHA2_sha384_inc_finalize - * or OQS_SHA2_sha384_inc_ctx_release. - * - * \param state Pointer to the state - */ -void OQS_SHA2_sha384_inc_init(OQS_SHA2_sha384_ctx *state); - -/** - * \brief Duplicate state for the SHA-384 incremental hashing API. - * - * \warning dest must be allocated by the caller. Caller is responsible - * for releasing dest by calling either OQS_SHA2_sha384_inc_finalize or - * OQS_SHA2_sha384_inc_ctx_release. - * - * \param dest The function state to copy into; must be initialized - * \param src The function state to copy; must be initialized - */ -void OQS_SHA2_sha384_inc_ctx_clone(OQS_SHA2_sha384_ctx *dest, const OQS_SHA2_sha384_ctx *src); - -/** - * \brief Process blocks with SHA-384 and update the state. - * - * \warning The state must be initialized by OQS_SHA2_sha384_inc_init or OQS_SHA2_sha384_inc_ctx_clone. - * - * \param state The state to update - * \param in Message input byte array - * \param inblocks The number of 128-byte blocks of message bytes to process - */ -void OQS_SHA2_sha384_inc_blocks(OQS_SHA2_sha384_ctx *state, const uint8_t *in, size_t inblocks); - -/** - * \brief Process more message bytes with SHA-384 and return the hash code in the output byte array. - * - * \warning The output array must be at least 48 bytes in length. The state is - * deallocated by this function and can not be used again after calling - * this function without calling OQS_SHA2_sha384_inc_init again. - * - * \param out The output byte array - * \param state The state - * \param in Additional message input byte array - * \param inlen The number of additional message bytes to process - */ -void OQS_SHA2_sha384_inc_finalize(uint8_t *out, OQS_SHA2_sha384_ctx *state, const uint8_t *in, size_t inlen); - -/** - * \brief Destroy state. - * - * \warning The state is deallocated by this function and can not be used again after calling - * this function without calling OQS_SHA2_sha384_inc_init again. - * - * \param state The state - */ -void OQS_SHA2_sha384_inc_ctx_release(OQS_SHA2_sha384_ctx *state); - -/** - * \brief Process a message with SHA-512 and return the hash code in the output byte array. - * - * \warning The output array must be at least 64 bytes in length. - * - * \param output The output byte array - * \param input The message input byte array - * \param inplen The number of message bytes to process - */ -void OQS_SHA2_sha512(uint8_t *output, const uint8_t *input, size_t inplen); - -/** - * \brief Allocate and initialize the state for the SHA-512 incremental hashing API. - * - * \warning The state must be released by OQS_SHA2_sha512_inc_finalize - * or OQS_SHA2_sha512_inc_ctx_release. - * - * \param state Pointer to the state - */ -void OQS_SHA2_sha512_inc_init(OQS_SHA2_sha512_ctx *state); - -/** - * \brief Duplicate state for the SHA-512 incremental hashing API. - * - * \warning dest must be allocated by the caller. Caller is responsible - * for releasing dest by calling either OQS_SHA2_sha512_inc_finalize or - * OQS_SHA2_sha512_inc_ctx_release. - * - * \param dest The function state to copy into; must be initialized - * \param src The function state to copy; must be initialized - */ -void OQS_SHA2_sha512_inc_ctx_clone(OQS_SHA2_sha512_ctx *dest, const OQS_SHA2_sha512_ctx *src); - -/** - * \brief Process blocks with SHA-512 and update the state. - * - * \warning The state must be initialized by OQS_SHA2_sha512_inc_init or OQS_SHA2_sha512_inc_ctx_clone. - * - * \param state The state to update - * \param in Message input byte array - * \param inblocks The number of 128-byte blocks of message bytes to process - */ -void OQS_SHA2_sha512_inc_blocks(OQS_SHA2_sha512_ctx *state, const uint8_t *in, size_t inblocks); - -/** - * \brief Process more message bytes with SHA-512 and return the hash code in the output byte array. - * - * \warning The output array must be at least 64 bytes in length. The state is - * deallocated by this function and can not be used again after calling - * this function without calling OQS_SHA2_sha512_inc_init again. - * - * \param out The output byte array - * \param state The state - * \param in Additional message input byte array - * \param inlen The number of additional message bytes to process - */ -void OQS_SHA2_sha512_inc_finalize(uint8_t *out, OQS_SHA2_sha512_ctx *state, const uint8_t *in, size_t inlen); - -/** - * \brief Destroy state. - * - * \warning The state is deallocated by this function and can not be used again after calling - * this function without calling OQS_SHA2_sha512_inc_init again. - * - * \param state The state - */ -void OQS_SHA2_sha512_inc_ctx_release(OQS_SHA2_sha512_ctx *state); - -#if defined(__cplusplus) -} // extern "C" -#endif - -#endif // OQS_SHA2_H diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/sha2_ops.h b/prebuilt_liboqs/linux-aarch64/include/oqs/sha2_ops.h deleted file mode 100644 index 7b8ae8c..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/sha2_ops.h +++ /dev/null @@ -1,176 +0,0 @@ -/** - * \file sha2_ops.h - * \brief Header defining the callback API for OQS SHA2 - * - * \author Douglas Stebila - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_SHA2_OPS_H -#define OQS_SHA2_OPS_H - -#include -#include - -#include - -#if defined(__cplusplus) -extern "C" { -#endif - -/** Data structure for the state of the SHA-224 incremental hashing API. */ -typedef struct { - /** Internal state */ - void *ctx; - /** current number of bytes in data */ - size_t data_len; - /** unprocessed data buffer */ - uint8_t data[128]; -} OQS_SHA2_sha224_ctx; - -/** Data structure for the state of the SHA-256 incremental hashing API. */ -typedef struct { - /** Internal state */ - void *ctx; - /** current number of bytes in data */ - size_t data_len; - /** unprocessed data buffer */ - uint8_t data[128]; -} OQS_SHA2_sha256_ctx; - -/** Data structure for the state of the SHA-384 incremental hashing API. */ -typedef struct { - /** Internal state. */ - void *ctx; - /** current number of bytes in data */ - size_t data_len; - /** unprocessed data buffer */ - uint8_t data[128]; -} OQS_SHA2_sha384_ctx; - -/** Data structure for the state of the SHA-512 incremental hashing API. */ -typedef struct { - /** Internal state. */ - void *ctx; - /** current number of bytes in data */ - size_t data_len; - /** unprocessed data buffer */ - uint8_t data[128]; -} OQS_SHA2_sha512_ctx; - -/** Data structure implemented by cryptographic provider for SHA-2 operations. - */ -struct OQS_SHA2_callbacks { - /** - * Implementation of function OQS_SHA2_sha256. - */ - void (*SHA2_sha256)(uint8_t *output, const uint8_t *input, size_t inplen); - - /** - * Implementation of function OQS_SHA2_sha256_inc_init. - */ - void (*SHA2_sha256_inc_init)(OQS_SHA2_sha256_ctx *state); - - /** - * Implementation of function OQS_SHA2_sha256_inc_ctx_clone. - */ - void (*SHA2_sha256_inc_ctx_clone)(OQS_SHA2_sha256_ctx *dest, const OQS_SHA2_sha256_ctx *src); - - /** - * Implementation of function OQS_SHA2_sha256_inc. - */ - void (*SHA2_sha256_inc)(OQS_SHA2_sha256_ctx *state, const uint8_t *in, size_t len); - - /** - * Implementation of function OQS_SHA2_sha256_inc_blocks. - */ - void (*SHA2_sha256_inc_blocks)(OQS_SHA2_sha256_ctx *state, const uint8_t *in, size_t inblocks); - - /** - * Implementation of function OQS_SHA2_sha256_inc_finalize. - */ - void (*SHA2_sha256_inc_finalize)(uint8_t *out, OQS_SHA2_sha256_ctx *state, const uint8_t *in, size_t inlen); - - /** - * Implementation of function OQS_SHA2_sha256_inc_ctx_release. - */ - void (*SHA2_sha256_inc_ctx_release)(OQS_SHA2_sha256_ctx *state); - - /** - * Implementation of function OQS_SHA2_sha384. - */ - void (*SHA2_sha384)(uint8_t *output, const uint8_t *input, size_t inplen); - - /** - * Implementation of function OQS_SHA2_sha384_inc_init. - */ - void (*SHA2_sha384_inc_init)(OQS_SHA2_sha384_ctx *state); - - /** - * Implementation of function OQS_SHA2_sha384_inc_ctx_clone. - */ - void (*SHA2_sha384_inc_ctx_clone)(OQS_SHA2_sha384_ctx *dest, const OQS_SHA2_sha384_ctx *src); - - /** - * Implementation of function OQS_SHA2_sha384_inc_blocks. - */ - void (*SHA2_sha384_inc_blocks)(OQS_SHA2_sha384_ctx *state, const uint8_t *in, size_t inblocks); - - /** - * Implementation of function OQS_SHA2_sha384_inc_finalize. - */ - void (*SHA2_sha384_inc_finalize)(uint8_t *out, OQS_SHA2_sha384_ctx *state, const uint8_t *in, size_t inlen); - - /** - * Implementation of function OQS_SHA2_sha384_inc_ctx_release. - */ - void (*SHA2_sha384_inc_ctx_release)(OQS_SHA2_sha384_ctx *state); - - /** - * Implementation of function OQS_SHA2_sha512. - */ - void (*SHA2_sha512)(uint8_t *output, const uint8_t *input, size_t inplen); - - /** - * Implementation of function OQS_SHA2_sha512_inc_init. - */ - void (*SHA2_sha512_inc_init)(OQS_SHA2_sha512_ctx *state); - - /** - * Implementation of function OQS_SHA2_sha512_inc_ctx_clone. - */ - void (*SHA2_sha512_inc_ctx_clone)(OQS_SHA2_sha512_ctx *dest, const OQS_SHA2_sha512_ctx *src); - - /** - * Implementation of function OQS_SHA2_sha512_inc_blocks. - */ - void (*SHA2_sha512_inc_blocks)(OQS_SHA2_sha512_ctx *state, const uint8_t *in, size_t inblocks); - - /** - * Implementation of function OQS_SHA2_sha512_inc_finalize. - */ - void (*SHA2_sha512_inc_finalize)(uint8_t *out, OQS_SHA2_sha512_ctx *state, const uint8_t *in, size_t inlen); - - /** - * Implementation of function OQS_SHA2_sha512_inc_ctx_release. - */ - void (*SHA2_sha512_inc_ctx_release)(OQS_SHA2_sha512_ctx *state); -}; - -/** - * Set callback functions for SHA2 operations. - * - * This function may be called before OQS_init to switch the - * cryptographic provider for SHA2 operations. If it is not called, - * the default provider determined at build time will be used. - * - * @param[in] new_callbacks Callback functions defined in OQS_SHA2_callbacks - */ -OQS_API void OQS_SHA2_set_callbacks(struct OQS_SHA2_callbacks *new_callbacks); - -#if defined(__cplusplus) -} // extern "C" -#endif - -#endif // OQS_SHA2_OPS_H diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/sha3.h b/prebuilt_liboqs/linux-aarch64/include/oqs/sha3.h deleted file mode 100644 index 7fa9c9a..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/sha3.h +++ /dev/null @@ -1,400 +0,0 @@ -/** - * \file sha3.h - * \brief SHA3 and SHAKE functions; not part of the OQS public API - * - * Contains the API and documentation for SHA3 digest and SHAKE implementations. - * - * Note this is not part of the OQS public API: implementations within liboqs can use these - * functions, but external consumers of liboqs should not use these functions. - * - * \author John Underhill, Douglas Stebila - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_SHA3_H -#define OQS_SHA3_H - -#include -#include - -#include - -#if defined(__cplusplus) -extern "C" { -#endif - -/* SHA3 */ - -/** The SHA-256 byte absorption rate */ -#define OQS_SHA3_SHA3_256_RATE 136 - -/** - * \brief Process a message with SHA3-256 and return the digest in the output byte array. - * - * \warning The output array must be at least 32 bytes in length. - * - * \param output The output byte array - * \param input The message input byte array - * \param inplen The number of message bytes to process - */ -void OQS_SHA3_sha3_256(uint8_t *output, const uint8_t *input, size_t inplen); - -/** - * \brief Initialize the state for the incremental SHA3-256 API. - * - * \warning Caller is responsible for releasing state by calling - * OQS_SHA3_sha3_256_inc_ctx_release. - * - * \param state The function state to be allocated and initialized. - */ -void OQS_SHA3_sha3_256_inc_init(OQS_SHA3_sha3_256_inc_ctx *state); - -/** - * \brief The SHA3-256 absorb function. - * Absorb an input into the state. - * - * \param state The function state; must be initialized - * \param input The input array - * \param inlen The length of the input - */ -void OQS_SHA3_sha3_256_inc_absorb(OQS_SHA3_sha3_256_inc_ctx *state, const uint8_t *input, size_t inlen); - -/** - * \brief The SHA3-256 finalize-and-squeeze function. - * Finalizes the state and squeezes a 32 byte digest. - * - * \warning Output array must be at least 32 bytes. - * State cannot be used after this without calling OQS_SHA3_sha3_256_inc_reset. - * - * \param output The output byte array - * \param state The function state; must be initialized - */ -void OQS_SHA3_sha3_256_inc_finalize(uint8_t *output, OQS_SHA3_sha3_256_inc_ctx *state); - -/** - * \brief Release the state for the SHA3-256 incremental API. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_sha3_256_inc_ctx_release(OQS_SHA3_sha3_256_inc_ctx *state); - -/** - * \brief Resets the state for the SHA3-256 incremental API. - * Alternative to freeing and reinitializing the state. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_sha3_256_inc_ctx_reset(OQS_SHA3_sha3_256_inc_ctx *state); - -/** - * \brief Clone the state for the SHA3-256 incremental API. - * - * \param dest The function state to copy into; must be initialized - * \param src The function state to copy; must be initialized - */ -void OQS_SHA3_sha3_256_inc_ctx_clone(OQS_SHA3_sha3_256_inc_ctx *dest, const OQS_SHA3_sha3_256_inc_ctx *src); - -/** The SHA-384 byte absorption rate */ -#define OQS_SHA3_SHA3_384_RATE 104 - -/** - * \brief Process a message with SHA3-384 and return the digest in the output byte array. - * - * \warning The output array must be at least 48 bytes in length. - * - * \param output The output byte array - * \param input The message input byte array - * \param inplen The number of message bytes to process - */ -void OQS_SHA3_sha3_384(uint8_t *output, const uint8_t *input, size_t inplen); - -/** - * \brief Initialize the state for the incremental SHA3-384 API. - * - * \warning Caller is responsible for releasing state by calling - * OQS_SHA3_sha3_384_inc_ctx_release. - * - * \param state The function state to be allocated and initialized. - */ -void OQS_SHA3_sha3_384_inc_init(OQS_SHA3_sha3_384_inc_ctx *state); - -/** - * \brief The SHA3-384 absorb function. - * Absorb an input into the state. - * - * \param state The function state; must be initialized - * \param input The input array - * \param inlen The length of the input - */ -void OQS_SHA3_sha3_384_inc_absorb(OQS_SHA3_sha3_384_inc_ctx *state, const uint8_t *input, size_t inlen); - -/** - * \brief The SHA3-384 finalize-and-squeeze function. - * Finalizes the state and squeezes a 48 byte digest. - * - * \warning Output array must be at least 48 bytes. - * State cannot be used after this without calling OQS_SHA3_sha3_384_inc_reset. - * - * \param output The output byte array - * \param state The function state; must be initialized - */ -void OQS_SHA3_sha3_384_inc_finalize(uint8_t *output, OQS_SHA3_sha3_384_inc_ctx *state); - -/** - * \brief Release the state for the SHA3-384 incremental API. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_sha3_384_inc_ctx_release(OQS_SHA3_sha3_384_inc_ctx *state); - -/** - * \brief Resets the state for the SHA3-384 incremental API. - * Alternative to freeing and reinitializing the state. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_sha3_384_inc_ctx_reset(OQS_SHA3_sha3_384_inc_ctx *state); - -/** - * \brief Clone the state for the SHA3-384 incremental API. - * - * \param dest The function state to copy into; must be initialized - * \param src The function state to copy; must be initialized - */ -void OQS_SHA3_sha3_384_inc_ctx_clone(OQS_SHA3_sha3_384_inc_ctx *dest, const OQS_SHA3_sha3_384_inc_ctx *src); - -/** The SHA-512 byte absorption rate */ -#define OQS_SHA3_SHA3_512_RATE 72 - -/** - * \brief Process a message with SHA3-512 and return the digest in the output byte array. - * - * \warning The output array must be at least 64 bytes in length. - * - * \param output The output byte array - * \param input The message input byte array - * \param inplen The number of message bytes to process - */ -void OQS_SHA3_sha3_512(uint8_t *output, const uint8_t *input, size_t inplen); - -/** - * \brief Initialize the state for the incremental SHA3-512 API. - * - * \warning Caller is responsible for releasing state by calling - * OQS_SHA3_sha3_512_inc_ctx_release. - * - * \param state The function state to be allocated and initialized. - */ -void OQS_SHA3_sha3_512_inc_init(OQS_SHA3_sha3_512_inc_ctx *state); - -/** - * \brief The SHA3-512 absorb function. - * Absorb an input into the state. - * - * \param state The function state; must be initialized - * \param input The input array - * \param inlen The length of the input - */ -void OQS_SHA3_sha3_512_inc_absorb(OQS_SHA3_sha3_512_inc_ctx *state, const uint8_t *input, size_t inlen); - -/** - * \brief The SHA3-512 finalize-and-squeeze function. - * Finalizes the state and squeezes a 64 byte digest. - * - * \warning Output array must be at least 64 bytes. - * State cannot be used after this without calling OQS_SHA3_sha3_512_inc_reset. - * - * \param output The output byte array - * \param state The function state; must be initialized - */ -void OQS_SHA3_sha3_512_inc_finalize(uint8_t *output, OQS_SHA3_sha3_512_inc_ctx *state); - -/** - * \brief Release the state for the SHA3-512 incremental API. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_sha3_512_inc_ctx_release(OQS_SHA3_sha3_512_inc_ctx *state); - -/** - * \brief Resets the state for the SHA3-512 incremental API. - * Alternative to freeing and reinitializing the state. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_sha3_512_inc_ctx_reset(OQS_SHA3_sha3_512_inc_ctx *state); - -/** - * \brief Clone the state for the SHA3-512 incremental API. - * - * \param dest The function state to copy into; must be initialized - * \param src The function state to copy; must be initialized - */ -void OQS_SHA3_sha3_512_inc_ctx_clone(OQS_SHA3_sha3_512_inc_ctx *dest, const OQS_SHA3_sha3_512_inc_ctx *src); - -/* SHAKE */ - -/** The SHAKE-128 byte absorption rate */ -#define OQS_SHA3_SHAKE128_RATE 168 - -/** - * \brief Seed a SHAKE-128 instance, and generate an array of pseudo-random bytes. - * - * \warning The output array length must not be zero. - * - * \param output The output byte array - * \param outlen The number of output bytes to generate - * \param input The input seed byte array - * \param inplen The number of seed bytes to process - */ -void OQS_SHA3_shake128(uint8_t *output, size_t outlen, const uint8_t *input, size_t inplen); - -/** - * \brief Initialize the state for the incremental SHAKE-128 API. - * - * \warning Caller is responsible for releasing state by calling - * OQS_SHA3_shake128_inc_ctx_release. - * - * \param state The function state to be initialized; must be allocated - */ -void OQS_SHA3_shake128_inc_init(OQS_SHA3_shake128_inc_ctx *state); - -/** - * \brief The SHAKE-128 absorb function. - * Absorb an input into the state. - * - * \warning State must be initialized. - * - * \param state The function state; must be initialized - * \param input input buffer - * \param inlen length of input buffer - */ -void OQS_SHA3_shake128_inc_absorb(OQS_SHA3_shake128_inc_ctx *state, const uint8_t *input, size_t inlen); - -/** - * \brief The SHAKE-128 finalize function. - * Prepares the state for squeezing. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_shake128_inc_finalize(OQS_SHA3_shake128_inc_ctx *state); - -/** - * \brief The SHAKE-128 squeeze function. - * Extracts to an output byte array. - * - * \param output output buffer - * \param outlen bytes of outbut buffer - * \param state The function state; must be initialized and finalized - */ -void OQS_SHA3_shake128_inc_squeeze(uint8_t *output, size_t outlen, OQS_SHA3_shake128_inc_ctx *state); - -/** - * \brief Frees the state for the incremental SHAKE-128 API. - * - * \param state The state to free - */ -void OQS_SHA3_shake128_inc_ctx_release(OQS_SHA3_shake128_inc_ctx *state); - -/** - * \brief Copies the state for the SHAKE-128 incremental API. - * - * \warning Caller is responsible for releasing dest by calling - * OQS_SHA3_shake128_inc_ctx_release. - * - * \param dest The function state to copy into; must be initialized - * \param src The function state to copy; must be initialized - */ -void OQS_SHA3_shake128_inc_ctx_clone(OQS_SHA3_shake128_inc_ctx *dest, const OQS_SHA3_shake128_inc_ctx *src); - -/** - * \brief Resets the state for the SHAKE-128 incremental API. Allows a context - * to be re-used without free and init calls. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_shake128_inc_ctx_reset(OQS_SHA3_shake128_inc_ctx *state); - -/** The SHAKE-256 byte absorption rate */ -#define OQS_SHA3_SHAKE256_RATE 136 - -/** - * \brief Seed a SHAKE-256 instance, and generate an array of pseudo-random bytes. - * - * \warning The output array length must not be zero. - * - * \param output The output byte array - * \param outlen The number of output bytes to generate - * \param input The input seed byte array - * \param inplen The number of seed bytes to process - */ -void OQS_SHA3_shake256(uint8_t *output, size_t outlen, const uint8_t *input, size_t inplen); - -/** - * \brief Initialize the state for the incremental SHAKE-256 API. - * - * \param state The function state to be initialized; must be allocated - */ -void OQS_SHA3_shake256_inc_init(OQS_SHA3_shake256_inc_ctx *state); - -/** - * \brief The SHAKE-256 absorb function. - * Absorb an input message array directly into the state. - * - * \warning State must be initialized by the caller. - * - * \param state The function state; must be initialized - * \param input input buffer - * \param inlen length of input buffer - */ -void OQS_SHA3_shake256_inc_absorb(OQS_SHA3_shake256_inc_ctx *state, const uint8_t *input, size_t inlen); - -/** - * \brief The SHAKE-256 finalize function. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_shake256_inc_finalize(OQS_SHA3_shake256_inc_ctx *state); - -/** - * \brief The SHAKE-256 squeeze function. - * Extracts to an output byte array. - * - * \param output output buffer - * \param outlen bytes of outbut buffer - * \param state The function state; must be initialized - */ -void OQS_SHA3_shake256_inc_squeeze(uint8_t *output, size_t outlen, OQS_SHA3_shake256_inc_ctx *state); - -/** - * \brief Frees the state for the incremental SHAKE-256 API. - * - * \param state The state to free - */ -void OQS_SHA3_shake256_inc_ctx_release(OQS_SHA3_shake256_inc_ctx *state); - -/** - * \brief Copies the state for the incremental SHAKE-256 API. - * - * \warning dest must be allocated. dest must be freed by calling - * OQS_SHA3_shake256_inc_ctx_release. - * - * \param dest The state to copy into; must be initialized - * \param src The state to copy from; must be initialized - */ -void OQS_SHA3_shake256_inc_ctx_clone(OQS_SHA3_shake256_inc_ctx *dest, const OQS_SHA3_shake256_inc_ctx *src); - -/** - * \brief Resets the state for the SHAKE-256 incremental API. Allows a context - * to be re-used without free and init calls. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_shake256_inc_ctx_reset(OQS_SHA3_shake256_inc_ctx *state); - -#if defined(__cplusplus) -} // extern "C" -#endif - -#endif // OQS_SHA3_H diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/sha3_ops.h b/prebuilt_liboqs/linux-aarch64/include/oqs/sha3_ops.h deleted file mode 100644 index 694fc21..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/sha3_ops.h +++ /dev/null @@ -1,256 +0,0 @@ -/** - * \file sha3_ops.h - * \brief Header defining the callback API for OQS SHA3 and SHAKE - * - * \author John Underhill, Douglas Stebila - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_SHA3_OPS_H -#define OQS_SHA3_OPS_H - -#include -#include - -#include - -#if defined(__cplusplus) -extern "C" { -#endif - -/** Data structure for the state of the incremental SHA3-256 API. */ -typedef struct { - /** Internal state. */ - void *ctx; -} OQS_SHA3_sha3_256_inc_ctx; - -/** Data structure for the state of the incremental SHA3-384 API. */ -typedef struct { - /** Internal state. */ - void *ctx; -} OQS_SHA3_sha3_384_inc_ctx; - -/** Data structure for the state of the incremental SHA3-512 API. */ -typedef struct { - /** Internal state. */ - void *ctx; -} OQS_SHA3_sha3_512_inc_ctx; - -/** Data structure for the state of the incremental SHAKE-128 API. */ -typedef struct { - /** Internal state. */ - void *ctx; -} OQS_SHA3_shake128_inc_ctx; - -/** Data structure for the state of the incremental SHAKE-256 API. */ -typedef struct { - /** Internal state. */ - void *ctx; -} OQS_SHA3_shake256_inc_ctx; - -/** Data structure implemented by cryptographic provider for SHA-3 operations. - */ -struct OQS_SHA3_callbacks { - /** - * Implementation of function OQS_SHA3_sha3_256. - */ - void (*SHA3_sha3_256)(uint8_t *output, const uint8_t *input, size_t inplen); - - /** - * Implementation of function OQS_SHA3_sha3_256_inc_init. - */ - void (*SHA3_sha3_256_inc_init)(OQS_SHA3_sha3_256_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_sha3_256_inc_absorb. - */ - void (*SHA3_sha3_256_inc_absorb)(OQS_SHA3_sha3_256_inc_ctx *state, const uint8_t *input, size_t inlen); - - /** - * Implementation of function OQS_SHA3_sha3_256_inc_finalize. - */ - void (*SHA3_sha3_256_inc_finalize)(uint8_t *output, OQS_SHA3_sha3_256_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_sha3_256_inc_ctx_release. - */ - void (*SHA3_sha3_256_inc_ctx_release)(OQS_SHA3_sha3_256_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_sha3_256_inc_ctx_reset. - */ - void (*SHA3_sha3_256_inc_ctx_reset)(OQS_SHA3_sha3_256_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_sha3_256_inc_ctx_clone. - */ - void (*SHA3_sha3_256_inc_ctx_clone)(OQS_SHA3_sha3_256_inc_ctx *dest, const OQS_SHA3_sha3_256_inc_ctx *src); - - /** - * Implementation of function OQS_SHA3_sha3_384. - */ - void (*SHA3_sha3_384)(uint8_t *output, const uint8_t *input, size_t inplen); - - /** - * Implementation of function OQS_SHA3_sha3_384_inc_init. - */ - void (*SHA3_sha3_384_inc_init)(OQS_SHA3_sha3_384_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_sha3_384_inc_absorb. - */ - void (*SHA3_sha3_384_inc_absorb)(OQS_SHA3_sha3_384_inc_ctx *state, const uint8_t *input, size_t inlen); - - /** - * Implementation of function OQS_SHA3_sha3_384_inc_finalize. - */ - void (*SHA3_sha3_384_inc_finalize)(uint8_t *output, OQS_SHA3_sha3_384_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_sha3_384_inc_ctx_release. - */ - void (*SHA3_sha3_384_inc_ctx_release)(OQS_SHA3_sha3_384_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_sha3_384_inc_ctx_reset. - */ - void (*SHA3_sha3_384_inc_ctx_reset)(OQS_SHA3_sha3_384_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_sha3_384_inc_ctx_clone. - */ - void (*SHA3_sha3_384_inc_ctx_clone)(OQS_SHA3_sha3_384_inc_ctx *dest, const OQS_SHA3_sha3_384_inc_ctx *src); - - /** - * Implementation of function OQS_SHA3_sha3_512. - */ - void (*SHA3_sha3_512)(uint8_t *output, const uint8_t *input, size_t inplen); - - /** - * Implementation of function OQS_SHA3_sha3_512_inc_init. - */ - void (*SHA3_sha3_512_inc_init)(OQS_SHA3_sha3_512_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_sha3_512_inc_absorb. - */ - void (*SHA3_sha3_512_inc_absorb)(OQS_SHA3_sha3_512_inc_ctx *state, const uint8_t *input, size_t inlen); - - /** - * Implementation of function OQS_SHA3_sha3_512_inc_finalize. - */ - void (*SHA3_sha3_512_inc_finalize)(uint8_t *output, OQS_SHA3_sha3_512_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_sha3_512_inc_ctx_release. - */ - void (*SHA3_sha3_512_inc_ctx_release)(OQS_SHA3_sha3_512_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_sha3_512_inc_ctx_reset. - */ - void (*SHA3_sha3_512_inc_ctx_reset)(OQS_SHA3_sha3_512_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_sha3_512_inc_ctx_clone. - */ - void (*SHA3_sha3_512_inc_ctx_clone)(OQS_SHA3_sha3_512_inc_ctx *dest, const OQS_SHA3_sha3_512_inc_ctx *src); - - /** - * Implementation of function OQS_SHA3_shake128. - */ - void (*SHA3_shake128)(uint8_t *output, size_t outlen, const uint8_t *input, size_t inplen); - - /** - * Implementation of function OQS_SHA3_shake128_inc_init. - */ - void (*SHA3_shake128_inc_init)(OQS_SHA3_shake128_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake128_inc_absorb. - */ - void (*SHA3_shake128_inc_absorb)(OQS_SHA3_shake128_inc_ctx *state, const uint8_t *input, size_t inlen); - - /** - * Implementation of function OQS_SHA3_shake128_inc_finalize. - */ - void (*SHA3_shake128_inc_finalize)(OQS_SHA3_shake128_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake128_inc_squeeze. - */ - void (*SHA3_shake128_inc_squeeze)(uint8_t *output, size_t outlen, OQS_SHA3_shake128_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake128_inc_ctx_release. - */ - void (*SHA3_shake128_inc_ctx_release)(OQS_SHA3_shake128_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake128_inc_ctx_clone. - */ - void (*SHA3_shake128_inc_ctx_clone)(OQS_SHA3_shake128_inc_ctx *dest, const OQS_SHA3_shake128_inc_ctx *src); - - /** - * Implementation of function OQS_SHA3_shake128_inc_ctx_reset. - */ - void (*SHA3_shake128_inc_ctx_reset)(OQS_SHA3_shake128_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake256. - */ - void (*SHA3_shake256)(uint8_t *output, size_t outlen, const uint8_t *input, size_t inplen); - - /** - * Implementation of function OQS_SHA3_shake256_inc_init. - */ - void (*SHA3_shake256_inc_init)(OQS_SHA3_shake256_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake256_inc_absorb. - */ - void (*SHA3_shake256_inc_absorb)(OQS_SHA3_shake256_inc_ctx *state, const uint8_t *input, size_t inlen); - - /** - * Implementation of function OQS_SHA3_shake256_inc_finalize. - */ - void (*SHA3_shake256_inc_finalize)(OQS_SHA3_shake256_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake256_inc_squeeze. - */ - void (*SHA3_shake256_inc_squeeze)(uint8_t *output, size_t outlen, OQS_SHA3_shake256_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake256_inc_ctx_release. - */ - void (*SHA3_shake256_inc_ctx_release)(OQS_SHA3_shake256_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake256_inc_ctx_clone. - */ - void (*SHA3_shake256_inc_ctx_clone)(OQS_SHA3_shake256_inc_ctx *dest, const OQS_SHA3_shake256_inc_ctx *src); - - /** - * Implementation of function OQS_SHA3_shake256_inc_ctx_reset. - */ - void (*SHA3_shake256_inc_ctx_reset)(OQS_SHA3_shake256_inc_ctx *state); -}; - -/** - * Set callback functions for SHA3 operations. - * - * This function may be called before OQS_init to switch the - * cryptographic provider for SHA3 operations. If it is not called, - * the default provider determined at build time will be used. - * - * @param new_callbacks Callback functions defined in OQS_SHA3_callbacks struct - */ -OQS_API void OQS_SHA3_set_callbacks(struct OQS_SHA3_callbacks *new_callbacks); - -#if defined(__cplusplus) -} // extern "C" -#endif - -#endif // OQS_SHA3_OPS_H diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/sha3x4.h b/prebuilt_liboqs/linux-aarch64/include/oqs/sha3x4.h deleted file mode 100644 index aabea5b..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/sha3x4.h +++ /dev/null @@ -1,252 +0,0 @@ -/** - * \file sha3x4.h - * \brief SHA3, SHAKE, and cSHAKE functions; not part of the OQS public API - * - * Contains the API and documentation for SHA3 digest and SHAKE implementations. - * - * Note this is not part of the OQS public API: implementations within liboqs can use these - * functions, but external consumers of liboqs should not use these functions. - * - * \author John Underhill, Douglas Stebila - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_SHA3X4_H -#define OQS_SHA3X4_H - -#include -#include - -#include - -#if defined(__cplusplus) -extern "C" { -#endif - -/** - * \brief Seed 4 parallel SHAKE-128 instances, and generate 4 arrays of pseudo-random bytes. - * - * \warning The output array length must not be zero. - * - * \param out0 The first output byte array - * \param out1 The second output byte array - * \param out2 The third output byte array - * \param out3 The fourth output byte array - * \param outlen The number of output bytes to generate in every output array - * \param in0 The first input seed byte array - * \param in1 The second input seed byte array - * \param in2 The third input seed byte array - * \param in3 The fourth input seed byte array - * \param inlen The number of seed bytes to process from every input array - */ -void OQS_SHA3_shake128_x4( - uint8_t *out0, - uint8_t *out1, - uint8_t *out2, - uint8_t *out3, - size_t outlen, - const uint8_t *in0, - const uint8_t *in1, - const uint8_t *in2, - const uint8_t *in3, - size_t inlen); - -/** - * \brief Initialize the state for four-way parallel incremental SHAKE-128 API. - * - * \param state The function state to be initialized; must be allocated - */ -void OQS_SHA3_shake128_x4_inc_init(OQS_SHA3_shake128_x4_inc_ctx *state); - -/** - * \brief Four-way parallel SHAKE-128 absorb function. - * Absorb four input messages of the same length into four parallel states. - * - * \warning State must be initialized by the caller. - * - * \param state The function state; must be initialized - * \param in0 The input to be absorbed into first instance - * \param in1 The input to be absorbed into first instance - * \param in2 The input to be absorbed into first instance - * \param in3 The input to be absorbed into first instance - * \param inlen The number of bytes to process from each input array - */ -void OQS_SHA3_shake128_x4_inc_absorb( - OQS_SHA3_shake128_x4_inc_ctx *state, - const uint8_t *in0, - const uint8_t *in1, - const uint8_t *in2, - const uint8_t *in3, - size_t inlen); - -/** - * \brief Four-way parallel SHAKE-128 finalize function. - * Prepares the states for squeezing. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_shake128_x4_inc_finalize(OQS_SHA3_shake128_x4_inc_ctx *state); - -/** - * \brief Four-way parallel SHAKE-128 squeeze function. - * Extracts from four parallel states into four output buffers - * - * \param out0 output buffer for the first instance - * \param out1 output buffer for the second instance - * \param out2 output buffer for the third instance - * \param out3 output buffer for the fourth instance - * \param outlen bytes of outbut buffer - * \param state The function state; must be initialized and finalized. - */ -void OQS_SHA3_shake128_x4_inc_squeeze( - uint8_t *out0, - uint8_t *out1, - uint8_t *out2, - uint8_t *out3, - size_t outlen, - OQS_SHA3_shake128_x4_inc_ctx *state); - -/** - * \brief Frees the state for the four-way parallel incremental SHAKE-128 API. - * - * \param state The state to free - */ -void OQS_SHA3_shake128_x4_inc_ctx_release(OQS_SHA3_shake128_x4_inc_ctx *state); - -/** - * \brief Copies the state for the four-way parallel incremental SHAKE-128 API. - * - * \param dest The state to copy into; must be initialized - * \param src The state to copy from; must be initialized - */ -void OQS_SHA3_shake128_x4_inc_ctx_clone( - OQS_SHA3_shake128_x4_inc_ctx *dest, - const OQS_SHA3_shake128_x4_inc_ctx *src); - -/** - * \brief Resets the state for the four-way parallel incremental SHAKE-128 API. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_shake128_x4_inc_ctx_reset(OQS_SHA3_shake128_x4_inc_ctx *state); - -/* SHAKE256 */ - -/** - * \brief Seed 4 parallel SHAKE-256 instances, and generate 4 arrays of pseudo-random bytes. - * - * Uses a vectorized (AVX2) implementation of SHAKE-256 if available. - * - * \warning The output array length must not be zero. - * - * \param out0 The first output byte array - * \param out1 The second output byte array - * \param out2 The third output byte array - * \param out3 The fourth output byte array - * \param outlen The number of output bytes to generate in every output array - * \param in0 The first input seed byte array - * \param in1 The second input seed byte array - * \param in2 The third input seed byte array - * \param in3 The fourth input seed byte array - * \param inlen The number of seed bytes to process from every input array - */ -void OQS_SHA3_shake256_x4( - uint8_t *out0, - uint8_t *out1, - uint8_t *out2, - uint8_t *out3, - size_t outlen, - const uint8_t *in0, - const uint8_t *in1, - const uint8_t *in2, - const uint8_t *in3, - size_t inlen); - -/** - * \brief Initialize the state for four-way parallel incremental SHAKE-256 API. - * - * \param state The function state to be initialized; must be allocated - */ -void OQS_SHA3_shake256_x4_inc_init(OQS_SHA3_shake256_x4_inc_ctx *state); - -/** - * \brief Four-way parallel SHAKE-256 absorb function. - * Absorb four input messages of the same length into four parallel states. - * - * \warning State must be initialized by the caller. - * - * \param state The function state; must be initialized - * \param in0 The input to be absorbed into first instance - * \param in1 The input to be absorbed into first instance - * \param in2 The input to be absorbed into first instance - * \param in3 The input to be absorbed into first instance - * \param inlen The number of bytes to process from each input array - */ -void OQS_SHA3_shake256_x4_inc_absorb( - OQS_SHA3_shake256_x4_inc_ctx *state, - const uint8_t *in0, - const uint8_t *in1, - const uint8_t *in2, - const uint8_t *in3, - size_t inlen); - -/** - * \brief Four-way parallel SHAKE-256 finalize function. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_shake256_x4_inc_finalize(OQS_SHA3_shake256_x4_inc_ctx *state); - -/** - * \brief Four-way parallel SHAKE-256 squeeze function. - * Extracts from four parallel states into four output buffers - * - * \param out0 output buffer for the first instance - * \param out1 output buffer for the second instance - * \param out2 output buffer for the third instance - * \param out3 output buffer for the fourth instance - * \param outlen bytes of outbut buffer - * \param state The function state; must be initialized and finalized - */ -void OQS_SHA3_shake256_x4_inc_squeeze( - uint8_t *out0, - uint8_t *out1, - uint8_t *out2, - uint8_t *out3, - size_t outlen, - OQS_SHA3_shake256_x4_inc_ctx *state); - -/** - * \brief Frees the state for the four-way parallel incremental SHAKE-256 API. - * - * \param state The state to free - */ -void OQS_SHA3_shake256_x4_inc_ctx_release(OQS_SHA3_shake256_x4_inc_ctx *state); - -/** - * \brief Copies the state for the four-way parallel incremental SHAKE-256 API. - * - * \warning dest must be allocated. dest must be freed by calling - * OQS_SHA3_shake256_inc_ctx_release. - * - * \param dest The state to copy into; must be initialized - * \param src The state to copy from; must be initialized - */ -void OQS_SHA3_shake256_x4_inc_ctx_clone( - OQS_SHA3_shake256_x4_inc_ctx *dest, - const OQS_SHA3_shake256_x4_inc_ctx *src); - -/** - * \brief Resets the state for the four-way parallel incremental SHAKE-256 API. - * Allows a context to be re-used without free and init calls. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_shake256_x4_inc_ctx_reset(OQS_SHA3_shake256_x4_inc_ctx *state); - -#if defined(__cplusplus) -} // extern "C" -#endif - -#endif // OQS_SHA3X4_H diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/sha3x4_ops.h b/prebuilt_liboqs/linux-aarch64/include/oqs/sha3x4_ops.h deleted file mode 100644 index 32e4cc3..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/sha3x4_ops.h +++ /dev/null @@ -1,182 +0,0 @@ -/** - * \file sha3x4_ops.h - * \brief Header defining the callback API for OQS SHA3 and SHAKE - * - * \author John Underhill, Douglas Stebila - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_SHA3X4_OPS_H -#define OQS_SHA3X4_OPS_H - -#include -#include - -#include - -#if defined(__cplusplus) -extern "C" { -#endif - -/** Data structure for the state of the four-way parallel incremental SHAKE-128 API. */ -typedef struct { - /** Internal state. */ - void *ctx; -} OQS_SHA3_shake128_x4_inc_ctx; - -/** Data structure for the state of the four-way parallel incremental SHAKE-256 API. */ -typedef struct { - /** Internal state. */ - void *ctx; -} OQS_SHA3_shake256_x4_inc_ctx; - -/** Data structure implemented by cryptographic provider for the - * four-way parallel incremental SHAKE-256 operations. - */ -struct OQS_SHA3_x4_callbacks { - /** - * Implementation of function OQS_SHA3_shake128_x4. - */ - void (*SHA3_shake128_x4)( - uint8_t *out0, - uint8_t *out1, - uint8_t *out2, - uint8_t *out3, - size_t outlen, - const uint8_t *in0, - const uint8_t *in1, - const uint8_t *in2, - const uint8_t *in3, - size_t inlen); - - /** - * Implementation of function OQS_SHA3_shake128_x4_inc_init. - */ - void (*SHA3_shake128_x4_inc_init)(OQS_SHA3_shake128_x4_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake128_x4_inc_absorb. - */ - void (*SHA3_shake128_x4_inc_absorb)( - OQS_SHA3_shake128_x4_inc_ctx *state, - const uint8_t *in0, - const uint8_t *in1, - const uint8_t *in2, - const uint8_t *in3, - size_t inlen); - - /** - * Implementation of function OQS_SHA3_shake128_x4_inc_finalize. - */ - void (*SHA3_shake128_x4_inc_finalize)(OQS_SHA3_shake128_x4_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake128_x4_inc_squeeze. - */ - void (*SHA3_shake128_x4_inc_squeeze)( - uint8_t *out0, - uint8_t *out1, - uint8_t *out2, - uint8_t *out3, - size_t outlen, - OQS_SHA3_shake128_x4_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake128_x4_inc_ctx_release. - */ - void (*SHA3_shake128_x4_inc_ctx_release)(OQS_SHA3_shake128_x4_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake128_x4_inc_ctx_clone. - */ - void (*SHA3_shake128_x4_inc_ctx_clone)( - OQS_SHA3_shake128_x4_inc_ctx *dest, - const OQS_SHA3_shake128_x4_inc_ctx *src); - - /** - * Implementation of function OQS_SHA3_shake128_x4_inc_ctx_reset. - */ - void (*SHA3_shake128_x4_inc_ctx_reset)(OQS_SHA3_shake128_x4_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake256_x4. - */ - void (*SHA3_shake256_x4)( - uint8_t *out0, - uint8_t *out1, - uint8_t *out2, - uint8_t *out3, - size_t outlen, - const uint8_t *in0, - const uint8_t *in1, - const uint8_t *in2, - const uint8_t *in3, - size_t inlen); - - /** - * Implementation of function OQS_SHA3_shake256_x4_inc_init. - */ - void (*SHA3_shake256_x4_inc_init)(OQS_SHA3_shake256_x4_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake256_x4_inc_absorb. - */ - void (*SHA3_shake256_x4_inc_absorb)( - OQS_SHA3_shake256_x4_inc_ctx *state, - const uint8_t *in0, - const uint8_t *in1, - const uint8_t *in2, - const uint8_t *in3, - size_t inlen); - - /** - * Implementation of function OQS_SHA3_shake256_x4_inc_finalize. - */ - void (*SHA3_shake256_x4_inc_finalize)(OQS_SHA3_shake256_x4_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake256_x4_inc_squeeze. - */ - void (*SHA3_shake256_x4_inc_squeeze)( - uint8_t *out0, - uint8_t *out1, - uint8_t *out2, - uint8_t *out3, - size_t outlen, - OQS_SHA3_shake256_x4_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake256_x4_inc_ctx_release. - */ - void (*SHA3_shake256_x4_inc_ctx_release)(OQS_SHA3_shake256_x4_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake256_x4_inc_ctx_clone. - */ - void (*SHA3_shake256_x4_inc_ctx_clone)( - OQS_SHA3_shake256_x4_inc_ctx *dest, - const OQS_SHA3_shake256_x4_inc_ctx *src); - - /** - * Implementation of function OQS_SHA3_shake256_x4_inc_ctx_reset. - */ - void (*SHA3_shake256_x4_inc_ctx_reset)(OQS_SHA3_shake256_x4_inc_ctx *state); -}; - -/** - * Set callback functions for 4-parallel SHA3 operations. - * - * This function may be called before OQS_init to switch the - * cryptographic provider for 4-parallel SHA3 operations. If it is not - * called, the default provider determined at build time will be used. - * - * @param new_callbacks Callback functions defined in OQS_SHA3_x4_callbacks struct - */ -OQS_API void OQS_SHA3_x4_set_callbacks(struct OQS_SHA3_x4_callbacks *new_callbacks); - -#if defined(__cplusplus) -} // extern "C" -#endif - -#endif // OQS_SHA3X4_OPS_H diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/sig.h b/prebuilt_liboqs/linux-aarch64/include/oqs/sig.h deleted file mode 100644 index d356e3f..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/sig.h +++ /dev/null @@ -1,770 +0,0 @@ -/** - * \file sig.h - * \brief Signature schemes - * - * The file `tests/example_sig.c` contains two examples on using the OQS_SIG API. - * - * The first example uses the individual scheme's algorithms directly and uses - * no dynamic memory allocation -- all buffers are allocated on the stack, with - * sizes indicated using preprocessor macros. Since algorithms can be disabled at - * compile-time, the programmer should wrap the code in \#ifdefs. - * - * The second example uses an OQS_SIG object to use an algorithm specified at - * runtime. Therefore it uses dynamic memory allocation -- all buffers must be - * malloc'ed by the programmer, with sizes indicated using the corresponding length - * member of the OQS_SIG object in question. Since algorithms can be disabled at - * compile-time, the programmer should check that the OQS_SIG object is not `NULL`. - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_SIG_H -#define OQS_SIG_H - -#include -#include -#include - -#include - -#if defined(__cplusplus) -extern "C" { -#endif - -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_ALG_IDENTIFIER_START -/** Algorithm identifier for ML-DSA-44 */ -#define OQS_SIG_alg_ml_dsa_44 "ML-DSA-44" -/** Algorithm identifier for ML-DSA-65 */ -#define OQS_SIG_alg_ml_dsa_65 "ML-DSA-65" -/** Algorithm identifier for ML-DSA-87 */ -#define OQS_SIG_alg_ml_dsa_87 "ML-DSA-87" -/** Algorithm identifier for Falcon-512 */ -#define OQS_SIG_alg_falcon_512 "Falcon-512" -/** Algorithm identifier for Falcon-1024 */ -#define OQS_SIG_alg_falcon_1024 "Falcon-1024" -/** Algorithm identifier for Falcon-padded-512 */ -#define OQS_SIG_alg_falcon_padded_512 "Falcon-padded-512" -/** Algorithm identifier for Falcon-padded-1024 */ -#define OQS_SIG_alg_falcon_padded_1024 "Falcon-padded-1024" -/** Algorithm identifier for SPHINCS+-SHA2-128f-simple */ -#define OQS_SIG_alg_sphincs_sha2_128f_simple "SPHINCS+-SHA2-128f-simple" -/** Algorithm identifier for SPHINCS+-SHA2-128s-simple */ -#define OQS_SIG_alg_sphincs_sha2_128s_simple "SPHINCS+-SHA2-128s-simple" -/** Algorithm identifier for SPHINCS+-SHA2-192f-simple */ -#define OQS_SIG_alg_sphincs_sha2_192f_simple "SPHINCS+-SHA2-192f-simple" -/** Algorithm identifier for SPHINCS+-SHA2-192s-simple */ -#define OQS_SIG_alg_sphincs_sha2_192s_simple "SPHINCS+-SHA2-192s-simple" -/** Algorithm identifier for SPHINCS+-SHA2-256f-simple */ -#define OQS_SIG_alg_sphincs_sha2_256f_simple "SPHINCS+-SHA2-256f-simple" -/** Algorithm identifier for SPHINCS+-SHA2-256s-simple */ -#define OQS_SIG_alg_sphincs_sha2_256s_simple "SPHINCS+-SHA2-256s-simple" -/** Algorithm identifier for SPHINCS+-SHAKE-128f-simple */ -#define OQS_SIG_alg_sphincs_shake_128f_simple "SPHINCS+-SHAKE-128f-simple" -/** Algorithm identifier for SPHINCS+-SHAKE-128s-simple */ -#define OQS_SIG_alg_sphincs_shake_128s_simple "SPHINCS+-SHAKE-128s-simple" -/** Algorithm identifier for SPHINCS+-SHAKE-192f-simple */ -#define OQS_SIG_alg_sphincs_shake_192f_simple "SPHINCS+-SHAKE-192f-simple" -/** Algorithm identifier for SPHINCS+-SHAKE-192s-simple */ -#define OQS_SIG_alg_sphincs_shake_192s_simple "SPHINCS+-SHAKE-192s-simple" -/** Algorithm identifier for SPHINCS+-SHAKE-256f-simple */ -#define OQS_SIG_alg_sphincs_shake_256f_simple "SPHINCS+-SHAKE-256f-simple" -/** Algorithm identifier for SPHINCS+-SHAKE-256s-simple */ -#define OQS_SIG_alg_sphincs_shake_256s_simple "SPHINCS+-SHAKE-256s-simple" -/** Algorithm identifier for MAYO-1 */ -#define OQS_SIG_alg_mayo_1 "MAYO-1" -/** Algorithm identifier for MAYO-2 */ -#define OQS_SIG_alg_mayo_2 "MAYO-2" -/** Algorithm identifier for MAYO-3 */ -#define OQS_SIG_alg_mayo_3 "MAYO-3" -/** Algorithm identifier for MAYO-5 */ -#define OQS_SIG_alg_mayo_5 "MAYO-5" -/** Algorithm identifier for cross-rsdp-128-balanced */ -#define OQS_SIG_alg_cross_rsdp_128_balanced "cross-rsdp-128-balanced" -/** Algorithm identifier for cross-rsdp-128-fast */ -#define OQS_SIG_alg_cross_rsdp_128_fast "cross-rsdp-128-fast" -/** Algorithm identifier for cross-rsdp-128-small */ -#define OQS_SIG_alg_cross_rsdp_128_small "cross-rsdp-128-small" -/** Algorithm identifier for cross-rsdp-192-balanced */ -#define OQS_SIG_alg_cross_rsdp_192_balanced "cross-rsdp-192-balanced" -/** Algorithm identifier for cross-rsdp-192-fast */ -#define OQS_SIG_alg_cross_rsdp_192_fast "cross-rsdp-192-fast" -/** Algorithm identifier for cross-rsdp-192-small */ -#define OQS_SIG_alg_cross_rsdp_192_small "cross-rsdp-192-small" -/** Algorithm identifier for cross-rsdp-256-balanced */ -#define OQS_SIG_alg_cross_rsdp_256_balanced "cross-rsdp-256-balanced" -/** Algorithm identifier for cross-rsdp-256-fast */ -#define OQS_SIG_alg_cross_rsdp_256_fast "cross-rsdp-256-fast" -/** Algorithm identifier for cross-rsdp-256-small */ -#define OQS_SIG_alg_cross_rsdp_256_small "cross-rsdp-256-small" -/** Algorithm identifier for cross-rsdpg-128-balanced */ -#define OQS_SIG_alg_cross_rsdpg_128_balanced "cross-rsdpg-128-balanced" -/** Algorithm identifier for cross-rsdpg-128-fast */ -#define OQS_SIG_alg_cross_rsdpg_128_fast "cross-rsdpg-128-fast" -/** Algorithm identifier for cross-rsdpg-128-small */ -#define OQS_SIG_alg_cross_rsdpg_128_small "cross-rsdpg-128-small" -/** Algorithm identifier for cross-rsdpg-192-balanced */ -#define OQS_SIG_alg_cross_rsdpg_192_balanced "cross-rsdpg-192-balanced" -/** Algorithm identifier for cross-rsdpg-192-fast */ -#define OQS_SIG_alg_cross_rsdpg_192_fast "cross-rsdpg-192-fast" -/** Algorithm identifier for cross-rsdpg-192-small */ -#define OQS_SIG_alg_cross_rsdpg_192_small "cross-rsdpg-192-small" -/** Algorithm identifier for cross-rsdpg-256-balanced */ -#define OQS_SIG_alg_cross_rsdpg_256_balanced "cross-rsdpg-256-balanced" -/** Algorithm identifier for cross-rsdpg-256-fast */ -#define OQS_SIG_alg_cross_rsdpg_256_fast "cross-rsdpg-256-fast" -/** Algorithm identifier for cross-rsdpg-256-small */ -#define OQS_SIG_alg_cross_rsdpg_256_small "cross-rsdpg-256-small" -/** Algorithm identifier for OV-Is */ -#define OQS_SIG_alg_uov_ov_Is "OV-Is" -/** Algorithm identifier for OV-Ip */ -#define OQS_SIG_alg_uov_ov_Ip "OV-Ip" -/** Algorithm identifier for OV-III */ -#define OQS_SIG_alg_uov_ov_III "OV-III" -/** Algorithm identifier for OV-V */ -#define OQS_SIG_alg_uov_ov_V "OV-V" -/** Algorithm identifier for OV-Is-pkc */ -#define OQS_SIG_alg_uov_ov_Is_pkc "OV-Is-pkc" -/** Algorithm identifier for OV-Ip-pkc */ -#define OQS_SIG_alg_uov_ov_Ip_pkc "OV-Ip-pkc" -/** Algorithm identifier for OV-III-pkc */ -#define OQS_SIG_alg_uov_ov_III_pkc "OV-III-pkc" -/** Algorithm identifier for OV-V-pkc */ -#define OQS_SIG_alg_uov_ov_V_pkc "OV-V-pkc" -/** Algorithm identifier for OV-Is-pkc-skc */ -#define OQS_SIG_alg_uov_ov_Is_pkc_skc "OV-Is-pkc-skc" -/** Algorithm identifier for OV-Ip-pkc-skc */ -#define OQS_SIG_alg_uov_ov_Ip_pkc_skc "OV-Ip-pkc-skc" -/** Algorithm identifier for OV-III-pkc-skc */ -#define OQS_SIG_alg_uov_ov_III_pkc_skc "OV-III-pkc-skc" -/** Algorithm identifier for OV-V-pkc-skc */ -#define OQS_SIG_alg_uov_ov_V_pkc_skc "OV-V-pkc-skc" -/** Algorithm identifier for SNOVA_24_5_4 */ -#define OQS_SIG_alg_snova_SNOVA_24_5_4 "SNOVA_24_5_4" -/** Algorithm identifier for SNOVA_24_5_4_SHAKE */ -#define OQS_SIG_alg_snova_SNOVA_24_5_4_SHAKE "SNOVA_24_5_4_SHAKE" -/** Algorithm identifier for SNOVA_24_5_4_esk */ -#define OQS_SIG_alg_snova_SNOVA_24_5_4_esk "SNOVA_24_5_4_esk" -/** Algorithm identifier for SNOVA_24_5_4_SHAKE_esk */ -#define OQS_SIG_alg_snova_SNOVA_24_5_4_SHAKE_esk "SNOVA_24_5_4_SHAKE_esk" -/** Algorithm identifier for SNOVA_37_17_2 */ -#define OQS_SIG_alg_snova_SNOVA_37_17_2 "SNOVA_37_17_2" -/** Algorithm identifier for SNOVA_25_8_3 */ -#define OQS_SIG_alg_snova_SNOVA_25_8_3 "SNOVA_25_8_3" -/** Algorithm identifier for SNOVA_56_25_2 */ -#define OQS_SIG_alg_snova_SNOVA_56_25_2 "SNOVA_56_25_2" -/** Algorithm identifier for SNOVA_49_11_3 */ -#define OQS_SIG_alg_snova_SNOVA_49_11_3 "SNOVA_49_11_3" -/** Algorithm identifier for SNOVA_37_8_4 */ -#define OQS_SIG_alg_snova_SNOVA_37_8_4 "SNOVA_37_8_4" -/** Algorithm identifier for SNOVA_24_5_5 */ -#define OQS_SIG_alg_snova_SNOVA_24_5_5 "SNOVA_24_5_5" -/** Algorithm identifier for SNOVA_60_10_4 */ -#define OQS_SIG_alg_snova_SNOVA_60_10_4 "SNOVA_60_10_4" -/** Algorithm identifier for SNOVA_29_6_5 */ -#define OQS_SIG_alg_snova_SNOVA_29_6_5 "SNOVA_29_6_5" -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_ALG_IDENTIFIER_END -///// OQS_COPY_FROM_SLH_DSA_FRAGMENT_ALGID_START -/** Algorithm identifier for slh_dsa_pure_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_pure_sha2_128s "SLH_DSA_PURE_SHA2_128S" -/** Algorithm identifier for slh_dsa_pure_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_pure_sha2_128f "SLH_DSA_PURE_SHA2_128F" -/** Algorithm identifier for slh_dsa_pure_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_pure_sha2_192s "SLH_DSA_PURE_SHA2_192S" -/** Algorithm identifier for slh_dsa_pure_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_pure_sha2_192f "SLH_DSA_PURE_SHA2_192F" -/** Algorithm identifier for slh_dsa_pure_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_pure_sha2_256s "SLH_DSA_PURE_SHA2_256S" -/** Algorithm identifier for slh_dsa_pure_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_pure_sha2_256f "SLH_DSA_PURE_SHA2_256F" -/** Algorithm identifier for slh_dsa_pure_shake_128s */ -#define OQS_SIG_alg_slh_dsa_pure_shake_128s "SLH_DSA_PURE_SHAKE_128S" -/** Algorithm identifier for slh_dsa_pure_shake_128f */ -#define OQS_SIG_alg_slh_dsa_pure_shake_128f "SLH_DSA_PURE_SHAKE_128F" -/** Algorithm identifier for slh_dsa_pure_shake_192s */ -#define OQS_SIG_alg_slh_dsa_pure_shake_192s "SLH_DSA_PURE_SHAKE_192S" -/** Algorithm identifier for slh_dsa_pure_shake_192f */ -#define OQS_SIG_alg_slh_dsa_pure_shake_192f "SLH_DSA_PURE_SHAKE_192F" -/** Algorithm identifier for slh_dsa_pure_shake_256s */ -#define OQS_SIG_alg_slh_dsa_pure_shake_256s "SLH_DSA_PURE_SHAKE_256S" -/** Algorithm identifier for slh_dsa_pure_shake_256f */ -#define OQS_SIG_alg_slh_dsa_pure_shake_256f "SLH_DSA_PURE_SHAKE_256F" -/** Algorithm identifier for slh_dsa_sha2_224_prehash_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_sha2_128s "SLH_DSA_SHA2_224_PREHASH_SHA2_128S" -/** Algorithm identifier for slh_dsa_sha2_224_prehash_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_sha2_128f "SLH_DSA_SHA2_224_PREHASH_SHA2_128F" -/** Algorithm identifier for slh_dsa_sha2_224_prehash_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_sha2_192s "SLH_DSA_SHA2_224_PREHASH_SHA2_192S" -/** Algorithm identifier for slh_dsa_sha2_224_prehash_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_sha2_192f "SLH_DSA_SHA2_224_PREHASH_SHA2_192F" -/** Algorithm identifier for slh_dsa_sha2_224_prehash_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_sha2_256s "SLH_DSA_SHA2_224_PREHASH_SHA2_256S" -/** Algorithm identifier for slh_dsa_sha2_224_prehash_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_sha2_256f "SLH_DSA_SHA2_224_PREHASH_SHA2_256F" -/** Algorithm identifier for slh_dsa_sha2_224_prehash_shake_128s */ -#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_shake_128s "SLH_DSA_SHA2_224_PREHASH_SHAKE_128S" -/** Algorithm identifier for slh_dsa_sha2_224_prehash_shake_128f */ -#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_shake_128f "SLH_DSA_SHA2_224_PREHASH_SHAKE_128F" -/** Algorithm identifier for slh_dsa_sha2_224_prehash_shake_192s */ -#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_shake_192s "SLH_DSA_SHA2_224_PREHASH_SHAKE_192S" -/** Algorithm identifier for slh_dsa_sha2_224_prehash_shake_192f */ -#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_shake_192f "SLH_DSA_SHA2_224_PREHASH_SHAKE_192F" -/** Algorithm identifier for slh_dsa_sha2_224_prehash_shake_256s */ -#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_shake_256s "SLH_DSA_SHA2_224_PREHASH_SHAKE_256S" -/** Algorithm identifier for slh_dsa_sha2_224_prehash_shake_256f */ -#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_shake_256f "SLH_DSA_SHA2_224_PREHASH_SHAKE_256F" -/** Algorithm identifier for slh_dsa_sha2_256_prehash_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_sha2_128s "SLH_DSA_SHA2_256_PREHASH_SHA2_128S" -/** Algorithm identifier for slh_dsa_sha2_256_prehash_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_sha2_128f "SLH_DSA_SHA2_256_PREHASH_SHA2_128F" -/** Algorithm identifier for slh_dsa_sha2_256_prehash_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_sha2_192s "SLH_DSA_SHA2_256_PREHASH_SHA2_192S" -/** Algorithm identifier for slh_dsa_sha2_256_prehash_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_sha2_192f "SLH_DSA_SHA2_256_PREHASH_SHA2_192F" -/** Algorithm identifier for slh_dsa_sha2_256_prehash_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_sha2_256s "SLH_DSA_SHA2_256_PREHASH_SHA2_256S" -/** Algorithm identifier for slh_dsa_sha2_256_prehash_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_sha2_256f "SLH_DSA_SHA2_256_PREHASH_SHA2_256F" -/** Algorithm identifier for slh_dsa_sha2_256_prehash_shake_128s */ -#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_shake_128s "SLH_DSA_SHA2_256_PREHASH_SHAKE_128S" -/** Algorithm identifier for slh_dsa_sha2_256_prehash_shake_128f */ -#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_shake_128f "SLH_DSA_SHA2_256_PREHASH_SHAKE_128F" -/** Algorithm identifier for slh_dsa_sha2_256_prehash_shake_192s */ -#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_shake_192s "SLH_DSA_SHA2_256_PREHASH_SHAKE_192S" -/** Algorithm identifier for slh_dsa_sha2_256_prehash_shake_192f */ -#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_shake_192f "SLH_DSA_SHA2_256_PREHASH_SHAKE_192F" -/** Algorithm identifier for slh_dsa_sha2_256_prehash_shake_256s */ -#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_shake_256s "SLH_DSA_SHA2_256_PREHASH_SHAKE_256S" -/** Algorithm identifier for slh_dsa_sha2_256_prehash_shake_256f */ -#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_shake_256f "SLH_DSA_SHA2_256_PREHASH_SHAKE_256F" -/** Algorithm identifier for slh_dsa_sha2_384_prehash_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_sha2_128s "SLH_DSA_SHA2_384_PREHASH_SHA2_128S" -/** Algorithm identifier for slh_dsa_sha2_384_prehash_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_sha2_128f "SLH_DSA_SHA2_384_PREHASH_SHA2_128F" -/** Algorithm identifier for slh_dsa_sha2_384_prehash_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_sha2_192s "SLH_DSA_SHA2_384_PREHASH_SHA2_192S" -/** Algorithm identifier for slh_dsa_sha2_384_prehash_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_sha2_192f "SLH_DSA_SHA2_384_PREHASH_SHA2_192F" -/** Algorithm identifier for slh_dsa_sha2_384_prehash_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_sha2_256s "SLH_DSA_SHA2_384_PREHASH_SHA2_256S" -/** Algorithm identifier for slh_dsa_sha2_384_prehash_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_sha2_256f "SLH_DSA_SHA2_384_PREHASH_SHA2_256F" -/** Algorithm identifier for slh_dsa_sha2_384_prehash_shake_128s */ -#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_shake_128s "SLH_DSA_SHA2_384_PREHASH_SHAKE_128S" -/** Algorithm identifier for slh_dsa_sha2_384_prehash_shake_128f */ -#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_shake_128f "SLH_DSA_SHA2_384_PREHASH_SHAKE_128F" -/** Algorithm identifier for slh_dsa_sha2_384_prehash_shake_192s */ -#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_shake_192s "SLH_DSA_SHA2_384_PREHASH_SHAKE_192S" -/** Algorithm identifier for slh_dsa_sha2_384_prehash_shake_192f */ -#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_shake_192f "SLH_DSA_SHA2_384_PREHASH_SHAKE_192F" -/** Algorithm identifier for slh_dsa_sha2_384_prehash_shake_256s */ -#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_shake_256s "SLH_DSA_SHA2_384_PREHASH_SHAKE_256S" -/** Algorithm identifier for slh_dsa_sha2_384_prehash_shake_256f */ -#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_shake_256f "SLH_DSA_SHA2_384_PREHASH_SHAKE_256F" -/** Algorithm identifier for slh_dsa_sha2_512_prehash_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_sha2_128s "SLH_DSA_SHA2_512_PREHASH_SHA2_128S" -/** Algorithm identifier for slh_dsa_sha2_512_prehash_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_sha2_128f "SLH_DSA_SHA2_512_PREHASH_SHA2_128F" -/** Algorithm identifier for slh_dsa_sha2_512_prehash_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_sha2_192s "SLH_DSA_SHA2_512_PREHASH_SHA2_192S" -/** Algorithm identifier for slh_dsa_sha2_512_prehash_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_sha2_192f "SLH_DSA_SHA2_512_PREHASH_SHA2_192F" -/** Algorithm identifier for slh_dsa_sha2_512_prehash_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_sha2_256s "SLH_DSA_SHA2_512_PREHASH_SHA2_256S" -/** Algorithm identifier for slh_dsa_sha2_512_prehash_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_sha2_256f "SLH_DSA_SHA2_512_PREHASH_SHA2_256F" -/** Algorithm identifier for slh_dsa_sha2_512_prehash_shake_128s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_shake_128s "SLH_DSA_SHA2_512_PREHASH_SHAKE_128S" -/** Algorithm identifier for slh_dsa_sha2_512_prehash_shake_128f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_shake_128f "SLH_DSA_SHA2_512_PREHASH_SHAKE_128F" -/** Algorithm identifier for slh_dsa_sha2_512_prehash_shake_192s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_shake_192s "SLH_DSA_SHA2_512_PREHASH_SHAKE_192S" -/** Algorithm identifier for slh_dsa_sha2_512_prehash_shake_192f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_shake_192f "SLH_DSA_SHA2_512_PREHASH_SHAKE_192F" -/** Algorithm identifier for slh_dsa_sha2_512_prehash_shake_256s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_shake_256s "SLH_DSA_SHA2_512_PREHASH_SHAKE_256S" -/** Algorithm identifier for slh_dsa_sha2_512_prehash_shake_256f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_shake_256f "SLH_DSA_SHA2_512_PREHASH_SHAKE_256F" -/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_sha2_128s "SLH_DSA_SHA2_512_224_PREHASH_SHA2_128S" -/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_sha2_128f "SLH_DSA_SHA2_512_224_PREHASH_SHA2_128F" -/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_sha2_192s "SLH_DSA_SHA2_512_224_PREHASH_SHA2_192S" -/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_sha2_192f "SLH_DSA_SHA2_512_224_PREHASH_SHA2_192F" -/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_sha2_256s "SLH_DSA_SHA2_512_224_PREHASH_SHA2_256S" -/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_sha2_256f "SLH_DSA_SHA2_512_224_PREHASH_SHA2_256F" -/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_shake_128s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_shake_128s "SLH_DSA_SHA2_512_224_PREHASH_SHAKE_128S" -/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_shake_128f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_shake_128f "SLH_DSA_SHA2_512_224_PREHASH_SHAKE_128F" -/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_shake_192s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_shake_192s "SLH_DSA_SHA2_512_224_PREHASH_SHAKE_192S" -/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_shake_192f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_shake_192f "SLH_DSA_SHA2_512_224_PREHASH_SHAKE_192F" -/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_shake_256s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_shake_256s "SLH_DSA_SHA2_512_224_PREHASH_SHAKE_256S" -/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_shake_256f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_shake_256f "SLH_DSA_SHA2_512_224_PREHASH_SHAKE_256F" -/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_sha2_128s "SLH_DSA_SHA2_512_256_PREHASH_SHA2_128S" -/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_sha2_128f "SLH_DSA_SHA2_512_256_PREHASH_SHA2_128F" -/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_sha2_192s "SLH_DSA_SHA2_512_256_PREHASH_SHA2_192S" -/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_sha2_192f "SLH_DSA_SHA2_512_256_PREHASH_SHA2_192F" -/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_sha2_256s "SLH_DSA_SHA2_512_256_PREHASH_SHA2_256S" -/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_sha2_256f "SLH_DSA_SHA2_512_256_PREHASH_SHA2_256F" -/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_shake_128s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_shake_128s "SLH_DSA_SHA2_512_256_PREHASH_SHAKE_128S" -/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_shake_128f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_shake_128f "SLH_DSA_SHA2_512_256_PREHASH_SHAKE_128F" -/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_shake_192s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_shake_192s "SLH_DSA_SHA2_512_256_PREHASH_SHAKE_192S" -/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_shake_192f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_shake_192f "SLH_DSA_SHA2_512_256_PREHASH_SHAKE_192F" -/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_shake_256s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_shake_256s "SLH_DSA_SHA2_512_256_PREHASH_SHAKE_256S" -/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_shake_256f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_shake_256f "SLH_DSA_SHA2_512_256_PREHASH_SHAKE_256F" -/** Algorithm identifier for slh_dsa_sha3_224_prehash_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_sha2_128s "SLH_DSA_SHA3_224_PREHASH_SHA2_128S" -/** Algorithm identifier for slh_dsa_sha3_224_prehash_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_sha2_128f "SLH_DSA_SHA3_224_PREHASH_SHA2_128F" -/** Algorithm identifier for slh_dsa_sha3_224_prehash_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_sha2_192s "SLH_DSA_SHA3_224_PREHASH_SHA2_192S" -/** Algorithm identifier for slh_dsa_sha3_224_prehash_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_sha2_192f "SLH_DSA_SHA3_224_PREHASH_SHA2_192F" -/** Algorithm identifier for slh_dsa_sha3_224_prehash_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_sha2_256s "SLH_DSA_SHA3_224_PREHASH_SHA2_256S" -/** Algorithm identifier for slh_dsa_sha3_224_prehash_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_sha2_256f "SLH_DSA_SHA3_224_PREHASH_SHA2_256F" -/** Algorithm identifier for slh_dsa_sha3_224_prehash_shake_128s */ -#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_shake_128s "SLH_DSA_SHA3_224_PREHASH_SHAKE_128S" -/** Algorithm identifier for slh_dsa_sha3_224_prehash_shake_128f */ -#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_shake_128f "SLH_DSA_SHA3_224_PREHASH_SHAKE_128F" -/** Algorithm identifier for slh_dsa_sha3_224_prehash_shake_192s */ -#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_shake_192s "SLH_DSA_SHA3_224_PREHASH_SHAKE_192S" -/** Algorithm identifier for slh_dsa_sha3_224_prehash_shake_192f */ -#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_shake_192f "SLH_DSA_SHA3_224_PREHASH_SHAKE_192F" -/** Algorithm identifier for slh_dsa_sha3_224_prehash_shake_256s */ -#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_shake_256s "SLH_DSA_SHA3_224_PREHASH_SHAKE_256S" -/** Algorithm identifier for slh_dsa_sha3_224_prehash_shake_256f */ -#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_shake_256f "SLH_DSA_SHA3_224_PREHASH_SHAKE_256F" -/** Algorithm identifier for slh_dsa_sha3_256_prehash_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_sha2_128s "SLH_DSA_SHA3_256_PREHASH_SHA2_128S" -/** Algorithm identifier for slh_dsa_sha3_256_prehash_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_sha2_128f "SLH_DSA_SHA3_256_PREHASH_SHA2_128F" -/** Algorithm identifier for slh_dsa_sha3_256_prehash_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_sha2_192s "SLH_DSA_SHA3_256_PREHASH_SHA2_192S" -/** Algorithm identifier for slh_dsa_sha3_256_prehash_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_sha2_192f "SLH_DSA_SHA3_256_PREHASH_SHA2_192F" -/** Algorithm identifier for slh_dsa_sha3_256_prehash_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_sha2_256s "SLH_DSA_SHA3_256_PREHASH_SHA2_256S" -/** Algorithm identifier for slh_dsa_sha3_256_prehash_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_sha2_256f "SLH_DSA_SHA3_256_PREHASH_SHA2_256F" -/** Algorithm identifier for slh_dsa_sha3_256_prehash_shake_128s */ -#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_shake_128s "SLH_DSA_SHA3_256_PREHASH_SHAKE_128S" -/** Algorithm identifier for slh_dsa_sha3_256_prehash_shake_128f */ -#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_shake_128f "SLH_DSA_SHA3_256_PREHASH_SHAKE_128F" -/** Algorithm identifier for slh_dsa_sha3_256_prehash_shake_192s */ -#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_shake_192s "SLH_DSA_SHA3_256_PREHASH_SHAKE_192S" -/** Algorithm identifier for slh_dsa_sha3_256_prehash_shake_192f */ -#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_shake_192f "SLH_DSA_SHA3_256_PREHASH_SHAKE_192F" -/** Algorithm identifier for slh_dsa_sha3_256_prehash_shake_256s */ -#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_shake_256s "SLH_DSA_SHA3_256_PREHASH_SHAKE_256S" -/** Algorithm identifier for slh_dsa_sha3_256_prehash_shake_256f */ -#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_shake_256f "SLH_DSA_SHA3_256_PREHASH_SHAKE_256F" -/** Algorithm identifier for slh_dsa_sha3_384_prehash_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_sha2_128s "SLH_DSA_SHA3_384_PREHASH_SHA2_128S" -/** Algorithm identifier for slh_dsa_sha3_384_prehash_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_sha2_128f "SLH_DSA_SHA3_384_PREHASH_SHA2_128F" -/** Algorithm identifier for slh_dsa_sha3_384_prehash_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_sha2_192s "SLH_DSA_SHA3_384_PREHASH_SHA2_192S" -/** Algorithm identifier for slh_dsa_sha3_384_prehash_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_sha2_192f "SLH_DSA_SHA3_384_PREHASH_SHA2_192F" -/** Algorithm identifier for slh_dsa_sha3_384_prehash_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_sha2_256s "SLH_DSA_SHA3_384_PREHASH_SHA2_256S" -/** Algorithm identifier for slh_dsa_sha3_384_prehash_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_sha2_256f "SLH_DSA_SHA3_384_PREHASH_SHA2_256F" -/** Algorithm identifier for slh_dsa_sha3_384_prehash_shake_128s */ -#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_shake_128s "SLH_DSA_SHA3_384_PREHASH_SHAKE_128S" -/** Algorithm identifier for slh_dsa_sha3_384_prehash_shake_128f */ -#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_shake_128f "SLH_DSA_SHA3_384_PREHASH_SHAKE_128F" -/** Algorithm identifier for slh_dsa_sha3_384_prehash_shake_192s */ -#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_shake_192s "SLH_DSA_SHA3_384_PREHASH_SHAKE_192S" -/** Algorithm identifier for slh_dsa_sha3_384_prehash_shake_192f */ -#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_shake_192f "SLH_DSA_SHA3_384_PREHASH_SHAKE_192F" -/** Algorithm identifier for slh_dsa_sha3_384_prehash_shake_256s */ -#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_shake_256s "SLH_DSA_SHA3_384_PREHASH_SHAKE_256S" -/** Algorithm identifier for slh_dsa_sha3_384_prehash_shake_256f */ -#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_shake_256f "SLH_DSA_SHA3_384_PREHASH_SHAKE_256F" -/** Algorithm identifier for slh_dsa_sha3_512_prehash_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_sha2_128s "SLH_DSA_SHA3_512_PREHASH_SHA2_128S" -/** Algorithm identifier for slh_dsa_sha3_512_prehash_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_sha2_128f "SLH_DSA_SHA3_512_PREHASH_SHA2_128F" -/** Algorithm identifier for slh_dsa_sha3_512_prehash_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_sha2_192s "SLH_DSA_SHA3_512_PREHASH_SHA2_192S" -/** Algorithm identifier for slh_dsa_sha3_512_prehash_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_sha2_192f "SLH_DSA_SHA3_512_PREHASH_SHA2_192F" -/** Algorithm identifier for slh_dsa_sha3_512_prehash_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_sha2_256s "SLH_DSA_SHA3_512_PREHASH_SHA2_256S" -/** Algorithm identifier for slh_dsa_sha3_512_prehash_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_sha2_256f "SLH_DSA_SHA3_512_PREHASH_SHA2_256F" -/** Algorithm identifier for slh_dsa_sha3_512_prehash_shake_128s */ -#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_shake_128s "SLH_DSA_SHA3_512_PREHASH_SHAKE_128S" -/** Algorithm identifier for slh_dsa_sha3_512_prehash_shake_128f */ -#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_shake_128f "SLH_DSA_SHA3_512_PREHASH_SHAKE_128F" -/** Algorithm identifier for slh_dsa_sha3_512_prehash_shake_192s */ -#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_shake_192s "SLH_DSA_SHA3_512_PREHASH_SHAKE_192S" -/** Algorithm identifier for slh_dsa_sha3_512_prehash_shake_192f */ -#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_shake_192f "SLH_DSA_SHA3_512_PREHASH_SHAKE_192F" -/** Algorithm identifier for slh_dsa_sha3_512_prehash_shake_256s */ -#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_shake_256s "SLH_DSA_SHA3_512_PREHASH_SHAKE_256S" -/** Algorithm identifier for slh_dsa_sha3_512_prehash_shake_256f */ -#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_shake_256f "SLH_DSA_SHA3_512_PREHASH_SHAKE_256F" -/** Algorithm identifier for slh_dsa_shake_128_prehash_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_shake_128_prehash_sha2_128s "SLH_DSA_SHAKE_128_PREHASH_SHA2_128S" -/** Algorithm identifier for slh_dsa_shake_128_prehash_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_shake_128_prehash_sha2_128f "SLH_DSA_SHAKE_128_PREHASH_SHA2_128F" -/** Algorithm identifier for slh_dsa_shake_128_prehash_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_shake_128_prehash_sha2_192s "SLH_DSA_SHAKE_128_PREHASH_SHA2_192S" -/** Algorithm identifier for slh_dsa_shake_128_prehash_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_shake_128_prehash_sha2_192f "SLH_DSA_SHAKE_128_PREHASH_SHA2_192F" -/** Algorithm identifier for slh_dsa_shake_128_prehash_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_shake_128_prehash_sha2_256s "SLH_DSA_SHAKE_128_PREHASH_SHA2_256S" -/** Algorithm identifier for slh_dsa_shake_128_prehash_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_shake_128_prehash_sha2_256f "SLH_DSA_SHAKE_128_PREHASH_SHA2_256F" -/** Algorithm identifier for slh_dsa_shake_128_prehash_shake_128s */ -#define OQS_SIG_alg_slh_dsa_shake_128_prehash_shake_128s "SLH_DSA_SHAKE_128_PREHASH_SHAKE_128S" -/** Algorithm identifier for slh_dsa_shake_128_prehash_shake_128f */ -#define OQS_SIG_alg_slh_dsa_shake_128_prehash_shake_128f "SLH_DSA_SHAKE_128_PREHASH_SHAKE_128F" -/** Algorithm identifier for slh_dsa_shake_128_prehash_shake_192s */ -#define OQS_SIG_alg_slh_dsa_shake_128_prehash_shake_192s "SLH_DSA_SHAKE_128_PREHASH_SHAKE_192S" -/** Algorithm identifier for slh_dsa_shake_128_prehash_shake_192f */ -#define OQS_SIG_alg_slh_dsa_shake_128_prehash_shake_192f "SLH_DSA_SHAKE_128_PREHASH_SHAKE_192F" -/** Algorithm identifier for slh_dsa_shake_128_prehash_shake_256s */ -#define OQS_SIG_alg_slh_dsa_shake_128_prehash_shake_256s "SLH_DSA_SHAKE_128_PREHASH_SHAKE_256S" -/** Algorithm identifier for slh_dsa_shake_128_prehash_shake_256f */ -#define OQS_SIG_alg_slh_dsa_shake_128_prehash_shake_256f "SLH_DSA_SHAKE_128_PREHASH_SHAKE_256F" -/** Algorithm identifier for slh_dsa_shake_256_prehash_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_shake_256_prehash_sha2_128s "SLH_DSA_SHAKE_256_PREHASH_SHA2_128S" -/** Algorithm identifier for slh_dsa_shake_256_prehash_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_shake_256_prehash_sha2_128f "SLH_DSA_SHAKE_256_PREHASH_SHA2_128F" -/** Algorithm identifier for slh_dsa_shake_256_prehash_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_shake_256_prehash_sha2_192s "SLH_DSA_SHAKE_256_PREHASH_SHA2_192S" -/** Algorithm identifier for slh_dsa_shake_256_prehash_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_shake_256_prehash_sha2_192f "SLH_DSA_SHAKE_256_PREHASH_SHA2_192F" -/** Algorithm identifier for slh_dsa_shake_256_prehash_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_shake_256_prehash_sha2_256s "SLH_DSA_SHAKE_256_PREHASH_SHA2_256S" -/** Algorithm identifier for slh_dsa_shake_256_prehash_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_shake_256_prehash_sha2_256f "SLH_DSA_SHAKE_256_PREHASH_SHA2_256F" -/** Algorithm identifier for slh_dsa_shake_256_prehash_shake_128s */ -#define OQS_SIG_alg_slh_dsa_shake_256_prehash_shake_128s "SLH_DSA_SHAKE_256_PREHASH_SHAKE_128S" -/** Algorithm identifier for slh_dsa_shake_256_prehash_shake_128f */ -#define OQS_SIG_alg_slh_dsa_shake_256_prehash_shake_128f "SLH_DSA_SHAKE_256_PREHASH_SHAKE_128F" -/** Algorithm identifier for slh_dsa_shake_256_prehash_shake_192s */ -#define OQS_SIG_alg_slh_dsa_shake_256_prehash_shake_192s "SLH_DSA_SHAKE_256_PREHASH_SHAKE_192S" -/** Algorithm identifier for slh_dsa_shake_256_prehash_shake_192f */ -#define OQS_SIG_alg_slh_dsa_shake_256_prehash_shake_192f "SLH_DSA_SHAKE_256_PREHASH_SHAKE_192F" -/** Algorithm identifier for slh_dsa_shake_256_prehash_shake_256s */ -#define OQS_SIG_alg_slh_dsa_shake_256_prehash_shake_256s "SLH_DSA_SHAKE_256_PREHASH_SHAKE_256S" -/** Algorithm identifier for slh_dsa_shake_256_prehash_shake_256f */ -#define OQS_SIG_alg_slh_dsa_shake_256_prehash_shake_256f "SLH_DSA_SHAKE_256_PREHASH_SHAKE_256F" -///// OQS_COPY_FROM_SLH_DSA_FRAGMENT_ALGID_END -// EDIT-WHEN-ADDING-SIG -///// OQS_COPY_FROM_SLH_DSA_FRAGMENT_ALGS_LENGTH_START - -/** Number of algorithm identifiers above. */ -#define OQS_SIG_SLH_DSA_algs_length 156 -///// OQS_COPY_FROM_SLH_DSA_FRAGMENT_ALGS_LENGTH_END -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_ALGS_LENGTH_START - -/** Number of algorithm identifiers above. */ -#define OQS_SIG_algs_length 65 + OQS_SIG_SLH_DSA_algs_length -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_ALGS_LENGTH_END - -/** - * Returns identifiers for available signature schemes in liboqs. Used with OQS_SIG_new. - * - * Note that algorithm identifiers are present in this list even when the algorithm is disabled - * at compile time. - * - * @param[in] i Index of the algorithm identifier to return, 0 <= i < OQS_SIG_algs_length - * @return Algorithm identifier as a string, or NULL. - */ -OQS_API const char *OQS_SIG_alg_identifier(size_t i); - -/** - * Returns the number of signature mechanisms in liboqs. They can be enumerated with - * OQS_SIG_alg_identifier. - * - * Note that some mechanisms may be disabled at compile time. - * - * @return The number of signature mechanisms. - */ -OQS_API int OQS_SIG_alg_count(void); - -/** - * Indicates whether the specified algorithm was enabled at compile-time or not. - * - * @param[in] method_name Name of the desired algorithm; one of the names in `OQS_SIG_algs`. - * @return 1 if enabled, 0 if disabled or not found - */ -OQS_API int OQS_SIG_alg_is_enabled(const char *method_name); - -/** - * Signature schemes object - */ -typedef struct OQS_SIG { - - /** Printable string representing the name of the signature scheme. */ - const char *method_name; - - /** - * Printable string representing the version of the cryptographic algorithm. - * - * Implementations with the same method_name and same alg_version will be interoperable. - * See README.md for information about algorithm compatibility. - */ - const char *alg_version; - - /** The NIST security level (1, 2, 3, 4, 5) claimed in this algorithm's original NIST submission. */ - uint8_t claimed_nist_level; - - /** Whether the signature offers EUF-CMA security (TRUE) or not (FALSE). */ - bool euf_cma; - - /** Whether the signature offers SUF-CMA security (TRUE) or not (FALSE). */ - bool suf_cma; - - /** Whether the signature supports signing with a context string (TRUE) or not (FALSE). */ - bool sig_with_ctx_support; - - /** The length, in bytes, of public keys for this signature scheme. */ - size_t length_public_key; - /** The length, in bytes, of secret keys for this signature scheme. */ - size_t length_secret_key; - /** The (maximum) length, in bytes, of signatures for this signature scheme. */ - size_t length_signature; - - /** - * Keypair generation algorithm. - * - * Caller is responsible for allocating sufficient memory for `public_key` and - * `secret_key`, based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_SIG_*_length_*`. - * - * @param[out] public_key The public key represented as a byte string. - * @param[out] secret_key The secret key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*keypair)(uint8_t *public_key, uint8_t *secret_key); - - /** - * Signature generation algorithm. - * - * Caller is responsible for allocating sufficient memory for `signature`, - * based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_SIG_*_length_*`. - * - * @param[out] signature The signature on the message represented as a byte string. - * @param[out] signature_len The actual length of the signature. May be smaller than `length_signature` for some algorithms since some algorithms have variable length signatures. - * @param[in] message The message to sign represented as a byte string. - * @param[in] message_len The length of the message to sign. - * @param[in] secret_key The secret key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*sign)(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); - - /** - * Signature generation algorithm, with custom context string. - * - * Caller is responsible for allocating sufficient memory for `signature`, - * based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_SIG_*_length_*`. - * - * @param[out] signature The signature on the message represented as a byte string. - * @param[out] signature_len The actual length of the signature. May be smaller than `length_signature` for some algorithms since some algorithms have variable length signatures. - * @param[in] message The message to sign represented as a byte string. - * @param[in] message_len The length of the message to sign. - * @param[in] ctx_str The context string used for the signature. This value can be set to NULL if a context string is not needed (i.e., for algorithms that do not support context strings or if an empty context string is used). - * @param[in] ctx_str_len The context string used for the signature. This value can be set to 0 if a context string is not needed (i.e., for algorithms that do not support context strings or if an empty context string is used). - * @param[in] secret_key The secret key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*sign_with_ctx_str)(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str, size_t ctx_str_len, const uint8_t *secret_key); - - /** - * Signature verification algorithm. - * - * @param[in] message The message represented as a byte string. - * @param[in] message_len The length of the message. - * @param[in] signature The signature on the message represented as a byte string. - * @param[in] signature_len The length of the signature. - * @param[in] public_key The public key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*verify)(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); - - /** - * Signature verification algorithm, with custom context string. - * - * @param[in] message The message represented as a byte string. - * @param[in] message_len The length of the message. - * @param[in] signature The signature on the message represented as a byte string. - * @param[in] signature_len The length of the signature. - * @param[in] ctx_str The context string for the signature. This value can be set to NULL if a context string is not needed (i.e., for algorithms that do not support context strings or if an empty context string is used). - * @param[in] ctx_str_len The length of the context string. This value can be set to 0 if a context string is not needed (i.e., for algorithms that do not support context strings or if an empty context string is used). - * @param[in] public_key The public key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*verify_with_ctx_str)(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str, size_t ctx_str_len, const uint8_t *public_key); - - -} OQS_SIG; - -/** - * Constructs an OQS_SIG object for a particular algorithm. - * - * Callers should always check whether the return value is `NULL`, which indicates either than an - * invalid algorithm name was provided, or that the requested algorithm was disabled at compile-time. - * - * @param[in] method_name Name of the desired algorithm; one of the names in `OQS_SIG_algs`. - * @return An OQS_SIG for the particular algorithm, or `NULL` if the algorithm has been disabled at compile-time. - */ -OQS_API OQS_SIG *OQS_SIG_new(const char *method_name); - -/** - * Keypair generation algorithm. - * - * Caller is responsible for allocating sufficient memory for `public_key` and - * `secret_key`, based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_SIG_*_length_*`. - * - * @param[in] sig The OQS_SIG object representing the signature scheme. - * @param[out] public_key The public key represented as a byte string. - * @param[out] secret_key The secret key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_SIG_keypair(const OQS_SIG *sig, uint8_t *public_key, uint8_t *secret_key); - -/** - * Signature generation algorithm. - * - * Caller is responsible for allocating sufficient memory for `signnature`, - * based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_SIG_*_length_*`. - * - * @param[in] sig The OQS_SIG object representing the signature scheme. - * @param[out] signature The signature on the message represented as a byte string. - * @param[out] signature_len The length of the signature. - * @param[in] message The message to sign represented as a byte string. - * @param[in] message_len The length of the message to sign. - * @param[in] secret_key The secret key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_SIG_sign(const OQS_SIG *sig, uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); - -/** - * Signature generation algorithm, with custom context string. - * - * Caller is responsible for allocating sufficient memory for `signature`, - * based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_SIG_*_length_*`. - * - * @param[in] sig The OQS_SIG object representing the signature scheme. - * @param[out] signature The signature on the message represented as a byte string. - * @param[out] signature_len The actual length of the signature. May be smaller than `length_signature` for some algorithms since some algorithms have variable length signatures. - * @param[in] message The message to sign represented as a byte string. - * @param[in] message_len The length of the message to sign. - * @param[in] ctx_str The context string used for the signature. This value can be set to NULL if a context string is not needed (i.e., for algorithms that do not support context strings or if an empty context string is used). - * @param[in] ctx_str_len The context string used for the signature. This value can be set to 0 if a context string is not needed (i.e., for algorithms that do not support context strings or if an empty context string is used). - * @param[in] secret_key The secret key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_SIG_sign_with_ctx_str(const OQS_SIG *sig, uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str, size_t ctx_str_len, const uint8_t *secret_key); - -/** - * Signature verification algorithm. - * - * @param[in] sig The OQS_SIG object representing the signature scheme. - * @param[in] message The message represented as a byte string. - * @param[in] message_len The length of the message. - * @param[in] signature The signature on the message represented as a byte string. - * @param[in] signature_len The length of the signature. - * @param[in] public_key The public key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_SIG_verify(const OQS_SIG *sig, const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); - -/** - * Signature verification algorithm, with custom context string. - * - * @param[in] sig The OQS_SIG object representing the signature scheme. - * @param[in] message The message represented as a byte string. - * @param[in] message_len The length of the message. - * @param[in] signature The signature on the message represented as a byte string. - * @param[in] signature_len The length of the signature. - * @param[in] ctx_str The context string used for the signature. This value can be set to NULL if a context string is not needed (i.e., for algorithms that do not support context strings or if an empty context string is used). - * @param[in] ctx_str_len The context string used for the signature. This value can be set to 0 if a context string is not needed (i.e., for algorithms that do not support context strings or if an empty context string is used). - * @param[in] public_key The public key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_SIG_verify_with_ctx_str(const OQS_SIG *sig, const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str, size_t ctx_str_len, const uint8_t *public_key); - -/** - * Frees an OQS_SIG object that was constructed by OQS_SIG_new. - * - * @param[in] sig The OQS_SIG object to free. - */ -OQS_API void OQS_SIG_free(OQS_SIG *sig); - -/** - * Indicates whether the specified signature algorithm supports signing with a context string. - * - * @param[in] alg_name Name of the desired algorithm; one of the names in `OQS_SIG_algs`. - * @return true if the algorithm supports context string signing, false otherwise. - */ -OQS_API bool OQS_SIG_supports_ctx_str(const char *alg_name); - -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_INCLUDE_START -#ifdef OQS_ENABLE_SIG_ML_DSA -#include -#endif /* OQS_ENABLE_SIG_ML_DSA */ -#ifdef OQS_ENABLE_SIG_FALCON -#include -#endif /* OQS_ENABLE_SIG_FALCON */ -#ifdef OQS_ENABLE_SIG_SPHINCS -#include -#endif /* OQS_ENABLE_SIG_SPHINCS */ -#ifdef OQS_ENABLE_SIG_MAYO -#include -#endif /* OQS_ENABLE_SIG_MAYO */ -#ifdef OQS_ENABLE_SIG_CROSS -#include -#endif /* OQS_ENABLE_SIG_CROSS */ -#ifdef OQS_ENABLE_SIG_UOV -#include -#endif /* OQS_ENABLE_SIG_UOV */ -#ifdef OQS_ENABLE_SIG_SNOVA -#include -#endif /* OQS_ENABLE_SIG_SNOVA */ -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_INCLUDE_END -///// OQS_COPY_FROM_SLH_DSA_FRAGMENT_INCLUDE_START -#ifdef OQS_ENABLE_SIG_SLH_DSA -#include -#endif /* OQS_ENABLE_SIG_SLH_DSA */ -///// OQS_COPY_FROM_SLH_DSA_FRAGMENT_INCLUDE_END -// EDIT-WHEN-ADDING-SIG - -#if defined(__cplusplus) -} // extern "C" -#endif - -#endif // OQS_SIG_H diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/sig_cross.h b/prebuilt_liboqs/linux-aarch64/include/oqs/sig_cross.h deleted file mode 100644 index 2832622..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/sig_cross.h +++ /dev/null @@ -1,242 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_SIG_CROSS_H -#define OQS_SIG_CROSS_H - -#include - -#if defined(OQS_ENABLE_SIG_cross_rsdp_128_balanced) -#define OQS_SIG_cross_rsdp_128_balanced_length_public_key 77 -#define OQS_SIG_cross_rsdp_128_balanced_length_secret_key 32 -#define OQS_SIG_cross_rsdp_128_balanced_length_signature 13152 - -OQS_SIG *OQS_SIG_cross_rsdp_128_balanced_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_balanced_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_balanced_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_balanced_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_balanced_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_balanced_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdp_128_fast) -#define OQS_SIG_cross_rsdp_128_fast_length_public_key 77 -#define OQS_SIG_cross_rsdp_128_fast_length_secret_key 32 -#define OQS_SIG_cross_rsdp_128_fast_length_signature 18432 - -OQS_SIG *OQS_SIG_cross_rsdp_128_fast_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_fast_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_fast_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_fast_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_fast_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_fast_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdp_128_small) -#define OQS_SIG_cross_rsdp_128_small_length_public_key 77 -#define OQS_SIG_cross_rsdp_128_small_length_secret_key 32 -#define OQS_SIG_cross_rsdp_128_small_length_signature 12432 - -OQS_SIG *OQS_SIG_cross_rsdp_128_small_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_small_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_small_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_small_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_small_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_small_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdp_192_balanced) -#define OQS_SIG_cross_rsdp_192_balanced_length_public_key 115 -#define OQS_SIG_cross_rsdp_192_balanced_length_secret_key 48 -#define OQS_SIG_cross_rsdp_192_balanced_length_signature 29853 - -OQS_SIG *OQS_SIG_cross_rsdp_192_balanced_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_balanced_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_balanced_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_balanced_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_balanced_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_balanced_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdp_192_fast) -#define OQS_SIG_cross_rsdp_192_fast_length_public_key 115 -#define OQS_SIG_cross_rsdp_192_fast_length_secret_key 48 -#define OQS_SIG_cross_rsdp_192_fast_length_signature 41406 - -OQS_SIG *OQS_SIG_cross_rsdp_192_fast_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_fast_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_fast_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_fast_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_fast_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_fast_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdp_192_small) -#define OQS_SIG_cross_rsdp_192_small_length_public_key 115 -#define OQS_SIG_cross_rsdp_192_small_length_secret_key 48 -#define OQS_SIG_cross_rsdp_192_small_length_signature 28391 - -OQS_SIG *OQS_SIG_cross_rsdp_192_small_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_small_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_small_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_small_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_small_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_small_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdp_256_balanced) -#define OQS_SIG_cross_rsdp_256_balanced_length_public_key 153 -#define OQS_SIG_cross_rsdp_256_balanced_length_secret_key 64 -#define OQS_SIG_cross_rsdp_256_balanced_length_signature 53527 - -OQS_SIG *OQS_SIG_cross_rsdp_256_balanced_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_balanced_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_balanced_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_balanced_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_balanced_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_balanced_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdp_256_fast) -#define OQS_SIG_cross_rsdp_256_fast_length_public_key 153 -#define OQS_SIG_cross_rsdp_256_fast_length_secret_key 64 -#define OQS_SIG_cross_rsdp_256_fast_length_signature 74590 - -OQS_SIG *OQS_SIG_cross_rsdp_256_fast_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_fast_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_fast_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_fast_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_fast_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_fast_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdp_256_small) -#define OQS_SIG_cross_rsdp_256_small_length_public_key 153 -#define OQS_SIG_cross_rsdp_256_small_length_secret_key 64 -#define OQS_SIG_cross_rsdp_256_small_length_signature 50818 - -OQS_SIG *OQS_SIG_cross_rsdp_256_small_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_small_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_small_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_small_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_small_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_small_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdpg_128_balanced) -#define OQS_SIG_cross_rsdpg_128_balanced_length_public_key 54 -#define OQS_SIG_cross_rsdpg_128_balanced_length_secret_key 32 -#define OQS_SIG_cross_rsdpg_128_balanced_length_signature 9120 - -OQS_SIG *OQS_SIG_cross_rsdpg_128_balanced_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_balanced_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_balanced_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_balanced_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_balanced_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_balanced_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdpg_128_fast) -#define OQS_SIG_cross_rsdpg_128_fast_length_public_key 54 -#define OQS_SIG_cross_rsdpg_128_fast_length_secret_key 32 -#define OQS_SIG_cross_rsdpg_128_fast_length_signature 11980 - -OQS_SIG *OQS_SIG_cross_rsdpg_128_fast_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_fast_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_fast_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_fast_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_fast_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_fast_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdpg_128_small) -#define OQS_SIG_cross_rsdpg_128_small_length_public_key 54 -#define OQS_SIG_cross_rsdpg_128_small_length_secret_key 32 -#define OQS_SIG_cross_rsdpg_128_small_length_signature 8960 - -OQS_SIG *OQS_SIG_cross_rsdpg_128_small_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_small_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_small_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_small_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_small_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_small_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdpg_192_balanced) -#define OQS_SIG_cross_rsdpg_192_balanced_length_public_key 83 -#define OQS_SIG_cross_rsdpg_192_balanced_length_secret_key 48 -#define OQS_SIG_cross_rsdpg_192_balanced_length_signature 22464 - -OQS_SIG *OQS_SIG_cross_rsdpg_192_balanced_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_balanced_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_balanced_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_balanced_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_balanced_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_balanced_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdpg_192_fast) -#define OQS_SIG_cross_rsdpg_192_fast_length_public_key 83 -#define OQS_SIG_cross_rsdpg_192_fast_length_secret_key 48 -#define OQS_SIG_cross_rsdpg_192_fast_length_signature 26772 - -OQS_SIG *OQS_SIG_cross_rsdpg_192_fast_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_fast_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_fast_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_fast_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_fast_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_fast_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdpg_192_small) -#define OQS_SIG_cross_rsdpg_192_small_length_public_key 83 -#define OQS_SIG_cross_rsdpg_192_small_length_secret_key 48 -#define OQS_SIG_cross_rsdpg_192_small_length_signature 20452 - -OQS_SIG *OQS_SIG_cross_rsdpg_192_small_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_small_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_small_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_small_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_small_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_small_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdpg_256_balanced) -#define OQS_SIG_cross_rsdpg_256_balanced_length_public_key 106 -#define OQS_SIG_cross_rsdpg_256_balanced_length_secret_key 64 -#define OQS_SIG_cross_rsdpg_256_balanced_length_signature 40100 - -OQS_SIG *OQS_SIG_cross_rsdpg_256_balanced_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_balanced_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_balanced_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_balanced_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_balanced_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_balanced_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdpg_256_fast) -#define OQS_SIG_cross_rsdpg_256_fast_length_public_key 106 -#define OQS_SIG_cross_rsdpg_256_fast_length_secret_key 64 -#define OQS_SIG_cross_rsdpg_256_fast_length_signature 48102 - -OQS_SIG *OQS_SIG_cross_rsdpg_256_fast_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_fast_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_fast_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_fast_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_fast_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_fast_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdpg_256_small) -#define OQS_SIG_cross_rsdpg_256_small_length_public_key 106 -#define OQS_SIG_cross_rsdpg_256_small_length_secret_key 64 -#define OQS_SIG_cross_rsdpg_256_small_length_signature 36454 - -OQS_SIG *OQS_SIG_cross_rsdpg_256_small_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_small_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_small_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_small_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_small_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_small_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#endif diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/sig_falcon.h b/prebuilt_liboqs/linux-aarch64/include/oqs/sig_falcon.h deleted file mode 100644 index 1721fe1..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/sig_falcon.h +++ /dev/null @@ -1,60 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_SIG_FALCON_H -#define OQS_SIG_FALCON_H - -#include - -#if defined(OQS_ENABLE_SIG_falcon_512) -#define OQS_SIG_falcon_512_length_public_key 897 -#define OQS_SIG_falcon_512_length_secret_key 1281 -#define OQS_SIG_falcon_512_length_signature 752 - -OQS_SIG *OQS_SIG_falcon_512_new(void); -OQS_API OQS_STATUS OQS_SIG_falcon_512_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_falcon_512_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_falcon_512_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_falcon_512_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_falcon_512_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_falcon_1024) -#define OQS_SIG_falcon_1024_length_public_key 1793 -#define OQS_SIG_falcon_1024_length_secret_key 2305 -#define OQS_SIG_falcon_1024_length_signature 1462 - -OQS_SIG *OQS_SIG_falcon_1024_new(void); -OQS_API OQS_STATUS OQS_SIG_falcon_1024_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_falcon_1024_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_falcon_1024_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_falcon_1024_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_falcon_1024_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_falcon_padded_512) -#define OQS_SIG_falcon_padded_512_length_public_key 897 -#define OQS_SIG_falcon_padded_512_length_secret_key 1281 -#define OQS_SIG_falcon_padded_512_length_signature 666 - -OQS_SIG *OQS_SIG_falcon_padded_512_new(void); -OQS_API OQS_STATUS OQS_SIG_falcon_padded_512_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_falcon_padded_512_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_falcon_padded_512_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_falcon_padded_512_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_falcon_padded_512_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_falcon_padded_1024) -#define OQS_SIG_falcon_padded_1024_length_public_key 1793 -#define OQS_SIG_falcon_padded_1024_length_secret_key 2305 -#define OQS_SIG_falcon_padded_1024_length_signature 1280 - -OQS_SIG *OQS_SIG_falcon_padded_1024_new(void); -OQS_API OQS_STATUS OQS_SIG_falcon_padded_1024_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_falcon_padded_1024_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_falcon_padded_1024_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_falcon_padded_1024_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_falcon_padded_1024_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#endif diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/sig_mayo.h b/prebuilt_liboqs/linux-aarch64/include/oqs/sig_mayo.h deleted file mode 100644 index 237492e..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/sig_mayo.h +++ /dev/null @@ -1,60 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_SIG_MAYO_H -#define OQS_SIG_MAYO_H - -#include - -#if defined(OQS_ENABLE_SIG_mayo_1) -#define OQS_SIG_mayo_1_length_public_key 1420 -#define OQS_SIG_mayo_1_length_secret_key 24 -#define OQS_SIG_mayo_1_length_signature 454 - -OQS_SIG *OQS_SIG_mayo_1_new(void); -OQS_API OQS_STATUS OQS_SIG_mayo_1_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_mayo_1_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_mayo_1_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_mayo_1_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_mayo_1_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_mayo_2) -#define OQS_SIG_mayo_2_length_public_key 4912 -#define OQS_SIG_mayo_2_length_secret_key 24 -#define OQS_SIG_mayo_2_length_signature 186 - -OQS_SIG *OQS_SIG_mayo_2_new(void); -OQS_API OQS_STATUS OQS_SIG_mayo_2_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_mayo_2_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_mayo_2_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_mayo_2_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_mayo_2_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_mayo_3) -#define OQS_SIG_mayo_3_length_public_key 2986 -#define OQS_SIG_mayo_3_length_secret_key 32 -#define OQS_SIG_mayo_3_length_signature 681 - -OQS_SIG *OQS_SIG_mayo_3_new(void); -OQS_API OQS_STATUS OQS_SIG_mayo_3_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_mayo_3_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_mayo_3_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_mayo_3_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_mayo_3_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_mayo_5) -#define OQS_SIG_mayo_5_length_public_key 5554 -#define OQS_SIG_mayo_5_length_secret_key 40 -#define OQS_SIG_mayo_5_length_signature 964 - -OQS_SIG *OQS_SIG_mayo_5_new(void); -OQS_API OQS_STATUS OQS_SIG_mayo_5_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_mayo_5_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_mayo_5_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_mayo_5_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_mayo_5_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#endif diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/sig_ml_dsa.h b/prebuilt_liboqs/linux-aarch64/include/oqs/sig_ml_dsa.h deleted file mode 100644 index e5f00f4..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/sig_ml_dsa.h +++ /dev/null @@ -1,47 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_SIG_ML_DSA_H -#define OQS_SIG_ML_DSA_H - -#include - -#if defined(OQS_ENABLE_SIG_ml_dsa_44) -#define OQS_SIG_ml_dsa_44_length_public_key 1312 -#define OQS_SIG_ml_dsa_44_length_secret_key 2560 -#define OQS_SIG_ml_dsa_44_length_signature 2420 - -OQS_SIG *OQS_SIG_ml_dsa_44_new(void); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_44_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_44_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_44_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_44_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_44_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_ml_dsa_65) -#define OQS_SIG_ml_dsa_65_length_public_key 1952 -#define OQS_SIG_ml_dsa_65_length_secret_key 4032 -#define OQS_SIG_ml_dsa_65_length_signature 3309 - -OQS_SIG *OQS_SIG_ml_dsa_65_new(void); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_65_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_65_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_65_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_65_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_65_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_ml_dsa_87) -#define OQS_SIG_ml_dsa_87_length_public_key 2592 -#define OQS_SIG_ml_dsa_87_length_secret_key 4896 -#define OQS_SIG_ml_dsa_87_length_signature 4627 - -OQS_SIG *OQS_SIG_ml_dsa_87_new(void); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_87_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_87_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_87_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_87_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_87_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#endif diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/sig_slh_dsa.h b/prebuilt_liboqs/linux-aarch64/include/oqs/sig_slh_dsa.h deleted file mode 100644 index f56ee2e..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/sig_slh_dsa.h +++ /dev/null @@ -1,2192 +0,0 @@ - -// SPDX-License-Identifier: MIT - -#ifndef OQS_SIG_SLH_DSA_H -#define OQS_SIG_SLH_DSA_H - -#include - -#if defined(OQS_ENABLE_SIG_slh_dsa_pure_sha2_128s) -#define OQS_SIG_slh_dsa_pure_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_pure_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_pure_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_pure_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_pure_shake_128s) -#define OQS_SIG_slh_dsa_pure_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_pure_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_pure_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_pure_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_pure_sha2_128f) -#define OQS_SIG_slh_dsa_pure_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_pure_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_pure_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_pure_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_pure_shake_128f) -#define OQS_SIG_slh_dsa_pure_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_pure_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_pure_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_pure_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_pure_sha2_192s) -#define OQS_SIG_slh_dsa_pure_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_pure_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_pure_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_pure_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_pure_shake_192s) -#define OQS_SIG_slh_dsa_pure_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_pure_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_pure_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_pure_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_pure_sha2_192f) -#define OQS_SIG_slh_dsa_pure_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_pure_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_pure_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_pure_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_pure_shake_192f) -#define OQS_SIG_slh_dsa_pure_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_pure_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_pure_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_pure_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_pure_sha2_256s) -#define OQS_SIG_slh_dsa_pure_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_pure_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_pure_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_pure_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_pure_shake_256s) -#define OQS_SIG_slh_dsa_pure_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_pure_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_pure_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_pure_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_pure_sha2_256f) -#define OQS_SIG_slh_dsa_pure_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_pure_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_pure_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_pure_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_pure_shake_256f) -#define OQS_SIG_slh_dsa_pure_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_pure_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_pure_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_pure_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_128s) -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_128s) -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_128s) -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_128s) -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s) -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_128s) -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_128s) -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_128s) -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_128s) -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_128s) -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_128s) -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_shake_128_prehash_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_128s) -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_shake_256_prehash_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_128s) -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_128s) -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_128s) -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_128s) -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_128s) -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_128s) -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_128s) -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_224_prehash_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_128s) -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_256_prehash_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_128s) -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_384_prehash_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_128s) -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_512_prehash_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_128s) -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_shake_128_prehash_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_128s) -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_shake_256_prehash_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_128f) -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_128f) -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_128f) -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_128f) -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f) -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f) -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_128f) -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_128f) -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_128f) -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_128f) -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_128f) -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_shake_128_prehash_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_128f) -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_shake_256_prehash_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_128f) -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_128f) -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_128f) -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_128f) -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_128f) -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_128f) -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_128f) -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_224_prehash_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_128f) -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_256_prehash_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_128f) -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_384_prehash_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_128f) -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_512_prehash_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_128f) -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_shake_128_prehash_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_128f) -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_shake_256_prehash_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_192s) -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_192s) -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_192s) -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_192s) -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s) -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_192s) -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_192s) -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_192s) -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_192s) -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_192s) -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_192s) -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_shake_128_prehash_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_192s) -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_shake_256_prehash_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_192s) -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_192s) -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_192s) -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_192s) -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_192s) -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_192s) -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_192s) -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_224_prehash_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_192s) -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_256_prehash_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_192s) -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_384_prehash_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_192s) -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_512_prehash_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_192s) -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_shake_128_prehash_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_192s) -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_shake_256_prehash_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_192f) -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_192f) -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_192f) -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_192f) -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f) -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_192f) -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_192f) -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_192f) -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_192f) -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_192f) -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_192f) -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_shake_128_prehash_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_192f) -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_shake_256_prehash_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_192f) -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_192f) -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_192f) -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_192f) -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_192f) -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_192f) -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_192f) -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_224_prehash_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_192f) -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_256_prehash_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_192f) -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_384_prehash_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_192f) -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_512_prehash_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_192f) -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_shake_128_prehash_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_192f) -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_shake_256_prehash_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_256s) -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_256s) -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_256s) -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_256s) -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s) -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_256s) -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_256s) -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_256s) -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_256s) -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_256s) -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_256s) -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_shake_128_prehash_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_256s) -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_shake_256_prehash_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_256s) -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_256s) -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_256s) -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_256s) -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_256s) -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_256s) -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_256s) -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_224_prehash_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_256s) -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_256_prehash_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_256s) -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_384_prehash_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_256s) -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_512_prehash_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_256s) -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_shake_128_prehash_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_256s) -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_shake_256_prehash_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_256f) -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_256f) -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_256f) -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_256f) -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f) -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_256f) -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_256f) -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_256f) -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_256f) -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_256f) -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_256f) -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_shake_128_prehash_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_256f) -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_shake_256_prehash_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_256f) -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_256f) -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_256f) -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_256f) -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_256f) -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_256f) -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_256f) -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_224_prehash_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_256f) -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_256_prehash_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_256f) -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_384_prehash_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_256f) -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_512_prehash_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_256f) -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_shake_128_prehash_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_256f) -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_shake_256_prehash_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#endif diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/sig_snova.h b/prebuilt_liboqs/linux-aarch64/include/oqs/sig_snova.h deleted file mode 100644 index 55243ed..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/sig_snova.h +++ /dev/null @@ -1,164 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_SIG_SNOVA_H -#define OQS_SIG_SNOVA_H - -#include - -#if defined(OQS_ENABLE_SIG_snova_SNOVA_24_5_4) -#define OQS_SIG_snova_SNOVA_24_5_4_length_public_key 1016 -#define OQS_SIG_snova_SNOVA_24_5_4_length_secret_key 48 -#define OQS_SIG_snova_SNOVA_24_5_4_length_signature 248 - -OQS_SIG *OQS_SIG_snova_SNOVA_24_5_4_new(void); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_snova_SNOVA_24_5_4_SHAKE) -#define OQS_SIG_snova_SNOVA_24_5_4_SHAKE_length_public_key 1016 -#define OQS_SIG_snova_SNOVA_24_5_4_SHAKE_length_secret_key 48 -#define OQS_SIG_snova_SNOVA_24_5_4_SHAKE_length_signature 248 - -OQS_SIG *OQS_SIG_snova_SNOVA_24_5_4_SHAKE_new(void); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_SHAKE_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_SHAKE_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_SHAKE_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_SHAKE_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_SHAKE_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_snova_SNOVA_24_5_4_esk) -#define OQS_SIG_snova_SNOVA_24_5_4_esk_length_public_key 1016 -#define OQS_SIG_snova_SNOVA_24_5_4_esk_length_secret_key 36848 -#define OQS_SIG_snova_SNOVA_24_5_4_esk_length_signature 248 - -OQS_SIG *OQS_SIG_snova_SNOVA_24_5_4_esk_new(void); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_esk_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_esk_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_esk_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_esk_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_esk_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_snova_SNOVA_24_5_4_SHAKE_esk) -#define OQS_SIG_snova_SNOVA_24_5_4_SHAKE_esk_length_public_key 1016 -#define OQS_SIG_snova_SNOVA_24_5_4_SHAKE_esk_length_secret_key 36848 -#define OQS_SIG_snova_SNOVA_24_5_4_SHAKE_esk_length_signature 248 - -OQS_SIG *OQS_SIG_snova_SNOVA_24_5_4_SHAKE_esk_new(void); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_SHAKE_esk_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_SHAKE_esk_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_SHAKE_esk_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_SHAKE_esk_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_SHAKE_esk_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_snova_SNOVA_37_17_2) -#define OQS_SIG_snova_SNOVA_37_17_2_length_public_key 9842 -#define OQS_SIG_snova_SNOVA_37_17_2_length_secret_key 48 -#define OQS_SIG_snova_SNOVA_37_17_2_length_signature 124 - -OQS_SIG *OQS_SIG_snova_SNOVA_37_17_2_new(void); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_37_17_2_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_37_17_2_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_37_17_2_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_37_17_2_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_37_17_2_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_snova_SNOVA_25_8_3) -#define OQS_SIG_snova_SNOVA_25_8_3_length_public_key 2320 -#define OQS_SIG_snova_SNOVA_25_8_3_length_secret_key 48 -#define OQS_SIG_snova_SNOVA_25_8_3_length_signature 165 - -OQS_SIG *OQS_SIG_snova_SNOVA_25_8_3_new(void); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_25_8_3_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_25_8_3_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_25_8_3_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_25_8_3_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_25_8_3_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_snova_SNOVA_56_25_2) -#define OQS_SIG_snova_SNOVA_56_25_2_length_public_key 31266 -#define OQS_SIG_snova_SNOVA_56_25_2_length_secret_key 48 -#define OQS_SIG_snova_SNOVA_56_25_2_length_signature 178 - -OQS_SIG *OQS_SIG_snova_SNOVA_56_25_2_new(void); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_56_25_2_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_56_25_2_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_56_25_2_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_56_25_2_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_56_25_2_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_snova_SNOVA_49_11_3) -#define OQS_SIG_snova_SNOVA_49_11_3_length_public_key 6006 -#define OQS_SIG_snova_SNOVA_49_11_3_length_secret_key 48 -#define OQS_SIG_snova_SNOVA_49_11_3_length_signature 286 - -OQS_SIG *OQS_SIG_snova_SNOVA_49_11_3_new(void); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_49_11_3_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_49_11_3_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_49_11_3_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_49_11_3_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_49_11_3_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_snova_SNOVA_37_8_4) -#define OQS_SIG_snova_SNOVA_37_8_4_length_public_key 4112 -#define OQS_SIG_snova_SNOVA_37_8_4_length_secret_key 48 -#define OQS_SIG_snova_SNOVA_37_8_4_length_signature 376 - -OQS_SIG *OQS_SIG_snova_SNOVA_37_8_4_new(void); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_37_8_4_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_37_8_4_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_37_8_4_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_37_8_4_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_37_8_4_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_snova_SNOVA_24_5_5) -#define OQS_SIG_snova_SNOVA_24_5_5_length_public_key 1579 -#define OQS_SIG_snova_SNOVA_24_5_5_length_secret_key 48 -#define OQS_SIG_snova_SNOVA_24_5_5_length_signature 379 - -OQS_SIG *OQS_SIG_snova_SNOVA_24_5_5_new(void); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_5_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_5_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_5_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_5_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_5_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_snova_SNOVA_60_10_4) -#define OQS_SIG_snova_SNOVA_60_10_4_length_public_key 8016 -#define OQS_SIG_snova_SNOVA_60_10_4_length_secret_key 48 -#define OQS_SIG_snova_SNOVA_60_10_4_length_signature 576 - -OQS_SIG *OQS_SIG_snova_SNOVA_60_10_4_new(void); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_60_10_4_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_60_10_4_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_60_10_4_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_60_10_4_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_60_10_4_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_snova_SNOVA_29_6_5) -#define OQS_SIG_snova_SNOVA_29_6_5_length_public_key 2716 -#define OQS_SIG_snova_SNOVA_29_6_5_length_secret_key 48 -#define OQS_SIG_snova_SNOVA_29_6_5_length_signature 454 - -OQS_SIG *OQS_SIG_snova_SNOVA_29_6_5_new(void); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_29_6_5_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_29_6_5_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_29_6_5_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_29_6_5_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_29_6_5_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#endif diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/sig_sphincs.h b/prebuilt_liboqs/linux-aarch64/include/oqs/sig_sphincs.h deleted file mode 100644 index 5b3e4f9..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/sig_sphincs.h +++ /dev/null @@ -1,164 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_SIG_SPHINCS_H -#define OQS_SIG_SPHINCS_H - -#include - -#if defined(OQS_ENABLE_SIG_sphincs_sha2_128f_simple) -#define OQS_SIG_sphincs_sha2_128f_simple_length_public_key 32 -#define OQS_SIG_sphincs_sha2_128f_simple_length_secret_key 64 -#define OQS_SIG_sphincs_sha2_128f_simple_length_signature 17088 - -OQS_SIG *OQS_SIG_sphincs_sha2_128f_simple_new(void); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_128f_simple_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_128f_simple_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_128f_simple_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_128f_simple_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_128f_simple_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_sphincs_sha2_128s_simple) -#define OQS_SIG_sphincs_sha2_128s_simple_length_public_key 32 -#define OQS_SIG_sphincs_sha2_128s_simple_length_secret_key 64 -#define OQS_SIG_sphincs_sha2_128s_simple_length_signature 7856 - -OQS_SIG *OQS_SIG_sphincs_sha2_128s_simple_new(void); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_128s_simple_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_128s_simple_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_128s_simple_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_128s_simple_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_128s_simple_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_sphincs_sha2_192f_simple) -#define OQS_SIG_sphincs_sha2_192f_simple_length_public_key 48 -#define OQS_SIG_sphincs_sha2_192f_simple_length_secret_key 96 -#define OQS_SIG_sphincs_sha2_192f_simple_length_signature 35664 - -OQS_SIG *OQS_SIG_sphincs_sha2_192f_simple_new(void); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_192f_simple_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_192f_simple_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_192f_simple_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_192f_simple_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_192f_simple_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_sphincs_sha2_192s_simple) -#define OQS_SIG_sphincs_sha2_192s_simple_length_public_key 48 -#define OQS_SIG_sphincs_sha2_192s_simple_length_secret_key 96 -#define OQS_SIG_sphincs_sha2_192s_simple_length_signature 16224 - -OQS_SIG *OQS_SIG_sphincs_sha2_192s_simple_new(void); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_192s_simple_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_192s_simple_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_192s_simple_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_192s_simple_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_192s_simple_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_sphincs_sha2_256f_simple) -#define OQS_SIG_sphincs_sha2_256f_simple_length_public_key 64 -#define OQS_SIG_sphincs_sha2_256f_simple_length_secret_key 128 -#define OQS_SIG_sphincs_sha2_256f_simple_length_signature 49856 - -OQS_SIG *OQS_SIG_sphincs_sha2_256f_simple_new(void); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_256f_simple_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_256f_simple_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_256f_simple_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_256f_simple_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_256f_simple_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_sphincs_sha2_256s_simple) -#define OQS_SIG_sphincs_sha2_256s_simple_length_public_key 64 -#define OQS_SIG_sphincs_sha2_256s_simple_length_secret_key 128 -#define OQS_SIG_sphincs_sha2_256s_simple_length_signature 29792 - -OQS_SIG *OQS_SIG_sphincs_sha2_256s_simple_new(void); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_256s_simple_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_256s_simple_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_256s_simple_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_256s_simple_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_256s_simple_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_sphincs_shake_128f_simple) -#define OQS_SIG_sphincs_shake_128f_simple_length_public_key 32 -#define OQS_SIG_sphincs_shake_128f_simple_length_secret_key 64 -#define OQS_SIG_sphincs_shake_128f_simple_length_signature 17088 - -OQS_SIG *OQS_SIG_sphincs_shake_128f_simple_new(void); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_128f_simple_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_128f_simple_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_128f_simple_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_128f_simple_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_128f_simple_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_sphincs_shake_128s_simple) -#define OQS_SIG_sphincs_shake_128s_simple_length_public_key 32 -#define OQS_SIG_sphincs_shake_128s_simple_length_secret_key 64 -#define OQS_SIG_sphincs_shake_128s_simple_length_signature 7856 - -OQS_SIG *OQS_SIG_sphincs_shake_128s_simple_new(void); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_128s_simple_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_128s_simple_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_128s_simple_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_128s_simple_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_128s_simple_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_sphincs_shake_192f_simple) -#define OQS_SIG_sphincs_shake_192f_simple_length_public_key 48 -#define OQS_SIG_sphincs_shake_192f_simple_length_secret_key 96 -#define OQS_SIG_sphincs_shake_192f_simple_length_signature 35664 - -OQS_SIG *OQS_SIG_sphincs_shake_192f_simple_new(void); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_192f_simple_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_192f_simple_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_192f_simple_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_192f_simple_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_192f_simple_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_sphincs_shake_192s_simple) -#define OQS_SIG_sphincs_shake_192s_simple_length_public_key 48 -#define OQS_SIG_sphincs_shake_192s_simple_length_secret_key 96 -#define OQS_SIG_sphincs_shake_192s_simple_length_signature 16224 - -OQS_SIG *OQS_SIG_sphincs_shake_192s_simple_new(void); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_192s_simple_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_192s_simple_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_192s_simple_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_192s_simple_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_192s_simple_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_sphincs_shake_256f_simple) -#define OQS_SIG_sphincs_shake_256f_simple_length_public_key 64 -#define OQS_SIG_sphincs_shake_256f_simple_length_secret_key 128 -#define OQS_SIG_sphincs_shake_256f_simple_length_signature 49856 - -OQS_SIG *OQS_SIG_sphincs_shake_256f_simple_new(void); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_256f_simple_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_256f_simple_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_256f_simple_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_256f_simple_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_256f_simple_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_sphincs_shake_256s_simple) -#define OQS_SIG_sphincs_shake_256s_simple_length_public_key 64 -#define OQS_SIG_sphincs_shake_256s_simple_length_secret_key 128 -#define OQS_SIG_sphincs_shake_256s_simple_length_signature 29792 - -OQS_SIG *OQS_SIG_sphincs_shake_256s_simple_new(void); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_256s_simple_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_256s_simple_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_256s_simple_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_256s_simple_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_256s_simple_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#endif diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/sig_stfl.h b/prebuilt_liboqs/linux-aarch64/include/oqs/sig_stfl.h deleted file mode 100644 index 8e81df4..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/sig_stfl.h +++ /dev/null @@ -1,740 +0,0 @@ -/** - * \file sig_stfl.h - * \brief Stateful Signature schemes - * - * The file `tests/example_sig_stfl.c` contains an example on using the OQS_SIG_STFL API. - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_SIG_STATEFUL_H -#define OQS_SIG_STATEFUL_H - -#include -#include -#include - -#include - -/* - * Developer's Notes: - * Stateful signatures are based on the one-time use of a secret key. A pool of secret keys is created for this purpose. - * The state of these keys is tracked to ensure that they are used only once to generate a signature. - * - * As such, product-specific environments do play a role in ensuring the safety of the keys. - * Secret keys must be stored securely. - * The key index/counter must be updated after each signature generation. - * The secret key must be protected in a thread-safe manner. - * - * Applications therefore are required to provide environment-specific callback functions to - * - store private key - * - lock/unlock private key - * - * See below for details - * OQS_SIG_STFL_SECRET_KEY_SET_lock - * OQS_SIG_STFL_SECRET_KEY_SET_unlock - * OQS_SIG_STFL_SECRET_KEY_SET_mutex - * OQS_SIG_STFL_SECRET_KEY_SET_store_cb - * - */ - -#if defined(__cplusplus) -extern "C" -{ -#endif - -/** Algorithm identifier for XMSS-SHA2_10_256 */ -#define OQS_SIG_STFL_alg_xmss_sha256_h10 "XMSS-SHA2_10_256" -/** Algorithm identifier for XMSS-SHA2_16_256 */ -#define OQS_SIG_STFL_alg_xmss_sha256_h16 "XMSS-SHA2_16_256" -/** Algorithm identifier for XMSS-SHA2_20_256 */ -#define OQS_SIG_STFL_alg_xmss_sha256_h20 "XMSS-SHA2_20_256" -/** Algorithm identifier for XMSS-SHAKE_10_256 */ -#define OQS_SIG_STFL_alg_xmss_shake128_h10 "XMSS-SHAKE_10_256" -/** Algorithm identifier for XMSS-SHAKE_16_256 */ -#define OQS_SIG_STFL_alg_xmss_shake128_h16 "XMSS-SHAKE_16_256" -/** Algorithm identifier for XMSS-SHAKE_20_256 */ -#define OQS_SIG_STFL_alg_xmss_shake128_h20 "XMSS-SHAKE_20_256" -/** Algorithm identifier for XMSS-SHA2_10_512 */ -#define OQS_SIG_STFL_alg_xmss_sha512_h10 "XMSS-SHA2_10_512" -/** Algorithm identifier for XMSS-SHA2_16_512 */ -#define OQS_SIG_STFL_alg_xmss_sha512_h16 "XMSS-SHA2_16_512" -/** Algorithm identifier for XMSS-SHA2_20_512 */ -#define OQS_SIG_STFL_alg_xmss_sha512_h20 "XMSS-SHA2_20_512" -/** Algorithm identifier for XMSS-SHAKE_10_512 */ -#define OQS_SIG_STFL_alg_xmss_shake256_h10 "XMSS-SHAKE_10_512" -/** Algorithm identifier for XMSS-SHAKE_16_512 */ -#define OQS_SIG_STFL_alg_xmss_shake256_h16 "XMSS-SHAKE_16_512" -/** Algorithm identifier for XMSS-SHAKE_20_512 */ -#define OQS_SIG_STFL_alg_xmss_shake256_h20 "XMSS-SHAKE_20_512" -/** Algorithm identifier for XMSS-SHA2_10_192 */ -#define OQS_SIG_STFL_alg_xmss_sha256_h10_192 "XMSS-SHA2_10_192" -/** Algorithm identifier for XMSS-SHA2_16_192 */ -#define OQS_SIG_STFL_alg_xmss_sha256_h16_192 "XMSS-SHA2_16_192" -/** Algorithm identifier for XMSS-SHA2_20_192 */ -#define OQS_SIG_STFL_alg_xmss_sha256_h20_192 "XMSS-SHA2_20_192" -/** Algorithm identifier for XMSS-SHAKE256_10_192 */ -#define OQS_SIG_STFL_alg_xmss_shake256_h10_192 "XMSS-SHAKE256_10_192" -/** Algorithm identifier for XMSS-SHAKE256_16_192 */ -#define OQS_SIG_STFL_alg_xmss_shake256_h16_192 "XMSS-SHAKE256_16_192" -/** Algorithm identifier for XMSS-SHAKE256_20_192 */ -#define OQS_SIG_STFL_alg_xmss_shake256_h20_192 "XMSS-SHAKE256_20_192" -/** Algorithm identifier for XMSS-SHAKE256_10_256 */ -#define OQS_SIG_STFL_alg_xmss_shake256_h10_256 "XMSS-SHAKE256_10_256" -/** Algorithm identifier for XMSS-SHAKE256_16_256 */ -#define OQS_SIG_STFL_alg_xmss_shake256_h16_256 "XMSS-SHAKE256_16_256" -/** Algorithm identifier for XMSS-SHAKE256_20_256 */ -#define OQS_SIG_STFL_alg_xmss_shake256_h20_256 "XMSS-SHAKE256_20_256" - -/** Algorithm identifier for XMSSMT-SHA2_20/2_256 */ -#define OQS_SIG_STFL_alg_xmssmt_sha256_h20_2 "XMSSMT-SHA2_20/2_256" -/** Algorithm identifier for XMSSMT-SHA2_20/4_256 */ -#define OQS_SIG_STFL_alg_xmssmt_sha256_h20_4 "XMSSMT-SHA2_20/4_256" -/** Algorithm identifier for XMSSMT-SHA2_40/2_256 */ -#define OQS_SIG_STFL_alg_xmssmt_sha256_h40_2 "XMSSMT-SHA2_40/2_256" -/** Algorithm identifier for XMSSMT-SHA2_40/4_256 */ -#define OQS_SIG_STFL_alg_xmssmt_sha256_h40_4 "XMSSMT-SHA2_40/4_256" -/** Algorithm identifier for XMSSMT-SHA2_40/8_256 */ -#define OQS_SIG_STFL_alg_xmssmt_sha256_h40_8 "XMSSMT-SHA2_40/8_256" -/** Algorithm identifier for XMSSMT-SHA2_60/3_256 */ -#define OQS_SIG_STFL_alg_xmssmt_sha256_h60_3 "XMSSMT-SHA2_60/3_256" -/** Algorithm identifier for XMSSMT-SHA2_60/6_256 */ -#define OQS_SIG_STFL_alg_xmssmt_sha256_h60_6 "XMSSMT-SHA2_60/6_256" -/** Algorithm identifier for XMSSMT-SHA2_60/12_256 */ -#define OQS_SIG_STFL_alg_xmssmt_sha256_h60_12 "XMSSMT-SHA2_60/12_256" -/** Algorithm identifier for XMSSMT-SHAKE_20/2_256 */ -#define OQS_SIG_STFL_alg_xmssmt_shake128_h20_2 "XMSSMT-SHAKE_20/2_256" -/** Algorithm identifier for XMSSMT-SHAKE_20/4_256 */ -#define OQS_SIG_STFL_alg_xmssmt_shake128_h20_4 "XMSSMT-SHAKE_20/4_256" -/** Algorithm identifier for XMSSMT-SHAKE_40/2_256 */ -#define OQS_SIG_STFL_alg_xmssmt_shake128_h40_2 "XMSSMT-SHAKE_40/2_256" -/** Algorithm identifier for XMSSMT-SHAKE_40/4_256 */ -#define OQS_SIG_STFL_alg_xmssmt_shake128_h40_4 "XMSSMT-SHAKE_40/4_256" -/** Algorithm identifier for XMSSMT-SHAKE_40/8_256 */ -#define OQS_SIG_STFL_alg_xmssmt_shake128_h40_8 "XMSSMT-SHAKE_40/8_256" -/** Algorithm identifier for XMSSMT-SHAKE_60/3_256 */ -#define OQS_SIG_STFL_alg_xmssmt_shake128_h60_3 "XMSSMT-SHAKE_60/3_256" -/** Algorithm identifier for XMSSMT-SHAKE_60/6_256 */ -#define OQS_SIG_STFL_alg_xmssmt_shake128_h60_6 "XMSSMT-SHAKE_60/6_256" -/** Algorithm identifier for XMSSMT-SHAKE_60/12_256 */ -#define OQS_SIG_STFL_alg_xmssmt_shake128_h60_12 "XMSSMT-SHAKE_60/12_256" - -/* Defined LMS parameter identifiers */ -/** Algorithm identifier for LMS-SHA256_H5_W1 */ -#define OQS_SIG_STFL_alg_lms_sha256_h5_w1 "LMS_SHA256_H5_W1" //"5/1" -/** Algorithm identifier for LMS-SHA256_H5_W2 */ -#define OQS_SIG_STFL_alg_lms_sha256_h5_w2 "LMS_SHA256_H5_W2" //"5/2" -/** Algorithm identifier for LMS-SHA256_H5_W4 */ -#define OQS_SIG_STFL_alg_lms_sha256_h5_w4 "LMS_SHA256_H5_W4" //"5/4" -/** Algorithm identifier for LMS-SHA256_H5_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h5_w8 "LMS_SHA256_H5_W8" //"5/8" - -/** Algorithm identifier for LMS-SHA256_H10_W1 */ -#define OQS_SIG_STFL_alg_lms_sha256_h10_w1 "LMS_SHA256_H10_W1" //"10/1" -/** Algorithm identifier for LMS-SHA256_H10_W2 */ -#define OQS_SIG_STFL_alg_lms_sha256_h10_w2 "LMS_SHA256_H10_W2" //"10/2" -/** Algorithm identifier for LMS-SHA256_H10_W4 */ -#define OQS_SIG_STFL_alg_lms_sha256_h10_w4 "LMS_SHA256_H10_W4" //"10/4" -/** Algorithm identifier for LMS-SHA256_H10_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h10_w8 "LMS_SHA256_H10_W8" //"10/8" - -/** Algorithm identifier for LMS-SHA256_H15_W1 */ -#define OQS_SIG_STFL_alg_lms_sha256_h15_w1 "LMS_SHA256_H15_W1" //"15/1" -/** Algorithm identifier for LMS-SHA256_H15_W2 */ -#define OQS_SIG_STFL_alg_lms_sha256_h15_w2 "LMS_SHA256_H15_W2" //"15/2" -/** Algorithm identifier for LMS-SHA256_H15_W4 */ -#define OQS_SIG_STFL_alg_lms_sha256_h15_w4 "LMS_SHA256_H15_W4" //"15/4" -/** Algorithm identifier for LMS-SHA256_H15_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h15_w8 "LMS_SHA256_H15_W8" //"15/8" - -/** Algorithm identifier for LMS-SHA256_H20_W1 */ -#define OQS_SIG_STFL_alg_lms_sha256_h20_w1 "LMS_SHA256_H20_W1" //"20/1" -/** Algorithm identifier for LMS-SHA256_H20_W2 */ -#define OQS_SIG_STFL_alg_lms_sha256_h20_w2 "LMS_SHA256_H20_W2" //"20/2" -/** Algorithm identifier for LMS-SHA256_H20_W4 */ -#define OQS_SIG_STFL_alg_lms_sha256_h20_w4 "LMS_SHA256_H20_W4" //"20/4" -/** Algorithm identifier for LMS-SHA256_H20_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h20_w8 "LMS_SHA256_H20_W8" //"20/8" - -/** Algorithm identifier for LMS-SHA256_H25_W1 */ -#define OQS_SIG_STFL_alg_lms_sha256_h25_w1 "LMS_SHA256_H25_W1" //"25/1" -/** Algorithm identifier for LMS-SHA256_H25_W2 */ -#define OQS_SIG_STFL_alg_lms_sha256_h25_w2 "LMS_SHA256_H25_W2" //"25/2" -/** Algorithm identifier for LMS-SHA256_H25_W4 */ -#define OQS_SIG_STFL_alg_lms_sha256_h25_w4 "LMS_SHA256_H25_W4" //"25/4" -/** Algorithm identifier for LMS-SHA256_H25_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h25_w8 "LMS_SHA256_H25_W8" //"25/8" - -// 2-Level LMS -/** Algorithm identifier for LMS-SHA256_H5_W8_H5_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h5_w8_h5_w8 "LMS_SHA256_H5_W8_H5_W8" //"5/8, 5/8" - -// RFC 6554 -/** Algorithm identifier for LMS-SHA256_H10_W4_H5_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h10_w4_h5_w8 "LMS_SHA256_H10_W4_H5_W8" //"10/4, 5/8" - -/** Algorithm identifier for LMS-SHA256_H10_W8_H5_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h10_w8_h5_w8 "LMS_SHA256_H10_W8_H5_W8" //"10/8, 5/8" -/** Algorithm identifier for LMS-SHA256_H10_W2_H10_W2 */ -#define OQS_SIG_STFL_alg_lms_sha256_h10_w2_h10_w2 "LMS_SHA256_H10_W2_H10_W2" //"10/2, 10/2" -/** Algorithm identifier for LMS-SHA256_H10_W4_H10_W4 */ -#define OQS_SIG_STFL_alg_lms_sha256_h10_w4_h10_w4 "LMS_SHA256_H10_W4_H10_W4" //"10/4, 10/4" -/** Algorithm identifier for LMS-SHA256_H10_W8_H10_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h10_w8_h10_w8 "LMS_SHA256_H10_W8_H10_W8" //"10/8, 10/8" - -/** Algorithm identifier for LMS-SHA256_H15_W8_H5_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h15_w8_h5_w8 "LMS_SHA256_H15_W8_H5_W8" //"15/8, 5/8" -/** Algorithm identifier for LMS-SHA256_H15_W8_H10_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h15_w8_h10_w8 "LMS_SHA256_H15_W8_H10_W8" //"15/8, 10/8" -/** Algorithm identifier for LMS-SHA256_H15_W8_H15_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h15_w8_h15_w8 "LMS_SHA256_H15_W8_H15_W8" //"15/8, 15/8" - -/** Algorithm identifier for LMS-SHA256_H20_W8_H5_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h20_w8_h5_w8 "LMS_SHA256_H20_W8_H5_W8" //"20/8, 5/8" -/** Algorithm identifier for LMS-SHA256_H20_W8_H10_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h20_w8_h10_w8 "LMS_SHA256_H20_W8_H10_W8" //"20/8, 10/8" -/** Algorithm identifier for LMS-SHA256_H20_W8_H15_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h20_w8_h15_w8 "LMS_SHA256_H20_W8_H15_W8" //"20/8, 15/8" -/** Algorithm identifier for LMS-SHA256_H20_W8_H20_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h20_w8_h20_w8 "LMS_SHA256_H20_W8_H20_W8" //"20/8, 20/8" - -/** Total number of stateful variants defined above, used to create the tracking array */ -#define OQS_SIG_STFL_algs_length 70 - -typedef struct OQS_SIG_STFL_SECRET_KEY OQS_SIG_STFL_SECRET_KEY; - -/** - * Application provided function to securely store data - * @param[in] sk_buf pointer to the data to be saved - * @param[in] buf_len length of the data to be stored - * @param[out] context pass back application data related to secret key data storage. - * return OQS_SUCCESS if successful, otherwise OQS_ERROR - */ -typedef OQS_STATUS (*secure_store_sk)(uint8_t *sk_buf, size_t buf_len, void *context); - -/** - * Application provided function to lock secret key object serialize access - * @param[in] mutex pointer to mutex struct - * return OQS_SUCCESS if successful, otherwise OQS_ERROR - */ -typedef OQS_STATUS (*lock_key)(void *mutex); - -/** - * Application provided function to unlock secret key object - * @param[in] mutex pointer to mutex struct - * return OQS_SUCCESS if successful, otherwise OQS_ERROR - */ -typedef OQS_STATUS (*unlock_key)(void *mutex); - -/** - * Returns identifiers for available signature schemes in liboqs. Used with `OQS_SIG_STFL_new`. - * - * Note that algorithm identifiers are present in this list even when the algorithm is disabled - * at compile time. - * - * @param[in] i Index of the algorithm identifier to return, 0 <= i < OQS_SIG_algs_length - * @return Algorithm identifier as a string, or NULL. - */ -OQS_API const char *OQS_SIG_STFL_alg_identifier(size_t i); - -/** - * Returns the number of stateful signature mechanisms in liboqs. They can be enumerated with - * OQS_SIG_STFL_alg_identifier. - * - * Note that some mechanisms may be disabled at compile time. - * - * @return The number of stateful signature mechanisms. - */ -OQS_API int OQS_SIG_STFL_alg_count(void); - -/** - * Indicates whether the specified algorithm was enabled at compile-time or not. - * - * @param[in] method_name Name of the desired algorithm; one of the names in `OQS_SIG_STFL_algs`. - * @return 1 if enabled, 0 if disabled or not found - */ -OQS_API int OQS_SIG_STFL_alg_is_enabled(const char *method_name); - -#ifndef OQS_ALLOW_STFL_KEY_AND_SIG_GEN - -/** Signature schemes object */ -typedef struct OQS_SIG OQS_SIG; - -/** Stateful signature scheme object */ -#define OQS_SIG_STFL OQS_SIG -#else - -/** Stateful signature scheme object */ -typedef struct OQS_SIG_STFL { - - /** - * A local ordinal representing the LMS/XMSS OID parameter of the signature scheme. - * This OID is unrelated to ASN.1 OID, it's only for LMS/XMSS internal usage. - */ - uint32_t oid; - - /** Printable string representing the name of the signature scheme. */ - const char *method_name; - - /** - * Printable string representing the version of the cryptographic algorithm. - * - * Implementations with the same method_name and same alg_version will be interoperable. - * See README.md for information about algorithm compatibility. - */ - const char *alg_version; - - /** Whether the signature offers EUF-CMA security (TRUE) or not (FALSE). */ - bool euf_cma; - - /** Whether the signature offers SUF-CMA security (TRUE) or not (FALSE). */ - bool suf_cma; - - /** The (maximum) length, in bytes, of public keys for this signature scheme. */ - size_t length_public_key; - /** The (maximum) length, in bytes, of secret keys for this signature scheme. */ - size_t length_secret_key; - /** The (maximum) length, in bytes, of signatures for this signature scheme. */ - size_t length_signature; - - /** - * Keypair generation algorithm. - * - * Caller is responsible for allocating sufficient memory for `public_key` - * based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_SIG_STFL_*_length_*`. - * - * @param[out] public_key The public key is represented as a byte string. - * @param[out] secret_key The secret key object - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*keypair)(uint8_t *public_key, OQS_SIG_STFL_SECRET_KEY *secret_key); - - /** - * Signature generation algorithm. - * - * For stateful signatures, there is always a limited number of signatures that can be used, - * The private key signature counter is increased by one once a signature is successfully generated, - * When the signature counter reaches the maximum number of available signatures, the signature generation always fails. - * - * Caller is responsible for allocating sufficient memory for `signature`, - * based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_SIG_STFL_*_length_*`. - * - * @param[out] signature The signature on the message is represented as a byte string. - * @param[out] signature_len The length of the signature. - * @param[in] message The message to sign is represented as a byte string. - * @param[in] message_len The length of the message to sign. - * @param[in] secret_key The secret key object pointer. - * @return OQS_SUCCESS or OQS_ERROR - * - * @note Internally, if `lock/unlock` functions and `mutex` are set, it will attempt to lock the private key and unlock - * the private key after the Signing operation is completed. - */ - OQS_STATUS (*sign)(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, OQS_SIG_STFL_SECRET_KEY *secret_key); - - /** - * Signature verification algorithm. - * - * @param[in] message The message is represented as a byte string. - * @param[in] message_len The length of the message. - * @param[in] signature The signature on the message is represented as a byte string. - * @param[in] signature_len The length of the signature. - * @param[in] public_key The public key is represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*verify)(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); - - /** - * Query the number of remaining signatures. - * - * The remaining signatures are the number of signatures available before the private key runs out of its total signature and expires. - * - * @param[out] remain The number of remaining signatures - * @param[in] secret_key The secret key object pointer. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*sigs_remaining)(unsigned long long *remain, const OQS_SIG_STFL_SECRET_KEY *secret_key); - - /** - * Query the total number of signatures. - * - * The total number of signatures is the constant number present in how many signatures can be generated from a private key. - * - * @param[out] total The total number of signatures - * @param[in] secret_key The secret key key object pointer. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*sigs_total)(unsigned long long *total, const OQS_SIG_STFL_SECRET_KEY *secret_key); - -} OQS_SIG_STFL; -#endif //OQS_ALLOW_STFL_KEY_AND_SIG_GEN - -/** - * @brief OQS_SIG_STFL_SECRET_KEY object for stateful signature schemes - */ - -typedef struct OQS_SIG_STFL_SECRET_KEY { - - /** The (maximum) length, in bytes, of secret keys for this signature scheme. */ - size_t length_secret_key; - - /** The variant-specific secret key data must be allocated at the initialization. */ - void *secret_key_data; - - /** The mutual exclusion struct */ - void *mutex; - - /** Application-managed data related to secure storage of secret key data */ - void *context; - - /** - * Serialize the stateful secret key. - * - * This function encodes the stateful secret key represented by `sk` into a byte stream - * for storage or transfer. The `sk_buf_ptr` will point to the allocated memory containing - * the byte stream. Users must free the `sk_buf_ptr` using `OQS_MEM_secure_free` after use. - * The `sk_len` will contain the length of the byte stream. - * - * @param[out] sk_buf_ptr Pointer to the byte stream representing the serialized secret key. - * @param[out] sk_buf_len Pointer to the length of the serialized byte stream. - * @param[in] sk Pointer to the `OQS_SIG_STFL_SECRET_KEY` object to serialize. - * @return The number of bytes in the serialized byte stream upon success, or an OQS error code on failure. - * - * @attention The caller is responsible for ensuring that `sk` is a valid object before calling this function. - */ - OQS_STATUS (*serialize_key)(uint8_t **sk_buf_ptr, size_t *sk_buf_len, const OQS_SIG_STFL_SECRET_KEY *sk); - - /** - * Deserialize a byte stream into the internal representation of a stateful secret key. - * - * This function takes a series of bytes representing a stateful secret key and initializes - * the internal `OQS_SIG_STFL_SECRET_KEY` object with the key material. This is particularly - * useful for reconstructing key objects from persisted or transmitted state. - * - * @param[out] sk Pointer to an uninitialized `OQS_SIG_STFL_SECRET_KEY` object to hold the secret key. - * @param[in] sk_buf Pointer to the byte stream containing the serialized secret key data. - * @param[in] sk_buf_len The length of the secret key byte stream. - * @param[in] context Pointer to application-specific data, handled externally, associated with the key. - * @returns OQS_SUCCESS if the deserialization succeeds, with the `sk` object populated with the key material. - * - * @attention The caller is responsible for ensuring that `sk_buf` is securely deallocated when it's no longer needed. - */ - OQS_STATUS (*deserialize_key)(OQS_SIG_STFL_SECRET_KEY *sk, const uint8_t *sk_buf, const size_t sk_buf_len, void *context); - - /** - * Secret Key Locking Function - * - * @param[in] mutex application defined mutex - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*lock_key)(void *mutex); - - /** - * Secret Key Unlocking / Releasing Function - * - * @param[in] mutex application defined mutex - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*unlock_key)(void *mutex); - - /** - * Store Secret Key Function - * - * Callback function used to securely store key data after a signature generation. - * When populated, this pointer points to the application-supplied secure storage function. - * @param[in] sk_buf The serialized secret key data to secure store - * @param[in] sk_buf_len length of data to secure - * @param[in] context application supplied data used to locate where this secret key - * is stored (passed in at the time the function pointer was set). - * - * @return OQS_SUCCESS or OQS_ERROR - * Ideally written to a secure device. - */ - OQS_STATUS (*secure_store_scrt_key)(uint8_t *sk_buf, size_t sk_buf_len, void *context); - - /** - * Free internal variant-specific data - * - * @param[in] sk The secret key represented as OQS_SIG_STFL_SECRET_KEY object. - * @return None. - */ - void (*free_key)(OQS_SIG_STFL_SECRET_KEY *sk); - - /** - * Set Secret Key Store Callback Function - * - * This function is used to establish a callback mechanism for secure storage - * of private keys involved in stateful signature Signing operation. The secure storage - * and the management of private keys is the responsibility of the adopting application. - * Therefore, before invoking stateful signature generation, a callback function and - * associated context data must be provided by the application to manage the storage. - * - * The `context` argument is designed to hold information requisite for private key storage, - * such as a hardware security module (HSM) context, a file path, or other relevant data. - * This context is passed to the libOQS when the callback function is registered. - * - * @param[in] sk A pointer to the secret key object that requires secure storage management - * after signature Signing operations. - * @param[in] store_cb A pointer to the callback function provided by the application - * for storing and updating the private key securely. - * @param[in] context Application-specific context information for the private key storage, - * furnished when setting the callback function via - * OQS_SIG_STFL_SECRET_KEY_set_store_cb(). - * @return None. - */ - void (*set_scrt_key_store_cb)(OQS_SIG_STFL_SECRET_KEY *sk, secure_store_sk store_cb, void *context); -} OQS_SIG_STFL_SECRET_KEY; - -/** - * Constructs an OQS_SIG_STFL object for a particular algorithm. - * - * Callers should always check whether the return value is `NULL`, which indicates either than an - * invalid algorithm name was provided, or that the requested algorithm was disabled at compile-time. - * - * @param[in] method_name Name of the desired algorithm; one of the names in `OQS_SIG_STFL_algs`. - * @return An OQS_SIG_STFL for the particular algorithm, or `NULL` if the algorithm has been disabled at compile-time. - */ -OQS_API OQS_SIG_STFL *OQS_SIG_STFL_new(const char *method_name); - -/** - * Keypair generation algorithm. - * - * Caller is responsible for allocating sufficient memory for `public_key` based - * on the `length_*` members in this object or the per-scheme compile-time macros - * `OQS_SIG_STFL_*_length_*`. The caller is also responsible for initializing - * `secret_key` using the OQS_SIG_STFL_SECRET_KEY(*) function. - * - * @param[in] sig The OQS_SIG_STFL object representing the signature scheme. - * @param[out] public_key The public key is represented as a byte string. - * @param[out] secret_key The secret key object pointer. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_SIG_STFL_keypair(const OQS_SIG_STFL *sig, uint8_t *public_key, OQS_SIG_STFL_SECRET_KEY *secret_key); - -/** - * Signature generation algorithm. - * - * For stateful signatures, there is always a limited number of signatures that can be used, - * The private key signature counter is increased by one once a signature is successfully generated, - * When the signature counter reaches the maximum number of available signatures, the signature generation always fails. - * - * Caller is responsible for allocating sufficient memory for `signature`, - * based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_SIG_STFL_*_length_*`. - * - * @param[in] sig The OQS_SIG_STFL object representing the signature scheme. - * @param[out] signature The signature on the message is represented as a byte string. - * @param[out] signature_len The length of the signature. - * @param[in] message The message to sign is represented as a byte string. - * @param[in] message_len The length of the message to sign. - * @param[in] secret_key The secret key object pointer. - * @return OQS_SUCCESS or OQS_ERROR - * - * @note Internally, if `lock/unlock` functions and `mutex` are set, it will attempt to lock the private key and unlock - * the private key after the Signing operation is completed. - */ -OQS_API OQS_STATUS OQS_SIG_STFL_sign(const OQS_SIG_STFL *sig, uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, OQS_SIG_STFL_SECRET_KEY *secret_key); - -/** - * Signature verification algorithm. - * - * @param[in] sig The OQS_SIG_STFL object representing the signature scheme. - * @param[in] message The message is represented as a byte string. - * @param[in] message_len The length of the message. - * @param[in] signature The signature on the message is represented as a byte string. - * @param[in] signature_len The length of the signature. - * @param[in] public_key The public key is represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_SIG_STFL_verify(const OQS_SIG_STFL *sig, const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); - -/** - * Query the number of remaining signatures. - * - * The remaining signatures are the number of signatures available before the private key runs out of its total signature and expires. - * - * @param[in] sig The OQS_SIG_STFL object representing the signature scheme. - * @param[in] remain The number of remaining signatures. - * @param[in] secret_key The secret key object. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_SIG_STFL_sigs_remaining(const OQS_SIG_STFL *sig, unsigned long long *remain, const OQS_SIG_STFL_SECRET_KEY *secret_key); - -/** - * Query the total number of signatures. - * - * The total number of signatures is the constant number present in how many signatures can be generated from a private key. - * - * @param[in] sig The OQS_SIG_STFL object representing the signature scheme. - * @param[out] max The number of remaining signatures - * @param[in] secret_key The secret key object. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_SIG_STFL_sigs_total(const OQS_SIG_STFL *sig, unsigned long long *max, const OQS_SIG_STFL_SECRET_KEY *secret_key); - -/** - * Free an OQS_SIG_STFL object that was constructed by OQS_SIG_STFL_new. - * - */ -OQS_API void OQS_SIG_STFL_free(OQS_SIG_STFL *sig); - -/** - * Construct an OQS_SIG_STFL_SECRET_KEY object for a particular algorithm. - * - * Callers should always check whether the return value is `NULL`, which indicates either than an - * invalid algorithm name was provided, or that the requested algorithm was disabled at compile-time. - * - * @param[in] method_name Name of the desired algorithm; one of the names in `OQS_SIG_STFL_algs`. - * @return An OQS_SIG_STFL_SECRET_KEY for the particular algorithm, or `NULL` if the algorithm has been disabled at compile-time. - */ -OQS_API OQS_SIG_STFL_SECRET_KEY *OQS_SIG_STFL_SECRET_KEY_new(const char *method_name); - -/** - * Free an OQS_SIG_STFL_SECRET_KEY object that was constructed by OQS_SECRET_KEY_new. - * - * @param[in] sk The OQS_SIG_STFL_SECRET_KEY object to free. - */ -OQS_API void OQS_SIG_STFL_SECRET_KEY_free(OQS_SIG_STFL_SECRET_KEY *sk); - -/** - * Attach a locking mechanism to a secret key object. - * - * This allows for proper synchronization in a multi-threaded or multi-process environment, - * by ensuring that a secret key is not used concurrently by multiple entities, which could otherwise lead to security issues. - * - * @param[in] sk Pointer to the secret key object whose lock function is to be set. - * @param[in] lock Function pointer to the locking routine provided by the application. - * - * @note It's not required to set the lock and unlock functions in a single-threaded environment. - * - * @note Once the `lock` function is set, users must also set the `mutex` and `unlock` functions. - * - * @note By default, the internal value of `sk->lock` is NULL, which does nothing to lock the private key. - */ -OQS_API void OQS_SIG_STFL_SECRET_KEY_SET_lock(OQS_SIG_STFL_SECRET_KEY *sk, lock_key lock); - -/** - * Attach an unlock mechanism to a secret key object. - * - * This allows for proper synchronization in a multi-threaded or multi-process environment, - * by ensuring that a secret key is not used concurrently by multiple entities, which could otherwise lead to security issues. - * - * @param[in] sk Pointer to the secret key object whose unlock function is to be set. - * @param[in] unlock Function pointer to the unlock routine provided by the application. - * - * @note It's not required to set the lock and unlock functions in a single-threaded environment. - * - * @note Once the `unlock` function is set, users must also set the `mutex` and `lock` functions. - * - * @note By default, the internal value of `sk->unlock` is NULL, which does nothing to unlock the private key. - */ -OQS_API void OQS_SIG_STFL_SECRET_KEY_SET_unlock(OQS_SIG_STFL_SECRET_KEY *sk, unlock_key unlock); - -/** - * Assign a mutex function to handle concurrency control over the secret key. - * - * This is to ensure that only one process can access or modify the key at any given time. - * - * @param[in] sk A pointer to the secret key that the mutex functionality will protect. - * @param[in] mutex A function pointer to the desired concurrency control mechanism. - * - * @note It's not required to set the lock and unlock functions in a single-threaded environment. - * - * @note By default, the internal value of `sk->mutex` is NULL, it must be set to be used in `lock` or `unlock` the private key. - */ -OQS_API void OQS_SIG_STFL_SECRET_KEY_SET_mutex(OQS_SIG_STFL_SECRET_KEY *sk, void *mutex); - -/** - * Lock the secret key to ensure exclusive access in a concurrent environment. - * - * If the `mutex` is not set, this lock operation will fail. - * This lock operation is essential in multi-threaded or multi-process contexts - * to prevent simultaneous Signing operations that could compromise the stateful signature security. - * - * @warning If the `lock` function is set and `mutex` is not set, this lock operation will fail. - * - * @param[in] sk Pointer to the secret key to be locked. - * @return OQS_SUCCESS if the lock is successfully applied; OQS_ERROR otherwise. - * - * @note It's not necessary to use this function in either Keygen or Verifying operations. - * In a concurrent environment, the user is responsible for locking and unlocking the private key, - * to make sure that only one thread can access the private key during a Signing operation. - * - * @note If the `lock` function and `mutex` are both set, proceed to lock the private key. - */ -OQS_STATUS OQS_SIG_STFL_SECRET_KEY_lock(OQS_SIG_STFL_SECRET_KEY *sk); - -/** - * Unlock the secret key, making it accessible to other processes. - * - * This function is crucial in environments where multiple processes need to coordinate access to - * the secret key, as it allows a process to signal that it has finished using the key, so - * others can safely use it. - * - * @warning If the `unlock` function is set and `mutex` is not set, this unlock operation will fail. - * - * @param[in] sk Pointer to the secret key whose lock should be released. - * @return OQS_SUCCESS if the lock was successfully released; otherwise, OQS_ERROR. - * - * @note It's not necessary to use this function in either Keygen or Verifying operations. - * In a concurrent environment, the user is responsible for locking and unlocking the private key, - * to make sure that only one thread can access the private key during a Signing operation. - * - * @note If the `unlock` function and `mutex` are both set, proceed to unlock the private key. - */ -OQS_STATUS OQS_SIG_STFL_SECRET_KEY_unlock(OQS_SIG_STFL_SECRET_KEY *sk); - -/** - * Set the callback and context for securely storing a stateful secret key. - * - * This function is designed to be called after a new stateful secret key - * has been generated. It enables the library to securely store secret key - * and update it every time a Signing operation occurs. - * Without properly setting this callback and context, signature generation - * will not succeed as the updated state of the secret key cannot be preserved. - * - * @param[in] sk Pointer to the stateful secret key to be managed. - * @param[in] store_cb Callback function that handles the secure storage of the key. - * @param[in] context Application-specific context that assists in the storage of secret key data. - * This context is managed by the application, which allocates it, keeps track of it, - * and deallocates it as necessary. - */ -OQS_API void OQS_SIG_STFL_SECRET_KEY_SET_store_cb(OQS_SIG_STFL_SECRET_KEY *sk, secure_store_sk store_cb, void *context); - -/** - * Serialize the stateful secret key data into a byte array. - * - * Converts an OQS_SIG_STFL_SECRET_KEY object into a byte array for storage or transmission. - * - * @param[out] sk_buf_ptr Pointer to the allocated byte array containing the serialized key. - * @param[out] sk_buf_len Length of the serialized key byte array. - * @param[in] sk Pointer to the OQS_SIG_STFL_SECRET_KEY object to be serialized. - * @return OQS_SUCCESS on success, or an OQS error code on failure. - * - * @note The function allocates memory for the byte array, and it is the caller's responsibility to free this memory after use. - */ -OQS_API OQS_STATUS OQS_SIG_STFL_SECRET_KEY_serialize(uint8_t **sk_buf_ptr, size_t *sk_buf_len, const OQS_SIG_STFL_SECRET_KEY *sk); - -/** - * Deserialize a byte array into an OQS_SIG_STFL_SECRET_KEY object. - * - * Transforms a binary representation of a secret key into an OQS_SIG_STFL_SECRET_KEY structure. - * After deserialization, the secret key object can be used for subsequent cryptographic operations. - * - * @param[out] sk A pointer to the secret key object that will be populated from the binary data. - * @param[in] sk_buf The buffer containing the serialized secret key data. - * @param[in] sk_buf_len The length of the binary secret key data in bytes. - * @param[in] context Application-specific data used to maintain context about the secret key. - * @return OQS_SUCCESS if deserialization was successful; otherwise, OQS_ERROR. - * - * @attention The caller is responsible for freeing the `sk_buf` memory when it is no longer needed. - */ -OQS_API OQS_STATUS OQS_SIG_STFL_SECRET_KEY_deserialize(OQS_SIG_STFL_SECRET_KEY *sk, const uint8_t *sk_buf, size_t sk_buf_len, void *context); - -#if defined(__cplusplus) -// extern "C" -} -#endif - -#endif /* OQS_SIG_STATEFUL_H */ diff --git a/prebuilt_liboqs/linux-aarch64/include/oqs/sig_uov.h b/prebuilt_liboqs/linux-aarch64/include/oqs/sig_uov.h deleted file mode 100644 index 47b829f..0000000 --- a/prebuilt_liboqs/linux-aarch64/include/oqs/sig_uov.h +++ /dev/null @@ -1,164 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_SIG_UOV_H -#define OQS_SIG_UOV_H - -#include - -#if defined(OQS_ENABLE_SIG_uov_ov_Is) -#define OQS_SIG_uov_ov_Is_length_public_key 412160 -#define OQS_SIG_uov_ov_Is_length_secret_key 348704 -#define OQS_SIG_uov_ov_Is_length_signature 96 - -OQS_SIG *OQS_SIG_uov_ov_Is_new(void); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_uov_ov_Ip) -#define OQS_SIG_uov_ov_Ip_length_public_key 278432 -#define OQS_SIG_uov_ov_Ip_length_secret_key 237896 -#define OQS_SIG_uov_ov_Ip_length_signature 128 - -OQS_SIG *OQS_SIG_uov_ov_Ip_new(void); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_uov_ov_III) -#define OQS_SIG_uov_ov_III_length_public_key 1225440 -#define OQS_SIG_uov_ov_III_length_secret_key 1044320 -#define OQS_SIG_uov_ov_III_length_signature 200 - -OQS_SIG *OQS_SIG_uov_ov_III_new(void); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_uov_ov_V) -#define OQS_SIG_uov_ov_V_length_public_key 2869440 -#define OQS_SIG_uov_ov_V_length_secret_key 2436704 -#define OQS_SIG_uov_ov_V_length_signature 260 - -OQS_SIG *OQS_SIG_uov_ov_V_new(void); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_uov_ov_Is_pkc) -#define OQS_SIG_uov_ov_Is_pkc_length_public_key 66576 -#define OQS_SIG_uov_ov_Is_pkc_length_secret_key 348704 -#define OQS_SIG_uov_ov_Is_pkc_length_signature 96 - -OQS_SIG *OQS_SIG_uov_ov_Is_pkc_new(void); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_pkc_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_pkc_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_pkc_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_pkc_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_pkc_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_uov_ov_Ip_pkc) -#define OQS_SIG_uov_ov_Ip_pkc_length_public_key 43576 -#define OQS_SIG_uov_ov_Ip_pkc_length_secret_key 237896 -#define OQS_SIG_uov_ov_Ip_pkc_length_signature 128 - -OQS_SIG *OQS_SIG_uov_ov_Ip_pkc_new(void); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_pkc_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_pkc_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_pkc_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_pkc_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_pkc_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_uov_ov_III_pkc) -#define OQS_SIG_uov_ov_III_pkc_length_public_key 189232 -#define OQS_SIG_uov_ov_III_pkc_length_secret_key 1044320 -#define OQS_SIG_uov_ov_III_pkc_length_signature 200 - -OQS_SIG *OQS_SIG_uov_ov_III_pkc_new(void); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_pkc_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_pkc_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_pkc_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_pkc_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_pkc_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_uov_ov_V_pkc) -#define OQS_SIG_uov_ov_V_pkc_length_public_key 446992 -#define OQS_SIG_uov_ov_V_pkc_length_secret_key 2436704 -#define OQS_SIG_uov_ov_V_pkc_length_signature 260 - -OQS_SIG *OQS_SIG_uov_ov_V_pkc_new(void); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_pkc_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_pkc_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_pkc_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_pkc_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_pkc_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_uov_ov_Is_pkc_skc) -#define OQS_SIG_uov_ov_Is_pkc_skc_length_public_key 66576 -#define OQS_SIG_uov_ov_Is_pkc_skc_length_secret_key 32 -#define OQS_SIG_uov_ov_Is_pkc_skc_length_signature 96 - -OQS_SIG *OQS_SIG_uov_ov_Is_pkc_skc_new(void); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_pkc_skc_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_pkc_skc_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_pkc_skc_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_pkc_skc_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_pkc_skc_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_uov_ov_Ip_pkc_skc) -#define OQS_SIG_uov_ov_Ip_pkc_skc_length_public_key 43576 -#define OQS_SIG_uov_ov_Ip_pkc_skc_length_secret_key 32 -#define OQS_SIG_uov_ov_Ip_pkc_skc_length_signature 128 - -OQS_SIG *OQS_SIG_uov_ov_Ip_pkc_skc_new(void); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_pkc_skc_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_pkc_skc_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_pkc_skc_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_pkc_skc_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_pkc_skc_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_uov_ov_III_pkc_skc) -#define OQS_SIG_uov_ov_III_pkc_skc_length_public_key 189232 -#define OQS_SIG_uov_ov_III_pkc_skc_length_secret_key 32 -#define OQS_SIG_uov_ov_III_pkc_skc_length_signature 200 - -OQS_SIG *OQS_SIG_uov_ov_III_pkc_skc_new(void); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_pkc_skc_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_pkc_skc_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_pkc_skc_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_pkc_skc_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_pkc_skc_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_uov_ov_V_pkc_skc) -#define OQS_SIG_uov_ov_V_pkc_skc_length_public_key 446992 -#define OQS_SIG_uov_ov_V_pkc_skc_length_secret_key 32 -#define OQS_SIG_uov_ov_V_pkc_skc_length_signature 260 - -OQS_SIG *OQS_SIG_uov_ov_V_pkc_skc_new(void); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_pkc_skc_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_pkc_skc_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_pkc_skc_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_pkc_skc_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_pkc_skc_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#endif diff --git a/prebuilt_liboqs/linux-aarch64/lib/liboqs.so b/prebuilt_liboqs/linux-aarch64/lib/liboqs.so deleted file mode 120000 index dc983a9..0000000 --- a/prebuilt_liboqs/linux-aarch64/lib/liboqs.so +++ /dev/null @@ -1 +0,0 @@ -liboqs.so.9 \ No newline at end of file diff --git a/prebuilt_liboqs/linux-aarch64/lib/liboqs.so.0.15.0-rc1 b/prebuilt_liboqs/linux-aarch64/lib/liboqs.so.0.15.0-rc1 deleted file mode 100755 index c0e821d..0000000 Binary files a/prebuilt_liboqs/linux-aarch64/lib/liboqs.so.0.15.0-rc1 and /dev/null differ diff --git a/prebuilt_liboqs/linux-aarch64/lib/liboqs.so.9 b/prebuilt_liboqs/linux-aarch64/lib/liboqs.so.9 deleted file mode 120000 index 1f5405b..0000000 --- a/prebuilt_liboqs/linux-aarch64/lib/liboqs.so.9 +++ /dev/null @@ -1 +0,0 @@ -liboqs.so.0.15.0-rc1 \ No newline at end of file diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/aes.h b/prebuilt_liboqs/linux-x86_64/include/oqs/aes.h deleted file mode 100644 index d0d6d63..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/aes.h +++ /dev/null @@ -1,202 +0,0 @@ -/** - * \file aes.h - * \brief Header defining the API for OQS AES; not part of the public OQS API - * - * Note this is not part of the OQS public API: implementations within liboqs can use these - * functions, but external consumers of liboqs should not use these functions. - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_AES_H -#define OQS_AES_H - -#include -#include - -#include - -#if defined(__cplusplus) -extern "C" { -#endif - -/** - * Function to fill a key schedule given an initial key for use in ECB mode. - * - * @param key Initial Key. - * @param ctx Abstract data structure for a key schedule. - */ -void OQS_AES128_ECB_load_schedule(const uint8_t *key, void **ctx); - -/** - * Function to initialize a context and fill a key schedule given an initial key for - * use in CTR mode. - * - * @param key Initial Key. - * @param ctx Abstract data structure for a key schedule. - */ -void OQS_AES128_CTR_inc_init(const uint8_t *key, void **ctx); - -/** - * Function to fill a context given an IV for use in CTR mode. - * - * Handles a 12- or 16-byte IV. If a 12-byte IV is given, then 4 counter - * bytes are initialized to all zeros. - * - * @param iv Initialization Vector. - * @param iv_len Length of the initialization vector. - * @param ctx Abstract data structure for IV. - */ -void OQS_AES128_CTR_inc_iv(const uint8_t *iv, size_t iv_len, void *ctx); - -/** - * Function to fill a context given an IV for use in CTR mode. - * Handles an 8-byte IV passed as a 64-bit unsigned integer, - * counter bytes are initialized to zero. - * - * @param iv Initialization Vector as 64-bit integer. - * @param ctx Abstract data structure for IV. - */ -void OQS_AES128_CTR_inc_ivu64(uint64_t iv, void *ctx); - -/** - * Function to free a key schedule. - * - * @param ctx Context generated with OQS_AES128_ECB_load_schedule(). - */ -void OQS_AES128_free_schedule(void *ctx); - -/** - * Function to encrypt blocks of plaintext using ECB mode. - * A schedule based on the key is generated and used internally. - * - * @param plaintext Plaintext to be encrypted. - * @param plaintext_len Length on the plaintext in bytes. Must be a multiple of 16. - * @param key Key to be used for encryption. - * @param ciphertext Pointer to a block of memory which >= in size to the plaintext block. The result will be written here. - * @warning plaintext_len must be a multiple of 16. - */ -void OQS_AES128_ECB_enc(const uint8_t *plaintext, const size_t plaintext_len, const uint8_t *key, uint8_t *ciphertext); - -/** - * Same as OQS_AES128_ECB_enc() except a schedule generated by - * OQS_AES128_ECB_load_schedule() is passed rather then a key. This is faster - * if the same schedule is used for multiple encryptions since it does - * not have to be regenerated from the key. - */ -void OQS_AES128_ECB_enc_sch(const uint8_t *plaintext, const size_t plaintext_len, const void *schedule, uint8_t *ciphertext); - -/** - * AES counter mode keystream generator. A context generated by - * OQS_AES128_CTR_inc_init() is passed rather then a key. - * - * Handles a 12- or 16-byte IV. If a 12-byte IV is given, then 4 counter - * bytes are initialized to all zeros. - * - * @param iv 12- or 16-byte initialization vector. - * @param iv_len Lengh of IV in bytes. - * @param ctx Abstract data structure for a key schedule. - * @param out Pointer to a block of memory which is big enough to contain out_len bytes; the result will be written here. - * @param out_len Length of output bytes to generate. - */ -void OQS_AES128_CTR_inc_stream_iv(const uint8_t *iv, size_t iv_len, const void *ctx, uint8_t *out, size_t out_len); - -/** - * Function to fill a key schedule given an initial key for use in ECB mode encryption. - * - * @param key Initial Key. - * @param ctx Abstract data structure for a key schedule. - */ -void OQS_AES256_ECB_load_schedule(const uint8_t *key, void **ctx); - -/** - * Function to initialize a context and fill a key schedule given an initial key for - * use in CTR mode. - * - * @param key Initial Key. - * @param ctx Abstract data structure for a key schedule. - */ -void OQS_AES256_CTR_inc_init(const uint8_t *key, void **ctx); - -/** - * Function to fill a context given an IV for use in CTR mode. - * - * Handles a 12- or 16-byte IV. If a 12-byte IV is given, then 4 counter - * bytes are initialized to all zeros. - * - * @param iv Initialization Vector. - * @param iv_len Length of the initialization vector. - * @param ctx Abstract data structure for IV. - */ -void OQS_AES256_CTR_inc_iv(const uint8_t *iv, size_t iv_len, void *ctx); - -/** - * Function to fill a context given an IV for use in CTR mode. - * Handles an 8-byte IV passed as a 64-bit unsigned integer, - * counter bytes are initialized to zero. - * - * @param iv Initialization Vector as 64-bit integer. - * @param ctx Abstract data structure for IV. - */ -void OQS_AES256_CTR_inc_ivu64(uint64_t iv, void *ctx); - -/** - * Function to free a key schedule. - * - * @param ctx Schedule generated with OQS_AES256_ECB_load_schedule - * or OQS_AES256_CTR_inc_init. - */ -void OQS_AES256_free_schedule(void *ctx); - -/** - * Function to encrypt blocks of plaintext using ECB mode. - * A schedule based on the key is generated and used internally. - * - * @param plaintext Plaintext to be encrypted. - * @param plaintext_len Length on the plaintext in bytes. Must be a multiple of 16. - * @param key Key to be used for encryption. - * @param ciphertext Pointer to a block of memory which >= in size to the plaintext block. The result will be written here. - * @warning plaintext_len must be a multiple of 16. - */ -void OQS_AES256_ECB_enc(const uint8_t *plaintext, const size_t plaintext_len, const uint8_t *key, uint8_t *ciphertext); - -/** - * Same as OQS_AES256_ECB_enc() except a schedule generated by - * OQS_AES256_ECB_load_schedule() is passed rather then a key. This is faster - * if the same schedule is used for multiple encryptions since it does - * not have to be regenerated from the key. - */ -void OQS_AES256_ECB_enc_sch(const uint8_t *plaintext, const size_t plaintext_len, const void *schedule, uint8_t *ciphertext); - -/** - * AES counter mode keystream generator. A context generated by - * OQS_AES256_CTR_inc_init() is passed rather then a key. - * - * Handles a 12- or 16-byte IV. If a 12-byte IV is given, then 4 counter - * bytes are initialized to all zeros. - * - * @param iv 12- or 16-byte initialization vector. - * @param iv_len Lengh of IV in bytes. - * @param ctx Abstract data structure for a key schedule. - * @param out Pointer to a block of memory which is big enough to contain out_len bytes; the result will be written here. - * @param out_len Length of output bytes to generate. - */ -void OQS_AES256_CTR_inc_stream_iv(const uint8_t *iv, size_t iv_len, const void *ctx, uint8_t *out, size_t out_len); - -/** - * AES counter mode keystream generator. A context generated by - * OQS_AES256_CTR_inc_init() and OQS_AES256_CTR_inc_iv() is passed - * rather than a key and an IV. The counter is internally updated, which allows - * the function to be called multiple times. - * - * @param ctx Abstract data structure for key schedule and IV. - * @param out Pointer to a block of memory which is big enough to contain out_blks*16 bytes; the result will be written here. - * @param out_blks Length of output blocks to generate, where one block is 16 bytes. - */ -void OQS_AES256_CTR_inc_stream_blks(void *ctx, uint8_t *out, size_t out_blks); - -#if defined(__cplusplus) -} // extern "C" -#endif - -#endif // OQS_AES_H diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/aes_ops.h b/prebuilt_liboqs/linux-x86_64/include/oqs/aes_ops.h deleted file mode 100644 index a64c47d..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/aes_ops.h +++ /dev/null @@ -1,124 +0,0 @@ -/** - * \file aes_ops.h - * \brief Header defining the callback API for OQS AES - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_AES_OPS_H -#define OQS_AES_OPS_H - -#include -#include - -#include - -#if defined(__cplusplus) -extern "C" { -#endif - -/** Data structure implemented by cryptographic provider for AES operations. - */ -struct OQS_AES_callbacks { - /** - * Implementation of function OQS_AES128_ECB_load_schedule. - */ - void (*AES128_ECB_load_schedule)(const uint8_t *key, void **ctx); - - /** - * Implementation of function OQS_AES256_CTR_inc_init. - */ - void (*AES128_CTR_inc_init)(const uint8_t *key, void **ctx); - - /** - * Implementation of function OQS_AES256_CTR_inc_iv. - */ - void (*AES128_CTR_inc_iv)(const uint8_t *iv, size_t iv_len, void *ctx); - - /** - * Implementation of function OQS_AES256_CTR_inc_ivu64. - */ - void (*AES128_CTR_inc_ivu64)(uint64_t iv, void *ctx); - - /** - * Implementation of function OQS_AES128_free_schedule. - */ - void (*AES128_free_schedule)(void *ctx); - - /** - * Implementation of function OQS_AES128_ECB_enc. - */ - void (*AES128_ECB_enc)(const uint8_t *plaintext, const size_t plaintext_len, const uint8_t *key, uint8_t *ciphertext); - - /** - * Implementation of function OQS_AES128_ECB_enc_sch. - */ - void (*AES128_ECB_enc_sch)(const uint8_t *plaintext, const size_t plaintext_len, const void *schedule, uint8_t *ciphertext); - - /** - * Implementation of function OQS_AES128_CTR_inc_stream_iv. - */ - void (*AES128_CTR_inc_stream_iv)(const uint8_t *iv, size_t iv_len, const void *ctx, uint8_t *out, size_t out_len); - - /** - * Implementation of function OQS_AES256_ECB_load_schedule. - */ - void (*AES256_ECB_load_schedule)(const uint8_t *key, void **ctx); - - /** - * Implementation of function OQS_AES256_CTR_inc_init. - */ - void (*AES256_CTR_inc_init)(const uint8_t *key, void **ctx); - - /** - * Implementation of function OQS_AES256_CTR_inc_iv. - */ - void (*AES256_CTR_inc_iv)(const uint8_t *iv, size_t iv_len, void *ctx); - - /** - * Implementation of function OQS_AES256_CTR_inc_ivu64. - */ - void (*AES256_CTR_inc_ivu64)(uint64_t iv, void *ctx); - - /** - * Implementation of function OQS_AES256_free_schedule. - */ - void (*AES256_free_schedule)(void *ctx); - - /** - * Implementation of function OQS_AES256_ECB_enc. - */ - void (*AES256_ECB_enc)(const uint8_t *plaintext, const size_t plaintext_len, const uint8_t *key, uint8_t *ciphertext); - - /** - * Implementation of function OQS_AES256_ECB_enc_sch. - */ - void (*AES256_ECB_enc_sch)(const uint8_t *plaintext, const size_t plaintext_len, const void *schedule, uint8_t *ciphertext); - - /** - * Implementation of function OQS_AES256_CTR_inc_stream_iv. - */ - void (*AES256_CTR_inc_stream_iv)(const uint8_t *iv, size_t iv_len, const void *ctx, uint8_t *out, size_t out_len); - - /** - * Implementation of function OQS_AES256_CTR_inc_stream_blks. - */ - void (*AES256_CTR_inc_stream_blks)(void *ctx, uint8_t *out, size_t out_blks); -}; - -/** - * Set callback functions for AES operations. - * - * This function may be called before OQS_init to switch the - * cryptographic provider for AES operations. If it is not called, the - * default provider determined at build time will be used. - * - * @param[in] new_callbacks Callback functions defined in OQS_AES_callbacks - */ -OQS_API void OQS_AES_set_callbacks(struct OQS_AES_callbacks *new_callbacks); - -#if defined(__cplusplus) -} // extern "C" -#endif - -#endif // OQS_AES_OPS_H diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/common.h b/prebuilt_liboqs/linux-x86_64/include/oqs/common.h deleted file mode 100644 index ee01ff8..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/common.h +++ /dev/null @@ -1,286 +0,0 @@ -/** - * \file common.h - * \brief Utility functions for use in liboqs. - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_COMMON_H -#define OQS_COMMON_H - -#include -#include -#include -#include - -#include - -#if defined(__cplusplus) -extern "C" { -#endif - -/** - * Macro for terminating the program if x is - * a null pointer. - */ -#define OQS_EXIT_IF_NULLPTR(x, loc) \ - do { \ - if ((x) == (void *)0) { \ - fprintf(stderr, "Unexpected NULL returned from %s API. Exiting.\n", \ - loc); \ - exit(EXIT_FAILURE); \ - } \ - } while (0) - -/** - * This macro is intended to replace those assert()s - * involving side-effecting statements in aes/aes_ossl.c. - * - * assert() becomes a no-op when -DNDEBUG is defined, - * which causes compilation failures when the statement - * being checked also results in side-effects. - * - * This is a temporary workaround until a better error - * handling strategy is developed. - */ -#ifdef OQS_USE_OPENSSL -#ifdef OPENSSL_NO_STDIO -#define OQS_OPENSSL_GUARD(x) \ - do { \ - if (1 != (x)) { \ - fprintf(stderr, "Error return value from OpenSSL API: %d. Exiting.\n", \ - x); \ - exit(EXIT_FAILURE); \ - } \ - } while (0) -#else // OPENSSL_NO_STDIO -#define OQS_OPENSSL_GUARD(x) \ - do { \ - if (1 != (x)) { \ - fprintf(stderr, "Error return value from OpenSSL API: %d. Exiting.\n", \ - x); \ - OSSL_FUNC(ERR_print_errors_fp)(stderr); \ - exit(EXIT_FAILURE); \ - } \ - } while (0) -#endif // OPENSSL_NO_STDIO -#endif // OQS_USE_OPENSSL - -/** - * Certain functions (such as OQS_randombytes_openssl in - * src/rand/rand.c) take in a size_t parameter, but can - * only handle values up to INT_MAX for those parameters. - * This macro is a temporary workaround for such functions. - */ -#define SIZE_T_TO_INT_OR_EXIT(size_t_var_name, int_var_name) \ - int int_var_name = 0; \ - if (size_t_var_name <= INT_MAX) { \ - int_var_name = (int)size_t_var_name; \ - } else { \ - exit(EXIT_FAILURE); \ - } - -/** - * Defines which functions should be exposed outside the LibOQS library - * - * By default the visibility of all the symbols is defined to "hidden" - * Only the library API should be marked as default - * - * Example: OQS_API return_value function_name(void); - */ -#if defined(_WIN32) -#define OQS_API __declspec(dllexport) -#else -#define OQS_API __attribute__((visibility("default"))) -#endif - -#if defined(OQS_SYS_UEFI) -#undef OQS_API -#define OQS_API -#endif - -/** - * Represents return values from functions. - * - * Callers should compare with the symbol rather than the individual value. - * For example, - * - * ret = OQS_KEM_encaps(...); - * if (ret == OQS_SUCCESS) { ... } - * - * rather than - * - * if (!OQS_KEM_encaps(...) { ... } - * - */ -typedef enum { - /** Used to indicate that some undefined error occurred. */ - OQS_ERROR = -1, - /** Used to indicate successful return from function. */ - OQS_SUCCESS = 0, - /** Used to indicate failures in external libraries (e.g., OpenSSL). */ - OQS_EXTERNAL_LIB_ERROR_OPENSSL = 50, -} OQS_STATUS; - -/** - * CPU runtime detection flags - */ -typedef enum { - OQS_CPU_EXT_INIT, /* Must be first */ - /* Start extension list */ - OQS_CPU_EXT_ADX, - OQS_CPU_EXT_AES, - OQS_CPU_EXT_AVX, - OQS_CPU_EXT_AVX2, - OQS_CPU_EXT_AVX512, - OQS_CPU_EXT_BMI1, - OQS_CPU_EXT_BMI2, - OQS_CPU_EXT_PCLMULQDQ, - OQS_CPU_EXT_VPCLMULQDQ, - OQS_CPU_EXT_POPCNT, - OQS_CPU_EXT_SSE, - OQS_CPU_EXT_SSE2, - OQS_CPU_EXT_SSE3, - OQS_CPU_EXT_ARM_AES, - OQS_CPU_EXT_ARM_SHA2, - OQS_CPU_EXT_ARM_SHA3, - OQS_CPU_EXT_ARM_NEON, - /* End extension list */ - OQS_CPU_EXT_COUNT, /* Must be last */ -} OQS_CPU_EXT; - -/** - * Checks if the CPU supports a given extension - * - * \return 1 if the given CPU extension is available, 0 otherwise. - */ -OQS_API int OQS_CPU_has_extension(OQS_CPU_EXT ext); - -/** - * This currently sets the values in the OQS_CPU_EXTENSIONS - * and prefetches the OpenSSL objects if necessary. - */ -OQS_API void OQS_init(void); - -/** - * This function stops OpenSSL threads, which allows resources - * to be cleaned up in the correct order. - * @note When liboqs is used in a multithreaded application, - * each thread should call this function prior to stopping. - */ -OQS_API void OQS_thread_stop(void); - -/** - * This function frees prefetched OpenSSL objects - */ -OQS_API void OQS_destroy(void); - -/** - * Return library version string. - */ -OQS_API const char *OQS_version(void); - -/** - * @brief Memory allocation and deallocation functions. - * - * These functions provide a unified interface for memory operations, - * using OpenSSL functions when OQS_USE_OPENSSL is defined, and - * standard C library functions otherwise. - */ - -/** - * Allocates memory of a given size. - * @param size The size of the memory to be allocated in bytes. - * @return A pointer to the allocated memory. - */ -OQS_API void *OQS_MEM_malloc(size_t size); - -/** - * Allocates memory for an array of elements of a given size. - * @param num_elements The number of elements to allocate. - * @param element_size The size of each element in bytes. - * @return A pointer to the allocated memory. - */ -OQS_API void *OQS_MEM_calloc(size_t num_elements, size_t element_size); - -/** - * Duplicates a string. - * @param str The string to be duplicated. - * @return A pointer to the newly allocated string. - */ -OQS_API char *OQS_MEM_strdup(const char *str); - -/** - * Constant time comparison of byte sequences `a` and `b` of length `len`. - * Returns 0 if the byte sequences are equal or if `len`=0. - * Returns 1 otherwise. - * - * @param[in] a A byte sequence of length at least `len`. - * @param[in] b A byte sequence of length at least `len`. - * @param[in] len The number of bytes to compare. - */ -OQS_API int OQS_MEM_secure_bcmp(const void *a, const void *b, size_t len); - -/** - * Zeros out `len` bytes of memory starting at `ptr`. - * - * Designed to be protected against optimizing compilers which try to remove - * "unnecessary" operations. Should be used for all buffers containing secret - * data. - * - * @param[in] ptr The start of the memory to zero out. - * @param[in] len The number of bytes to zero out. - */ -OQS_API void OQS_MEM_cleanse(void *ptr, size_t len); - -/** - * Zeros out `len` bytes of memory starting at `ptr`, then frees `ptr`. - * - * Can be called with `ptr = NULL`, in which case no operation is performed. - * - * Designed to be protected against optimizing compilers which try to remove - * "unnecessary" operations. Should be used for all buffers containing secret - * data. - * - * @param[in] ptr The start of the memory to zero out and free. - * @param[in] len The number of bytes to zero out. - */ -OQS_API void OQS_MEM_secure_free(void *ptr, size_t len); - -/** - * Frees `ptr`. - * - * Can be called with `ptr = NULL`, in which case no operation is performed. - * - * Should only be used on non-secret data. - * - * @param[in] ptr The start of the memory to free. - */ -OQS_API void OQS_MEM_insecure_free(void *ptr); - -/** - * Internal implementation of C11 aligned_alloc to work around compiler quirks. - * - * Allocates size bytes of uninitialized memory with a base pointer that is - * a multiple of alignment. Alignment must be a power of two and a multiple - * of sizeof(void *). Size must be a multiple of alignment. - * @note The allocated memory should be freed with `OQS_MEM_aligned_free` when - * it is no longer needed. - */ -void *OQS_MEM_aligned_alloc(size_t alignment, size_t size); - -/** - * Free memory allocated with OQS_MEM_aligned_alloc. - */ -void OQS_MEM_aligned_free(void *ptr); - -/** - * Free and zeroize memory allocated with OQS_MEM_aligned_alloc. - */ -void OQS_MEM_aligned_secure_free(void *ptr, size_t len); - -#if defined(__cplusplus) -} // extern "C" -#endif - -#endif // OQS_COMMON_H diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/kem.h b/prebuilt_liboqs/linux-x86_64/include/oqs/kem.h deleted file mode 100644 index fe52cd8..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/kem.h +++ /dev/null @@ -1,374 +0,0 @@ -/** - * \file kem.h - * \brief Key encapsulation mechanisms - * - * The file `tests/example_kem.c` contains two examples on using the OQS_KEM API. - * - * The first example uses the individual scheme's algorithms directly and uses - * no dynamic memory allocation -- all buffers are allocated on the stack, with - * sizes indicated using preprocessor macros. Since algorithms can be disabled at - * compile-time, the programmer should wrap the code in \#ifdefs. - * - * The second example uses an OQS_KEM object to use an algorithm specified at - * runtime. Therefore it uses dynamic memory allocation -- all buffers must be - * malloc'ed by the programmer, with sizes indicated using the corresponding length - * member of the OQS_KEM object in question. Since algorithms can be disabled at - * compile-time, the programmer should check that the OQS_KEM object is not `NULL`. - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_KEM_H -#define OQS_KEM_H - -#include -#include -#include - -#include - -#if defined(__cplusplus) -extern "C" { -#endif - -/** Algorithm identifier for BIKE-L1 KEM (Round-4). */ -#define OQS_KEM_alg_bike_l1 "BIKE-L1" -/** Algorithm identifier for BIKE-L3 KEM (Round-4). */ -#define OQS_KEM_alg_bike_l3 "BIKE-L3" -/** Algorithm identifier for BIKE-L5 KEM (Round-4). */ -#define OQS_KEM_alg_bike_l5 "BIKE-L5" -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_ALG_IDENTIFIER_START -/** Algorithm identifier for Classic-McEliece-348864 KEM. */ -#define OQS_KEM_alg_classic_mceliece_348864 "Classic-McEliece-348864" -/** Algorithm identifier for Classic-McEliece-348864f KEM. */ -#define OQS_KEM_alg_classic_mceliece_348864f "Classic-McEliece-348864f" -/** Algorithm identifier for Classic-McEliece-460896 KEM. */ -#define OQS_KEM_alg_classic_mceliece_460896 "Classic-McEliece-460896" -/** Algorithm identifier for Classic-McEliece-460896f KEM. */ -#define OQS_KEM_alg_classic_mceliece_460896f "Classic-McEliece-460896f" -/** Algorithm identifier for Classic-McEliece-6688128 KEM. */ -#define OQS_KEM_alg_classic_mceliece_6688128 "Classic-McEliece-6688128" -/** Algorithm identifier for Classic-McEliece-6688128f KEM. */ -#define OQS_KEM_alg_classic_mceliece_6688128f "Classic-McEliece-6688128f" -/** Algorithm identifier for Classic-McEliece-6960119 KEM. */ -#define OQS_KEM_alg_classic_mceliece_6960119 "Classic-McEliece-6960119" -/** Algorithm identifier for Classic-McEliece-6960119f KEM. */ -#define OQS_KEM_alg_classic_mceliece_6960119f "Classic-McEliece-6960119f" -/** Algorithm identifier for Classic-McEliece-8192128 KEM. */ -#define OQS_KEM_alg_classic_mceliece_8192128 "Classic-McEliece-8192128" -/** Algorithm identifier for Classic-McEliece-8192128f KEM. */ -#define OQS_KEM_alg_classic_mceliece_8192128f "Classic-McEliece-8192128f" -/** Algorithm identifier for HQC-128 KEM. */ -#define OQS_KEM_alg_hqc_128 "HQC-128" -/** Algorithm identifier for HQC-192 KEM. */ -#define OQS_KEM_alg_hqc_192 "HQC-192" -/** Algorithm identifier for HQC-256 KEM. */ -#define OQS_KEM_alg_hqc_256 "HQC-256" -/** Algorithm identifier for Kyber512 KEM. */ -#define OQS_KEM_alg_kyber_512 "Kyber512" -/** Algorithm identifier for Kyber768 KEM. */ -#define OQS_KEM_alg_kyber_768 "Kyber768" -/** Algorithm identifier for Kyber1024 KEM. */ -#define OQS_KEM_alg_kyber_1024 "Kyber1024" -/** Algorithm identifier for ML-KEM-512 KEM. */ -#define OQS_KEM_alg_ml_kem_512 "ML-KEM-512" -/** Algorithm identifier for ML-KEM-768 KEM. */ -#define OQS_KEM_alg_ml_kem_768 "ML-KEM-768" -/** Algorithm identifier for ML-KEM-1024 KEM. */ -#define OQS_KEM_alg_ml_kem_1024 "ML-KEM-1024" -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_ALG_IDENTIFIER_END -/** Algorithm identifier for NTRU-HPS-2048-509 KEM. */ -#define OQS_KEM_alg_ntru_hps2048509 "NTRU-HPS-2048-509" -/** Algorithm identifier for NTRU-HPS-2048-677 KEM. */ -#define OQS_KEM_alg_ntru_hps2048677 "NTRU-HPS-2048-677" -/** Algorithm identifier for NTRU-HPS-4096-821 KEM. */ -#define OQS_KEM_alg_ntru_hps4096821 "NTRU-HPS-4096-821" -/** Algorithm identifier for NTRU-HPS-4096-1229 KEM. */ -#define OQS_KEM_alg_ntru_hps40961229 "NTRU-HPS-4096-1229" -/** Algorithm identifier for NTRU-HRSS-701 KEM. */ -#define OQS_KEM_alg_ntru_hrss701 "NTRU-HRSS-701" -/** Algorithm identifier for NTRU-HRSS-1373 KEM. */ -#define OQS_KEM_alg_ntru_hrss1373 "NTRU-HRSS-1373" -/** Algorithm identifier for sntrup761 KEM. */ -#define OQS_KEM_alg_ntruprime_sntrup761 "sntrup761" -/** Algorithm identifier for FrodoKEM-640-AES KEM. */ -#define OQS_KEM_alg_frodokem_640_aes "FrodoKEM-640-AES" -/** Algorithm identifier for FrodoKEM-640-SHAKE KEM. */ -#define OQS_KEM_alg_frodokem_640_shake "FrodoKEM-640-SHAKE" -/** Algorithm identifier for FrodoKEM-976-AES KEM. */ -#define OQS_KEM_alg_frodokem_976_aes "FrodoKEM-976-AES" -/** Algorithm identifier for FrodoKEM-976-SHAKE KEM. */ -#define OQS_KEM_alg_frodokem_976_shake "FrodoKEM-976-SHAKE" -/** Algorithm identifier for FrodoKEM-1344-AES KEM. */ -#define OQS_KEM_alg_frodokem_1344_aes "FrodoKEM-1344-AES" -/** Algorithm identifier for FrodoKEM-1344-SHAKE KEM. */ -#define OQS_KEM_alg_frodokem_1344_shake "FrodoKEM-1344-SHAKE" -// EDIT-WHEN-ADDING-KEM -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_ALGS_LENGTH_START - -/** Number of algorithm identifiers above. */ -#define OQS_KEM_algs_length 35 -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_ALGS_LENGTH_END - -/** - * Returns identifiers for available key encapsulation mechanisms in liboqs. Used with OQS_KEM_new. - * - * Note that algorithm identifiers are present in this list even when the algorithm is disabled - * at compile time. - * - * @param[in] i Index of the algorithm identifier to return, 0 <= i < OQS_KEM_algs_length - * @return Algorithm identifier as a string, or NULL. - */ -OQS_API const char *OQS_KEM_alg_identifier(size_t i); - -/** - * Returns the number of key encapsulation mechanisms in liboqs. They can be enumerated with - * OQS_KEM_alg_identifier. - * - * Note that some mechanisms may be disabled at compile time. - * - * @return The number of key encapsulation mechanisms. - */ -OQS_API int OQS_KEM_alg_count(void); - -/** - * Indicates whether the specified algorithm was enabled at compile-time or not. - * - * @param[in] method_name Name of the desired algorithm; one of the names in `OQS_KEM_algs`. - * @return 1 if enabled, 0 if disabled or not found - */ -OQS_API int OQS_KEM_alg_is_enabled(const char *method_name); - -/** - * Key encapsulation mechanism object - */ -typedef struct OQS_KEM { - - /** Printable string representing the name of the key encapsulation mechanism. */ - const char *method_name; - - /** - * Printable string representing the version of the cryptographic algorithm. - * - * Implementations with the same method_name and same alg_version will be interoperable. - * See README.md for information about algorithm compatibility. - */ - const char *alg_version; - - /** The NIST security level (1, 2, 3, 4, 5) claimed in this algorithm's original NIST submission. */ - uint8_t claimed_nist_level; - - /** Whether the KEM offers IND-CCA security (TRUE) or IND-CPA security (FALSE). */ - bool ind_cca; - - /** The length, in bytes, of public keys for this KEM. */ - size_t length_public_key; - /** The length, in bytes, of secret keys for this KEM. */ - size_t length_secret_key; - /** The length, in bytes, of ciphertexts for this KEM. */ - size_t length_ciphertext; - /** The length, in bytes, of shared secrets for this KEM. */ - size_t length_shared_secret; - /** The length, in bytes, of seeds for derandomized keypair generation for this KEM. */ - size_t length_keypair_seed; - /** The length, in bytes, of seeds for derandomized encaps generation for this KEM. */ - size_t length_encaps_seed; - - /** - * Derandomized keypair generation algorithm. - * - * Caller is responsible for allocating sufficient memory for `public_key` and - * `secret_key`, based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_KEM_*_length_*`. - * - * @param[out] public_key The public key represented as a byte string. - * @param[out] secret_key The secret key represented as a byte string. - * @param[in] seed The input randomness represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*keypair_derand)(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); - - /** - * Keypair generation algorithm. - * - * Caller is responsible for allocating sufficient memory for `public_key` and - * `secret_key`, based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_KEM_*_length_*`. - * - * @param[out] public_key The public key represented as a byte string. - * @param[out] secret_key The secret key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*keypair)(uint8_t *public_key, uint8_t *secret_key); - - /** - * Derandomized encapsulation algorithm. - * - * Caller is responsible for allocating sufficient memory for `ciphertext` and - * `shared_secret`, based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_KEM_*_length_*`. - * - * @param[out] ciphertext The ciphertext (encapsulation) represented as a byte string. - * @param[out] shared_secret The shared secret represented as a byte string. - * @param[in] public_key The public key represented as a byte string. - * @param[in] seed The input randomness represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*encaps_derand)(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); - - /** - * Encapsulation algorithm. - * - * Caller is responsible for allocating sufficient memory for `ciphertext` and - * `shared_secret`, based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_KEM_*_length_*`. - * - * @param[out] ciphertext The ciphertext (encapsulation) represented as a byte string. - * @param[out] shared_secret The shared secret represented as a byte string. - * @param[in] public_key The public key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*encaps)(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); - - /** - * Decapsulation algorithm. - * - * Caller is responsible for allocating sufficient memory for `shared_secret`, based - * on the `length_*` members in this object or the per-scheme compile-time macros - * `OQS_KEM_*_length_*`. - * - * @param[out] shared_secret The shared secret represented as a byte string. - * @param[in] ciphertext The ciphertext (encapsulation) represented as a byte string. - * @param[in] secret_key The secret key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*decaps)(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); - -} OQS_KEM; - -/** - * Constructs an OQS_KEM object for a particular algorithm. - * - * Callers should always check whether the return value is `NULL`, which indicates either than an - * invalid algorithm name was provided, or that the requested algorithm was disabled at compile-time. - * - * @param[in] method_name Name of the desired algorithm; one of the names in `OQS_KEM_algs`. - * @return An OQS_KEM for the particular algorithm, or `NULL` if the algorithm has been disabled at compile-time. - */ -OQS_API OQS_KEM *OQS_KEM_new(const char *method_name); - -/** - * Derandomized keypair generation algorithm. - * - * Caller is responsible for allocating sufficient memory for `public_key` and - * `secret_key`, based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_KEM_*_length_*`. - * - * @param[in] kem The OQS_KEM object representing the KEM. - * @param[out] public_key The public key represented as a byte string. - * @param[out] secret_key The secret key represented as a byte string. - * @param[in] seed The input randomness represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_KEM_keypair_derand(const OQS_KEM *kem, uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); - -/** - * Keypair generation algorithm. - * - * Caller is responsible for allocating sufficient memory for `public_key` and - * `secret_key`, based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_KEM_*_length_*`. - * - * @param[in] kem The OQS_KEM object representing the KEM. - * @param[out] public_key The public key represented as a byte string. - * @param[out] secret_key The secret key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_KEM_keypair(const OQS_KEM *kem, uint8_t *public_key, uint8_t *secret_key); - -/** - * Derandomized encapsulation algorithm. - * - * Caller is responsible for allocating sufficient memory for `ciphertext` and - * `shared_secret`, based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_KEM_*_length_*`. - * - * @param[in] kem The OQS_KEM object representing the KEM. - * @param[out] ciphertext The ciphertext (encapsulation) represented as a byte string. - * @param[out] shared_secret The shared secret represented as a byte string. - * @param[in] public_key The public key represented as a byte string. - * @param[in] seed The input randomness represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_KEM_encaps_derand(const OQS_KEM *kem, uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); - -/** - * Encapsulation algorithm. - * - * Caller is responsible for allocating sufficient memory for `ciphertext` and - * `shared_secret`, based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_KEM_*_length_*`. - * - * @param[in] kem The OQS_KEM object representing the KEM. - * @param[out] ciphertext The ciphertext (encapsulation) represented as a byte string. - * @param[out] shared_secret The shared secret represented as a byte string. - * @param[in] public_key The public key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_KEM_encaps(const OQS_KEM *kem, uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); - -/** - * Decapsulation algorithm. - * - * Caller is responsible for allocating sufficient memory for `shared_secret`, based - * on the `length_*` members in this object or the per-scheme compile-time macros - * `OQS_KEM_*_length_*`. - * - * @param[in] kem The OQS_KEM object representing the KEM. - * @param[out] shared_secret The shared secret represented as a byte string. - * @param[in] ciphertext The ciphertext (encapsulation) represented as a byte string. - * @param[in] secret_key The secret key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_KEM_decaps(const OQS_KEM *kem, uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); - -/** - * Frees an OQS_KEM object that was constructed by OQS_KEM_new. - * - * @param[in] kem The OQS_KEM object to free. - */ -OQS_API void OQS_KEM_free(OQS_KEM *kem); - -#ifdef OQS_ENABLE_KEM_BIKE -#include -#endif /* OQS_ENABLE_KEM_BIKE */ -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_INCLUDE_START -#ifdef OQS_ENABLE_KEM_CLASSIC_MCELIECE -#include -#endif /* OQS_ENABLE_KEM_CLASSIC_MCELIECE */ -#ifdef OQS_ENABLE_KEM_HQC -#include -#endif /* OQS_ENABLE_KEM_HQC */ -#ifdef OQS_ENABLE_KEM_KYBER -#include -#endif /* OQS_ENABLE_KEM_KYBER */ -#ifdef OQS_ENABLE_KEM_ML_KEM -#include -#endif /* OQS_ENABLE_KEM_ML_KEM */ -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_INCLUDE_END -#ifdef OQS_ENABLE_KEM_NTRU -#include -#endif /* OQS_ENABLE_KEM_NTRU */ -#ifdef OQS_ENABLE_KEM_NTRUPRIME -#include -#endif /* OQS_ENABLE_KEM_NTRUPRIME */ -#ifdef OQS_ENABLE_KEM_FRODOKEM -#include -#endif /* OQS_ENABLE_KEM_FRODOKEM */ -// EDIT-WHEN-ADDING-KEM - -#if defined(__cplusplus) -} // extern "C" -#endif - -#endif // OQS_KEM_H diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/kem_bike.h b/prebuilt_liboqs/linux-x86_64/include/oqs/kem_bike.h deleted file mode 100644 index beac165..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/kem_bike.h +++ /dev/null @@ -1,54 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_KEM_BIKE_H -#define OQS_KEM_BIKE_H - -#include - -// Round-4 KEMs -#ifdef OQS_ENABLE_KEM_bike_l1 -#define OQS_KEM_bike_l1_length_secret_key 5223 -#define OQS_KEM_bike_l1_length_public_key 1541 -#define OQS_KEM_bike_l1_length_ciphertext 1573 -#define OQS_KEM_bike_l1_length_shared_secret 32 -#define OQS_KEM_bike_l1_length_keypair_seed 0 -#define OQS_KEM_bike_l1_length_encaps_seed 0 -OQS_KEM *OQS_KEM_bike_l1_new(void); -OQS_API OQS_STATUS OQS_KEM_bike_l1_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_bike_l1_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_bike_l1_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_bike_l1_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_bike_l1_decaps(uint8_t *shared_secret, const unsigned char *ciphertext, const uint8_t *secret_key); -#endif - -#ifdef OQS_ENABLE_KEM_bike_l3 -#define OQS_KEM_bike_l3_length_secret_key 10105 -#define OQS_KEM_bike_l3_length_public_key 3083 -#define OQS_KEM_bike_l3_length_ciphertext 3115 -#define OQS_KEM_bike_l3_length_shared_secret 32 -#define OQS_KEM_bike_l3_length_keypair_seed 0 -#define OQS_KEM_bike_l3_length_encaps_seed 0 -OQS_KEM *OQS_KEM_bike_l3_new(void); -OQS_API OQS_STATUS OQS_KEM_bike_l3_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_bike_l3_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_bike_l3_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_bike_l3_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_bike_l3_decaps(uint8_t *shared_secret, const unsigned char *ciphertext, const uint8_t *secret_key); -#endif - -#ifdef OQS_ENABLE_KEM_bike_l5 -#define OQS_KEM_bike_l5_length_secret_key 16494 -#define OQS_KEM_bike_l5_length_public_key 5122 -#define OQS_KEM_bike_l5_length_ciphertext 5154 -#define OQS_KEM_bike_l5_length_shared_secret 32 -#define OQS_KEM_bike_l5_length_keypair_seed 0 -#define OQS_KEM_bike_l5_length_encaps_seed 0 -OQS_KEM *OQS_KEM_bike_l5_new(void); -OQS_API OQS_STATUS OQS_KEM_bike_l5_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_bike_l5_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_bike_l5_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_bike_l5_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_bike_l5_decaps(uint8_t *shared_secret, const unsigned char *ciphertext, const uint8_t *secret_key); -#endif - -#endif // OQS_KEM_BIKE_H diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/kem_classic_mceliece.h b/prebuilt_liboqs/linux-x86_64/include/oqs/kem_classic_mceliece.h deleted file mode 100644 index 13613e7..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/kem_classic_mceliece.h +++ /dev/null @@ -1,159 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_KEM_CLASSIC_MCELIECE_H -#define OQS_KEM_CLASSIC_MCELIECE_H - -#include - -#if defined(OQS_ENABLE_KEM_classic_mceliece_348864) -#define OQS_KEM_classic_mceliece_348864_length_public_key 261120 -#define OQS_KEM_classic_mceliece_348864_length_secret_key 6492 -#define OQS_KEM_classic_mceliece_348864_length_ciphertext 96 -#define OQS_KEM_classic_mceliece_348864_length_shared_secret 32 -#define OQS_KEM_classic_mceliece_348864_length_keypair_seed 0 -#define OQS_KEM_classic_mceliece_348864_length_encaps_seed 0 -OQS_KEM *OQS_KEM_classic_mceliece_348864_new(void); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_348864_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_348864_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_348864_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_348864_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_348864_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_classic_mceliece_348864f) -#define OQS_KEM_classic_mceliece_348864f_length_public_key 261120 -#define OQS_KEM_classic_mceliece_348864f_length_secret_key 6492 -#define OQS_KEM_classic_mceliece_348864f_length_ciphertext 96 -#define OQS_KEM_classic_mceliece_348864f_length_shared_secret 32 -#define OQS_KEM_classic_mceliece_348864f_length_keypair_seed 0 -#define OQS_KEM_classic_mceliece_348864f_length_encaps_seed 0 -OQS_KEM *OQS_KEM_classic_mceliece_348864f_new(void); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_348864f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_348864f_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_348864f_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_348864f_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_348864f_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_classic_mceliece_460896) -#define OQS_KEM_classic_mceliece_460896_length_public_key 524160 -#define OQS_KEM_classic_mceliece_460896_length_secret_key 13608 -#define OQS_KEM_classic_mceliece_460896_length_ciphertext 156 -#define OQS_KEM_classic_mceliece_460896_length_shared_secret 32 -#define OQS_KEM_classic_mceliece_460896_length_keypair_seed 0 -#define OQS_KEM_classic_mceliece_460896_length_encaps_seed 0 -OQS_KEM *OQS_KEM_classic_mceliece_460896_new(void); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_460896_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_460896_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_460896_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_460896_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_460896_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_classic_mceliece_460896f) -#define OQS_KEM_classic_mceliece_460896f_length_public_key 524160 -#define OQS_KEM_classic_mceliece_460896f_length_secret_key 13608 -#define OQS_KEM_classic_mceliece_460896f_length_ciphertext 156 -#define OQS_KEM_classic_mceliece_460896f_length_shared_secret 32 -#define OQS_KEM_classic_mceliece_460896f_length_keypair_seed 0 -#define OQS_KEM_classic_mceliece_460896f_length_encaps_seed 0 -OQS_KEM *OQS_KEM_classic_mceliece_460896f_new(void); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_460896f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_460896f_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_460896f_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_460896f_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_460896f_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_classic_mceliece_6688128) -#define OQS_KEM_classic_mceliece_6688128_length_public_key 1044992 -#define OQS_KEM_classic_mceliece_6688128_length_secret_key 13932 -#define OQS_KEM_classic_mceliece_6688128_length_ciphertext 208 -#define OQS_KEM_classic_mceliece_6688128_length_shared_secret 32 -#define OQS_KEM_classic_mceliece_6688128_length_keypair_seed 0 -#define OQS_KEM_classic_mceliece_6688128_length_encaps_seed 0 -OQS_KEM *OQS_KEM_classic_mceliece_6688128_new(void); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6688128_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6688128_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6688128_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6688128_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6688128_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_classic_mceliece_6688128f) -#define OQS_KEM_classic_mceliece_6688128f_length_public_key 1044992 -#define OQS_KEM_classic_mceliece_6688128f_length_secret_key 13932 -#define OQS_KEM_classic_mceliece_6688128f_length_ciphertext 208 -#define OQS_KEM_classic_mceliece_6688128f_length_shared_secret 32 -#define OQS_KEM_classic_mceliece_6688128f_length_keypair_seed 0 -#define OQS_KEM_classic_mceliece_6688128f_length_encaps_seed 0 -OQS_KEM *OQS_KEM_classic_mceliece_6688128f_new(void); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6688128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6688128f_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6688128f_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6688128f_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6688128f_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_classic_mceliece_6960119) -#define OQS_KEM_classic_mceliece_6960119_length_public_key 1047319 -#define OQS_KEM_classic_mceliece_6960119_length_secret_key 13948 -#define OQS_KEM_classic_mceliece_6960119_length_ciphertext 194 -#define OQS_KEM_classic_mceliece_6960119_length_shared_secret 32 -#define OQS_KEM_classic_mceliece_6960119_length_keypair_seed 0 -#define OQS_KEM_classic_mceliece_6960119_length_encaps_seed 0 -OQS_KEM *OQS_KEM_classic_mceliece_6960119_new(void); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6960119_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6960119_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6960119_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6960119_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6960119_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_classic_mceliece_6960119f) -#define OQS_KEM_classic_mceliece_6960119f_length_public_key 1047319 -#define OQS_KEM_classic_mceliece_6960119f_length_secret_key 13948 -#define OQS_KEM_classic_mceliece_6960119f_length_ciphertext 194 -#define OQS_KEM_classic_mceliece_6960119f_length_shared_secret 32 -#define OQS_KEM_classic_mceliece_6960119f_length_keypair_seed 0 -#define OQS_KEM_classic_mceliece_6960119f_length_encaps_seed 0 -OQS_KEM *OQS_KEM_classic_mceliece_6960119f_new(void); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6960119f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6960119f_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6960119f_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6960119f_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_6960119f_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_classic_mceliece_8192128) -#define OQS_KEM_classic_mceliece_8192128_length_public_key 1357824 -#define OQS_KEM_classic_mceliece_8192128_length_secret_key 14120 -#define OQS_KEM_classic_mceliece_8192128_length_ciphertext 208 -#define OQS_KEM_classic_mceliece_8192128_length_shared_secret 32 -#define OQS_KEM_classic_mceliece_8192128_length_keypair_seed 0 -#define OQS_KEM_classic_mceliece_8192128_length_encaps_seed 0 -OQS_KEM *OQS_KEM_classic_mceliece_8192128_new(void); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_8192128_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_8192128_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_8192128_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_8192128_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_8192128_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_classic_mceliece_8192128f) -#define OQS_KEM_classic_mceliece_8192128f_length_public_key 1357824 -#define OQS_KEM_classic_mceliece_8192128f_length_secret_key 14120 -#define OQS_KEM_classic_mceliece_8192128f_length_ciphertext 208 -#define OQS_KEM_classic_mceliece_8192128f_length_shared_secret 32 -#define OQS_KEM_classic_mceliece_8192128f_length_keypair_seed 0 -#define OQS_KEM_classic_mceliece_8192128f_length_encaps_seed 0 -OQS_KEM *OQS_KEM_classic_mceliece_8192128f_new(void); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_8192128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_8192128f_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_8192128f_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_8192128f_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_classic_mceliece_8192128f_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#endif - diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/kem_frodokem.h b/prebuilt_liboqs/linux-x86_64/include/oqs/kem_frodokem.h deleted file mode 100644 index 56a38c9..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/kem_frodokem.h +++ /dev/null @@ -1,98 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_KEM_FRODOKEM_H -#define OQS_KEM_FRODOKEM_H - -#include - -#ifdef OQS_ENABLE_KEM_frodokem_640_aes -#define OQS_KEM_frodokem_640_aes_length_public_key 9616 -#define OQS_KEM_frodokem_640_aes_length_secret_key 19888 -#define OQS_KEM_frodokem_640_aes_length_ciphertext 9720 -#define OQS_KEM_frodokem_640_aes_length_shared_secret 16 -#define OQS_KEM_frodokem_640_aes_length_keypair_seed 0 -#define OQS_KEM_frodokem_640_aes_length_encaps_seed 0 -OQS_KEM *OQS_KEM_frodokem_640_aes_new(void); -OQS_API OQS_STATUS OQS_KEM_frodokem_640_aes_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_frodokem_640_aes_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_frodokem_640_aes_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_frodokem_640_aes_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_frodokem_640_aes_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#ifdef OQS_ENABLE_KEM_frodokem_640_shake -#define OQS_KEM_frodokem_640_shake_length_public_key 9616 -#define OQS_KEM_frodokem_640_shake_length_secret_key 19888 -#define OQS_KEM_frodokem_640_shake_length_ciphertext 9720 -#define OQS_KEM_frodokem_640_shake_length_shared_secret 16 -#define OQS_KEM_frodokem_640_shake_length_keypair_seed 0 -#define OQS_KEM_frodokem_640_shake_length_encaps_seed 0 -OQS_KEM *OQS_KEM_frodokem_640_shake_new(void); -OQS_API OQS_STATUS OQS_KEM_frodokem_640_shake_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_frodokem_640_shake_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_frodokem_640_shake_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_frodokem_640_shake_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_frodokem_640_shake_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#ifdef OQS_ENABLE_KEM_frodokem_976_aes -#define OQS_KEM_frodokem_976_aes_length_public_key 15632 -#define OQS_KEM_frodokem_976_aes_length_secret_key 31296 -#define OQS_KEM_frodokem_976_aes_length_ciphertext 15744 -#define OQS_KEM_frodokem_976_aes_length_shared_secret 24 -#define OQS_KEM_frodokem_976_aes_length_keypair_seed 0 -#define OQS_KEM_frodokem_976_aes_length_encaps_seed 0 -OQS_KEM *OQS_KEM_frodokem_976_aes_new(void); -OQS_API OQS_STATUS OQS_KEM_frodokem_976_aes_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_frodokem_976_aes_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_frodokem_976_aes_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_frodokem_976_aes_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_frodokem_976_aes_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#ifdef OQS_ENABLE_KEM_frodokem_976_shake -#define OQS_KEM_frodokem_976_shake_length_public_key 15632 -#define OQS_KEM_frodokem_976_shake_length_secret_key 31296 -#define OQS_KEM_frodokem_976_shake_length_ciphertext 15744 -#define OQS_KEM_frodokem_976_shake_length_shared_secret 24 -#define OQS_KEM_frodokem_976_shake_length_keypair_seed 0 -#define OQS_KEM_frodokem_976_shake_length_encaps_seed 0 -OQS_KEM *OQS_KEM_frodokem_976_shake_new(void); -OQS_API OQS_STATUS OQS_KEM_frodokem_976_shake_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_frodokem_976_shake_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_frodokem_976_shake_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_frodokem_976_shake_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_frodokem_976_shake_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#ifdef OQS_ENABLE_KEM_frodokem_1344_aes -#define OQS_KEM_frodokem_1344_aes_length_public_key 21520 -#define OQS_KEM_frodokem_1344_aes_length_secret_key 43088 -#define OQS_KEM_frodokem_1344_aes_length_ciphertext 21632 -#define OQS_KEM_frodokem_1344_aes_length_shared_secret 32 -#define OQS_KEM_frodokem_1344_aes_length_keypair_seed 0 -#define OQS_KEM_frodokem_1344_aes_length_encaps_seed 0 -OQS_KEM *OQS_KEM_frodokem_1344_aes_new(void); -OQS_API OQS_STATUS OQS_KEM_frodokem_1344_aes_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_frodokem_1344_aes_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_frodokem_1344_aes_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_frodokem_1344_aes_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_frodokem_1344_aes_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#ifdef OQS_ENABLE_KEM_frodokem_1344_shake -#define OQS_KEM_frodokem_1344_shake_length_public_key 21520 -#define OQS_KEM_frodokem_1344_shake_length_secret_key 43088 -#define OQS_KEM_frodokem_1344_shake_length_ciphertext 21632 -#define OQS_KEM_frodokem_1344_shake_length_shared_secret 32 -#define OQS_KEM_frodokem_1344_shake_length_keypair_seed 0 -#define OQS_KEM_frodokem_1344_shake_length_encaps_seed 0 -OQS_KEM *OQS_KEM_frodokem_1344_shake_new(void); -OQS_API OQS_STATUS OQS_KEM_frodokem_1344_shake_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_frodokem_1344_shake_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_frodokem_1344_shake_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_frodokem_1344_shake_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_frodokem_1344_shake_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#endif // OQS_KEM_FRODOKEM_H diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/kem_kyber.h b/prebuilt_liboqs/linux-x86_64/include/oqs/kem_kyber.h deleted file mode 100644 index 7915704..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/kem_kyber.h +++ /dev/null @@ -1,54 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_KEM_KYBER_H -#define OQS_KEM_KYBER_H - -#include - -#if defined(OQS_ENABLE_KEM_kyber_512) -#define OQS_KEM_kyber_512_length_public_key 800 -#define OQS_KEM_kyber_512_length_secret_key 1632 -#define OQS_KEM_kyber_512_length_ciphertext 768 -#define OQS_KEM_kyber_512_length_shared_secret 32 -#define OQS_KEM_kyber_512_length_keypair_seed 0 -#define OQS_KEM_kyber_512_length_encaps_seed 0 -OQS_KEM *OQS_KEM_kyber_512_new(void); -OQS_API OQS_STATUS OQS_KEM_kyber_512_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_kyber_512_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_kyber_512_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_kyber_512_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_kyber_512_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_kyber_768) -#define OQS_KEM_kyber_768_length_public_key 1184 -#define OQS_KEM_kyber_768_length_secret_key 2400 -#define OQS_KEM_kyber_768_length_ciphertext 1088 -#define OQS_KEM_kyber_768_length_shared_secret 32 -#define OQS_KEM_kyber_768_length_keypair_seed 0 -#define OQS_KEM_kyber_768_length_encaps_seed 0 -OQS_KEM *OQS_KEM_kyber_768_new(void); -OQS_API OQS_STATUS OQS_KEM_kyber_768_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_kyber_768_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_kyber_768_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_kyber_768_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_kyber_768_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_kyber_1024) -#define OQS_KEM_kyber_1024_length_public_key 1568 -#define OQS_KEM_kyber_1024_length_secret_key 3168 -#define OQS_KEM_kyber_1024_length_ciphertext 1568 -#define OQS_KEM_kyber_1024_length_shared_secret 32 -#define OQS_KEM_kyber_1024_length_keypair_seed 0 -#define OQS_KEM_kyber_1024_length_encaps_seed 0 -OQS_KEM *OQS_KEM_kyber_1024_new(void); -OQS_API OQS_STATUS OQS_KEM_kyber_1024_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_kyber_1024_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_kyber_1024_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_kyber_1024_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_kyber_1024_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#endif - diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/kem_ml_kem.h b/prebuilt_liboqs/linux-x86_64/include/oqs/kem_ml_kem.h deleted file mode 100644 index be45e17..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/kem_ml_kem.h +++ /dev/null @@ -1,54 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_KEM_ML_KEM_H -#define OQS_KEM_ML_KEM_H - -#include - -#if defined(OQS_ENABLE_KEM_ml_kem_512) -#define OQS_KEM_ml_kem_512_length_public_key 800 -#define OQS_KEM_ml_kem_512_length_secret_key 1632 -#define OQS_KEM_ml_kem_512_length_ciphertext 768 -#define OQS_KEM_ml_kem_512_length_shared_secret 32 -#define OQS_KEM_ml_kem_512_length_keypair_seed 64 -#define OQS_KEM_ml_kem_512_length_encaps_seed 32 -OQS_KEM *OQS_KEM_ml_kem_512_new(void); -OQS_API OQS_STATUS OQS_KEM_ml_kem_512_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_ml_kem_512_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ml_kem_512_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_ml_kem_512_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ml_kem_512_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_ml_kem_768) -#define OQS_KEM_ml_kem_768_length_public_key 1184 -#define OQS_KEM_ml_kem_768_length_secret_key 2400 -#define OQS_KEM_ml_kem_768_length_ciphertext 1088 -#define OQS_KEM_ml_kem_768_length_shared_secret 32 -#define OQS_KEM_ml_kem_768_length_keypair_seed 64 -#define OQS_KEM_ml_kem_768_length_encaps_seed 32 -OQS_KEM *OQS_KEM_ml_kem_768_new(void); -OQS_API OQS_STATUS OQS_KEM_ml_kem_768_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_ml_kem_768_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ml_kem_768_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_ml_kem_768_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ml_kem_768_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#if defined(OQS_ENABLE_KEM_ml_kem_1024) -#define OQS_KEM_ml_kem_1024_length_public_key 1568 -#define OQS_KEM_ml_kem_1024_length_secret_key 3168 -#define OQS_KEM_ml_kem_1024_length_ciphertext 1568 -#define OQS_KEM_ml_kem_1024_length_shared_secret 32 -#define OQS_KEM_ml_kem_1024_length_keypair_seed 64 -#define OQS_KEM_ml_kem_1024_length_encaps_seed 32 -OQS_KEM *OQS_KEM_ml_kem_1024_new(void); -OQS_API OQS_STATUS OQS_KEM_ml_kem_1024_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_ml_kem_1024_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ml_kem_1024_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_ml_kem_1024_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ml_kem_1024_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#endif - diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/kem_ntru.h b/prebuilt_liboqs/linux-x86_64/include/oqs/kem_ntru.h deleted file mode 100644 index 93f7999..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/kem_ntru.h +++ /dev/null @@ -1,93 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_KEM_NTRU_H -#define OQS_KEM_NTRU_H - -#include - -#ifdef OQS_ENABLE_KEM_ntru_hps2048509 -#define OQS_KEM_ntru_hps2048509_length_public_key 699 -#define OQS_KEM_ntru_hps2048509_length_secret_key 935 -#define OQS_KEM_ntru_hps2048509_length_ciphertext 699 -#define OQS_KEM_ntru_hps2048509_length_shared_secret 32 -#define OQS_KEM_ntru_hps2048509_length_keypair_seed 0 -#define OQS_KEM_ntru_hps2048509_length_encaps_seed 0 -OQS_KEM *OQS_KEM_ntru_hps2048509_new(void); -OQS_API OQS_STATUS OQS_KEM_ntru_hps2048509_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_ntru_hps2048509_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ntru_hps2048509_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_ntru_hps2048509_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#ifdef OQS_ENABLE_KEM_ntru_hps2048677 -#define OQS_KEM_ntru_hps2048677_length_public_key 930 -#define OQS_KEM_ntru_hps2048677_length_secret_key 1234 -#define OQS_KEM_ntru_hps2048677_length_ciphertext 930 -#define OQS_KEM_ntru_hps2048677_length_shared_secret 32 -#define OQS_KEM_ntru_hps2048677_length_keypair_seed 0 -#define OQS_KEM_ntru_hps2048677_length_encaps_seed 0 -OQS_KEM *OQS_KEM_ntru_hps2048677_new(void); -OQS_API OQS_STATUS OQS_KEM_ntru_hps2048677_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_ntru_hps2048677_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ntru_hps2048677_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_ntru_hps2048677_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#ifdef OQS_ENABLE_KEM_ntru_hps4096821 -#define OQS_KEM_ntru_hps4096821_length_public_key 1230 -#define OQS_KEM_ntru_hps4096821_length_secret_key 1590 -#define OQS_KEM_ntru_hps4096821_length_ciphertext 1230 -#define OQS_KEM_ntru_hps4096821_length_shared_secret 32 -#define OQS_KEM_ntru_hps4096821_length_keypair_seed 0 -#define OQS_KEM_ntru_hps4096821_length_encaps_seed 0 -OQS_KEM *OQS_KEM_ntru_hps4096821_new(void); -OQS_API OQS_STATUS OQS_KEM_ntru_hps4096821_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_ntru_hps4096821_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ntru_hps4096821_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_ntru_hps4096821_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#ifdef OQS_ENABLE_KEM_ntru_hps40961229 -#define OQS_KEM_ntru_hps40961229_length_public_key 1842 -#define OQS_KEM_ntru_hps40961229_length_secret_key 2366 -#define OQS_KEM_ntru_hps40961229_length_ciphertext 1842 -#define OQS_KEM_ntru_hps40961229_length_shared_secret 32 -#define OQS_KEM_ntru_hps40961229_length_keypair_seed 0 -#define OQS_KEM_ntru_hps40961229_length_encaps_seed 0 -OQS_KEM *OQS_KEM_ntru_hps40961229_new(void); -OQS_API OQS_STATUS OQS_KEM_ntru_hps40961229_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_ntru_hps40961229_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ntru_hps40961229_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_ntru_hps40961229_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#ifdef OQS_ENABLE_KEM_ntru_hrss701 -#define OQS_KEM_ntru_hrss701_length_public_key 1138 -#define OQS_KEM_ntru_hrss701_length_secret_key 1450 -#define OQS_KEM_ntru_hrss701_length_ciphertext 1138 -#define OQS_KEM_ntru_hrss701_length_shared_secret 32 -#define OQS_KEM_ntru_hrss701_length_keypair_seed 0 -#define OQS_KEM_ntru_hrss701_length_encaps_seed 0 -OQS_KEM *OQS_KEM_ntru_hrss701_new(void); -OQS_API OQS_STATUS OQS_KEM_ntru_hrss701_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_ntru_hrss701_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ntru_hrss701_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_ntru_hrss701_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#ifdef OQS_ENABLE_KEM_ntru_hrss1373 -#define OQS_KEM_ntru_hrss1373_length_public_key 2401 -#define OQS_KEM_ntru_hrss1373_length_secret_key 2983 -#define OQS_KEM_ntru_hrss1373_length_ciphertext 2401 -#define OQS_KEM_ntru_hrss1373_length_shared_secret 32 -#define OQS_KEM_ntru_hrss1373_length_keypair_seed 0 -#define OQS_KEM_ntru_hrss1373_length_encaps_seed 0 -OQS_KEM *OQS_KEM_ntru_hrss1373_new(void); -OQS_API OQS_STATUS OQS_KEM_ntru_hrss1373_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_ntru_hrss1373_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ntru_hrss1373_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_ntru_hrss1373_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#endif - diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/kem_ntruprime.h b/prebuilt_liboqs/linux-x86_64/include/oqs/kem_ntruprime.h deleted file mode 100644 index fbb5e61..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/kem_ntruprime.h +++ /dev/null @@ -1,24 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_KEM_NTRUPRIME_H -#define OQS_KEM_NTRUPRIME_H - -#include - -#ifdef OQS_ENABLE_KEM_ntruprime_sntrup761 -#define OQS_KEM_ntruprime_sntrup761_length_public_key 1158 -#define OQS_KEM_ntruprime_sntrup761_length_secret_key 1763 -#define OQS_KEM_ntruprime_sntrup761_length_ciphertext 1039 -#define OQS_KEM_ntruprime_sntrup761_length_shared_secret 32 -#define OQS_KEM_ntruprime_sntrup761_length_keypair_seed 0 -#define OQS_KEM_ntruprime_sntrup761_length_encaps_seed 0 -OQS_KEM *OQS_KEM_ntruprime_sntrup761_new(void); -OQS_API OQS_STATUS OQS_KEM_ntruprime_sntrup761_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_KEM_ntruprime_sntrup761_keypair_derand(uint8_t *public_key, uint8_t *secret_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ntruprime_sntrup761_encaps(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_KEM_ntruprime_sntrup761_encaps_derand(uint8_t *ciphertext, uint8_t *shared_secret, const uint8_t *public_key, const uint8_t *seed); -OQS_API OQS_STATUS OQS_KEM_ntruprime_sntrup761_decaps(uint8_t *shared_secret, const uint8_t *ciphertext, const uint8_t *secret_key); -#endif - -#endif - diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/oqs.h b/prebuilt_liboqs/linux-x86_64/include/oqs/oqs.h deleted file mode 100644 index d6833bc..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/oqs.h +++ /dev/null @@ -1,26 +0,0 @@ -/** - * \file oqs.h - * \brief Overall header file for the liboqs public API. - * - * C programs using liboqs can include just this one file, and it will include all - * other necessary headers from liboqs. - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_H -#define OQS_H - -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#endif // OQS_H diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/oqsconfig.h b/prebuilt_liboqs/linux-x86_64/include/oqs/oqsconfig.h deleted file mode 100644 index fe48349..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/oqsconfig.h +++ /dev/null @@ -1,569 +0,0 @@ -// SPDX-License-Identifier: MIT - -/** - * Version of liboqs as a string. Equivalent to {MAJOR}.{MINOR}.{PATCH}{PRE_RELEASE} - */ -#define OQS_VERSION_TEXT "0.15.0-rc1" -/** - * Version levels of liboqs as integers. - */ -#define OQS_VERSION_MAJOR 0 -#define OQS_VERSION_MINOR 15 -#define OQS_VERSION_PATCH 0 -/** - * OQS_VERSION_PRE_RELEASE is defined if this is a pre-release version of liboqs, otherwise it is undefined. - * Examples: "-dev" or "-rc1". - */ -#define OQS_VERSION_PRE_RELEASE "-rc1" - -#define OQS_COMPILE_BUILD_TARGET "aarch64-Linux-6.8.0-86-generic" -#define OQS_DIST_BUILD 1 -/* #undef OQS_DIST_X86_64_BUILD */ -/* #undef OQS_DIST_X86_BUILD */ -#define OQS_DIST_ARM64_V8_BUILD 1 -/* #undef OQS_DIST_ARM32_V7_BUILD */ -/* #undef OQS_DIST_PPC64LE_BUILD */ -/* #undef OQS_DEBUG_BUILD */ -/* #undef ARCH_X86_64 */ -#define ARCH_ARM64v8 1 -/* #undef ARCH_ARM32v7 */ -#define BUILD_SHARED_LIBS 1 -#define OQS_BUILD_ONLY_LIB 1 -#define OQS_OPT_TARGET "generic" -/* #undef USE_COVERAGE */ -/* #undef USE_SANITIZER */ -#define CMAKE_BUILD_TYPE "Release" - -/* #undef OQS_USE_OPENSSL */ -/* #undef OQS_USE_AES_OPENSSL */ -/* #undef OQS_USE_SHA2_OPENSSL */ -/* #undef OQS_USE_SHA3_OPENSSL */ -/* #undef OQS_DLOPEN_OPENSSL */ -/* #undef OQS_OPENSSL_CRYPTO_SONAME */ - -/* #undef OQS_EMBEDDED_BUILD */ - -#define OQS_USE_PTHREADS 1 - -/* #undef OQS_USE_ADX_INSTRUCTIONS */ -/* #undef OQS_USE_AES_INSTRUCTIONS */ -/* #undef OQS_USE_AVX_INSTRUCTIONS */ -/* #undef OQS_USE_AVX2_INSTRUCTIONS */ -/* #undef OQS_USE_AVX512_INSTRUCTIONS */ -/* #undef OQS_USE_BMI1_INSTRUCTIONS */ -/* #undef OQS_USE_BMI2_INSTRUCTIONS */ -/* #undef OQS_USE_PCLMULQDQ_INSTRUCTIONS */ -/* #undef OQS_USE_VPCLMULQDQ_INSTRUCTIONS */ -/* #undef OQS_USE_POPCNT_INSTRUCTIONS */ -/* #undef OQS_USE_SSE_INSTRUCTIONS */ -/* #undef OQS_USE_SSE2_INSTRUCTIONS */ -/* #undef OQS_USE_SSE3_INSTRUCTIONS */ - -/* #undef OQS_USE_ARM_AES_INSTRUCTIONS */ -/* #undef OQS_USE_ARM_SHA2_INSTRUCTIONS */ -/* #undef OQS_USE_ARM_SHA3_INSTRUCTIONS */ -/* #undef OQS_USE_ARM_NEON_INSTRUCTIONS */ - -/* #undef OQS_SPEED_USE_ARM_PMU */ - -/* #undef OQS_ENABLE_TEST_CONSTANT_TIME */ - -/* #undef OQS_ENABLE_SHA3_xkcp_low_avx2 */ -/* #undef OQS_USE_SHA3_AVX512VL */ - -#define OQS_USE_CUPQC 0 -#define OQS_USE_ICICLE 0 - -#define OQS_ENABLE_KEM_BIKE 1 -#define OQS_ENABLE_KEM_bike_l1 1 -#define OQS_ENABLE_KEM_bike_l3 1 -#define OQS_ENABLE_KEM_bike_l5 1 - -#define OQS_ENABLE_KEM_FRODOKEM 1 -#define OQS_ENABLE_KEM_frodokem_640_aes 1 -#define OQS_ENABLE_KEM_frodokem_640_shake 1 -#define OQS_ENABLE_KEM_frodokem_976_aes 1 -#define OQS_ENABLE_KEM_frodokem_976_shake 1 -#define OQS_ENABLE_KEM_frodokem_1344_aes 1 -#define OQS_ENABLE_KEM_frodokem_1344_shake 1 - -#define OQS_ENABLE_KEM_NTRUPRIME 1 -#define OQS_ENABLE_KEM_ntruprime_sntrup761 1 -/* #undef OQS_ENABLE_KEM_ntruprime_sntrup761_avx2 */ - -#define OQS_ENABLE_KEM_NTRU 1 -#define OQS_ENABLE_KEM_ntru_hps2048509 1 -/* #undef OQS_ENABLE_KEM_ntru_hps2048509_avx2 */ -#define OQS_ENABLE_KEM_ntru_hps2048677 1 -/* #undef OQS_ENABLE_KEM_ntru_hps2048677_avx2 */ -#define OQS_ENABLE_KEM_ntru_hps4096821 1 -/* #undef OQS_ENABLE_KEM_ntru_hps4096821_avx2 */ -#define OQS_ENABLE_KEM_ntru_hps40961229 1 -#define OQS_ENABLE_KEM_ntru_hrss701 1 -/* #undef OQS_ENABLE_KEM_ntru_hrss701_avx2 */ -#define OQS_ENABLE_KEM_ntru_hrss1373 1 - -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_ADD_ALG_ENABLE_DEFINES_START - -#define OQS_ENABLE_KEM_CLASSIC_MCELIECE 1 -#define OQS_ENABLE_KEM_classic_mceliece_348864 1 -/* #undef OQS_ENABLE_KEM_classic_mceliece_348864_avx2 */ -#define OQS_ENABLE_KEM_classic_mceliece_348864f 1 -/* #undef OQS_ENABLE_KEM_classic_mceliece_348864f_avx2 */ -#define OQS_ENABLE_KEM_classic_mceliece_460896 1 -/* #undef OQS_ENABLE_KEM_classic_mceliece_460896_avx2 */ -#define OQS_ENABLE_KEM_classic_mceliece_460896f 1 -/* #undef OQS_ENABLE_KEM_classic_mceliece_460896f_avx2 */ -#define OQS_ENABLE_KEM_classic_mceliece_6688128 1 -/* #undef OQS_ENABLE_KEM_classic_mceliece_6688128_avx2 */ -#define OQS_ENABLE_KEM_classic_mceliece_6688128f 1 -/* #undef OQS_ENABLE_KEM_classic_mceliece_6688128f_avx2 */ -#define OQS_ENABLE_KEM_classic_mceliece_6960119 1 -/* #undef OQS_ENABLE_KEM_classic_mceliece_6960119_avx2 */ -#define OQS_ENABLE_KEM_classic_mceliece_6960119f 1 -/* #undef OQS_ENABLE_KEM_classic_mceliece_6960119f_avx2 */ -#define OQS_ENABLE_KEM_classic_mceliece_8192128 1 -/* #undef OQS_ENABLE_KEM_classic_mceliece_8192128_avx2 */ -#define OQS_ENABLE_KEM_classic_mceliece_8192128f 1 -/* #undef OQS_ENABLE_KEM_classic_mceliece_8192128f_avx2 */ - -/* #undef OQS_ENABLE_KEM_HQC */ -/* #undef OQS_ENABLE_KEM_hqc_128 */ -/* #undef OQS_ENABLE_KEM_hqc_192 */ -/* #undef OQS_ENABLE_KEM_hqc_256 */ - -#define OQS_ENABLE_KEM_KYBER 1 -#define OQS_ENABLE_KEM_kyber_512 1 -/* #undef OQS_ENABLE_KEM_kyber_512_avx2 */ -#define OQS_ENABLE_KEM_kyber_512_aarch64 1 -#define OQS_ENABLE_KEM_kyber_768 1 -/* #undef OQS_ENABLE_KEM_kyber_768_avx2 */ -#define OQS_ENABLE_KEM_kyber_768_aarch64 1 -#define OQS_ENABLE_KEM_kyber_1024 1 -/* #undef OQS_ENABLE_KEM_kyber_1024_avx2 */ -#define OQS_ENABLE_KEM_kyber_1024_aarch64 1 - -#define OQS_ENABLE_KEM_ML_KEM 1 -#define OQS_ENABLE_KEM_ml_kem_512 1 -/* #undef OQS_ENABLE_KEM_ml_kem_512_x86_64 */ -#define OQS_ENABLE_KEM_ml_kem_512_aarch64 1 -/* #undef OQS_ENABLE_KEM_ml_kem_512_cuda */ -/* #undef OQS_ENABLE_KEM_ml_kem_512_icicle_cuda */ -#define OQS_ENABLE_KEM_ml_kem_768 1 -/* #undef OQS_ENABLE_KEM_ml_kem_768_x86_64 */ -#define OQS_ENABLE_KEM_ml_kem_768_aarch64 1 -/* #undef OQS_ENABLE_KEM_ml_kem_768_cuda */ -/* #undef OQS_ENABLE_KEM_ml_kem_768_icicle_cuda */ -#define OQS_ENABLE_KEM_ml_kem_1024 1 -/* #undef OQS_ENABLE_KEM_ml_kem_1024_x86_64 */ -#define OQS_ENABLE_KEM_ml_kem_1024_aarch64 1 -/* #undef OQS_ENABLE_KEM_ml_kem_1024_cuda */ -/* #undef OQS_ENABLE_KEM_ml_kem_1024_icicle_cuda */ - -#define OQS_ENABLE_SIG_ML_DSA 1 -#define OQS_ENABLE_SIG_ml_dsa_44 1 -/* #undef OQS_ENABLE_SIG_ml_dsa_44_avx2 */ -#define OQS_ENABLE_SIG_ml_dsa_65 1 -/* #undef OQS_ENABLE_SIG_ml_dsa_65_avx2 */ -#define OQS_ENABLE_SIG_ml_dsa_87 1 -/* #undef OQS_ENABLE_SIG_ml_dsa_87_avx2 */ - -#define OQS_ENABLE_SIG_FALCON 1 -#define OQS_ENABLE_SIG_falcon_512 1 -/* #undef OQS_ENABLE_SIG_falcon_512_avx2 */ -#define OQS_ENABLE_SIG_falcon_512_aarch64 1 -#define OQS_ENABLE_SIG_falcon_1024 1 -/* #undef OQS_ENABLE_SIG_falcon_1024_avx2 */ -#define OQS_ENABLE_SIG_falcon_1024_aarch64 1 -#define OQS_ENABLE_SIG_falcon_padded_512 1 -/* #undef OQS_ENABLE_SIG_falcon_padded_512_avx2 */ -#define OQS_ENABLE_SIG_falcon_padded_512_aarch64 1 -#define OQS_ENABLE_SIG_falcon_padded_1024 1 -/* #undef OQS_ENABLE_SIG_falcon_padded_1024_avx2 */ -#define OQS_ENABLE_SIG_falcon_padded_1024_aarch64 1 - -#define OQS_ENABLE_SIG_SPHINCS 1 -#define OQS_ENABLE_SIG_sphincs_sha2_128f_simple 1 -/* #undef OQS_ENABLE_SIG_sphincs_sha2_128f_simple_avx2 */ -#define OQS_ENABLE_SIG_sphincs_sha2_128s_simple 1 -/* #undef OQS_ENABLE_SIG_sphincs_sha2_128s_simple_avx2 */ -#define OQS_ENABLE_SIG_sphincs_sha2_192f_simple 1 -/* #undef OQS_ENABLE_SIG_sphincs_sha2_192f_simple_avx2 */ -#define OQS_ENABLE_SIG_sphincs_sha2_192s_simple 1 -/* #undef OQS_ENABLE_SIG_sphincs_sha2_192s_simple_avx2 */ -#define OQS_ENABLE_SIG_sphincs_sha2_256f_simple 1 -/* #undef OQS_ENABLE_SIG_sphincs_sha2_256f_simple_avx2 */ -#define OQS_ENABLE_SIG_sphincs_sha2_256s_simple 1 -/* #undef OQS_ENABLE_SIG_sphincs_sha2_256s_simple_avx2 */ -#define OQS_ENABLE_SIG_sphincs_shake_128f_simple 1 -/* #undef OQS_ENABLE_SIG_sphincs_shake_128f_simple_avx2 */ -#define OQS_ENABLE_SIG_sphincs_shake_128s_simple 1 -/* #undef OQS_ENABLE_SIG_sphincs_shake_128s_simple_avx2 */ -#define OQS_ENABLE_SIG_sphincs_shake_192f_simple 1 -/* #undef OQS_ENABLE_SIG_sphincs_shake_192f_simple_avx2 */ -#define OQS_ENABLE_SIG_sphincs_shake_192s_simple 1 -/* #undef OQS_ENABLE_SIG_sphincs_shake_192s_simple_avx2 */ -#define OQS_ENABLE_SIG_sphincs_shake_256f_simple 1 -/* #undef OQS_ENABLE_SIG_sphincs_shake_256f_simple_avx2 */ -#define OQS_ENABLE_SIG_sphincs_shake_256s_simple 1 -/* #undef OQS_ENABLE_SIG_sphincs_shake_256s_simple_avx2 */ - -#define OQS_ENABLE_SIG_MAYO 1 -#define OQS_ENABLE_SIG_mayo_1 1 -/* #undef OQS_ENABLE_SIG_mayo_1_avx2 */ -#define OQS_ENABLE_SIG_mayo_1_neon 1 -#define OQS_ENABLE_SIG_mayo_2 1 -/* #undef OQS_ENABLE_SIG_mayo_2_avx2 */ -#define OQS_ENABLE_SIG_mayo_2_neon 1 -#define OQS_ENABLE_SIG_mayo_3 1 -/* #undef OQS_ENABLE_SIG_mayo_3_avx2 */ -#define OQS_ENABLE_SIG_mayo_3_neon 1 -#define OQS_ENABLE_SIG_mayo_5 1 -/* #undef OQS_ENABLE_SIG_mayo_5_avx2 */ -#define OQS_ENABLE_SIG_mayo_5_neon 1 - -#define OQS_ENABLE_SIG_CROSS 1 -#define OQS_ENABLE_SIG_cross_rsdp_128_balanced 1 -/* #undef OQS_ENABLE_SIG_cross_rsdp_128_balanced_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdp_128_fast 1 -/* #undef OQS_ENABLE_SIG_cross_rsdp_128_fast_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdp_128_small 1 -/* #undef OQS_ENABLE_SIG_cross_rsdp_128_small_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdp_192_balanced 1 -/* #undef OQS_ENABLE_SIG_cross_rsdp_192_balanced_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdp_192_fast 1 -/* #undef OQS_ENABLE_SIG_cross_rsdp_192_fast_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdp_192_small 1 -/* #undef OQS_ENABLE_SIG_cross_rsdp_192_small_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdp_256_balanced 1 -/* #undef OQS_ENABLE_SIG_cross_rsdp_256_balanced_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdp_256_fast 1 -/* #undef OQS_ENABLE_SIG_cross_rsdp_256_fast_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdp_256_small 1 -/* #undef OQS_ENABLE_SIG_cross_rsdp_256_small_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdpg_128_balanced 1 -/* #undef OQS_ENABLE_SIG_cross_rsdpg_128_balanced_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdpg_128_fast 1 -/* #undef OQS_ENABLE_SIG_cross_rsdpg_128_fast_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdpg_128_small 1 -/* #undef OQS_ENABLE_SIG_cross_rsdpg_128_small_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdpg_192_balanced 1 -/* #undef OQS_ENABLE_SIG_cross_rsdpg_192_balanced_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdpg_192_fast 1 -/* #undef OQS_ENABLE_SIG_cross_rsdpg_192_fast_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdpg_192_small 1 -/* #undef OQS_ENABLE_SIG_cross_rsdpg_192_small_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdpg_256_balanced 1 -/* #undef OQS_ENABLE_SIG_cross_rsdpg_256_balanced_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdpg_256_fast 1 -/* #undef OQS_ENABLE_SIG_cross_rsdpg_256_fast_avx2 */ -#define OQS_ENABLE_SIG_cross_rsdpg_256_small 1 -/* #undef OQS_ENABLE_SIG_cross_rsdpg_256_small_avx2 */ - -#define OQS_ENABLE_SIG_UOV 1 -#define OQS_ENABLE_SIG_uov_ov_Is 1 -#define OQS_ENABLE_SIG_uov_ov_Is_neon 1 -/* #undef OQS_ENABLE_SIG_uov_ov_Is_avx2 */ -#define OQS_ENABLE_SIG_uov_ov_Ip 1 -#define OQS_ENABLE_SIG_uov_ov_Ip_neon 1 -/* #undef OQS_ENABLE_SIG_uov_ov_Ip_avx2 */ -#define OQS_ENABLE_SIG_uov_ov_III 1 -#define OQS_ENABLE_SIG_uov_ov_III_neon 1 -/* #undef OQS_ENABLE_SIG_uov_ov_III_avx2 */ -#define OQS_ENABLE_SIG_uov_ov_V 1 -#define OQS_ENABLE_SIG_uov_ov_V_neon 1 -/* #undef OQS_ENABLE_SIG_uov_ov_V_avx2 */ -#define OQS_ENABLE_SIG_uov_ov_Is_pkc 1 -#define OQS_ENABLE_SIG_uov_ov_Is_pkc_neon 1 -/* #undef OQS_ENABLE_SIG_uov_ov_Is_pkc_avx2 */ -#define OQS_ENABLE_SIG_uov_ov_Ip_pkc 1 -#define OQS_ENABLE_SIG_uov_ov_Ip_pkc_neon 1 -/* #undef OQS_ENABLE_SIG_uov_ov_Ip_pkc_avx2 */ -#define OQS_ENABLE_SIG_uov_ov_III_pkc 1 -#define OQS_ENABLE_SIG_uov_ov_III_pkc_neon 1 -/* #undef OQS_ENABLE_SIG_uov_ov_III_pkc_avx2 */ -#define OQS_ENABLE_SIG_uov_ov_V_pkc 1 -#define OQS_ENABLE_SIG_uov_ov_V_pkc_neon 1 -/* #undef OQS_ENABLE_SIG_uov_ov_V_pkc_avx2 */ -#define OQS_ENABLE_SIG_uov_ov_Is_pkc_skc 1 -#define OQS_ENABLE_SIG_uov_ov_Is_pkc_skc_neon 1 -/* #undef OQS_ENABLE_SIG_uov_ov_Is_pkc_skc_avx2 */ -#define OQS_ENABLE_SIG_uov_ov_Ip_pkc_skc 1 -#define OQS_ENABLE_SIG_uov_ov_Ip_pkc_skc_neon 1 -/* #undef OQS_ENABLE_SIG_uov_ov_Ip_pkc_skc_avx2 */ -#define OQS_ENABLE_SIG_uov_ov_III_pkc_skc 1 -#define OQS_ENABLE_SIG_uov_ov_III_pkc_skc_neon 1 -/* #undef OQS_ENABLE_SIG_uov_ov_III_pkc_skc_avx2 */ -#define OQS_ENABLE_SIG_uov_ov_V_pkc_skc 1 -#define OQS_ENABLE_SIG_uov_ov_V_pkc_skc_neon 1 -/* #undef OQS_ENABLE_SIG_uov_ov_V_pkc_skc_avx2 */ - -#define OQS_ENABLE_SIG_SNOVA 1 -#define OQS_ENABLE_SIG_snova_SNOVA_24_5_4 1 -/* #undef OQS_ENABLE_SIG_snova_SNOVA_24_5_4_avx2 */ -#define OQS_ENABLE_SIG_snova_SNOVA_24_5_4_neon 1 -#define OQS_ENABLE_SIG_snova_SNOVA_24_5_4_SHAKE 1 -/* #undef OQS_ENABLE_SIG_snova_SNOVA_24_5_4_SHAKE_avx2 */ -#define OQS_ENABLE_SIG_snova_SNOVA_24_5_4_SHAKE_neon 1 -#define OQS_ENABLE_SIG_snova_SNOVA_24_5_4_esk 1 -/* #undef OQS_ENABLE_SIG_snova_SNOVA_24_5_4_esk_avx2 */ -#define OQS_ENABLE_SIG_snova_SNOVA_24_5_4_esk_neon 1 -#define OQS_ENABLE_SIG_snova_SNOVA_24_5_4_SHAKE_esk 1 -/* #undef OQS_ENABLE_SIG_snova_SNOVA_24_5_4_SHAKE_esk_avx2 */ -#define OQS_ENABLE_SIG_snova_SNOVA_24_5_4_SHAKE_esk_neon 1 -#define OQS_ENABLE_SIG_snova_SNOVA_37_17_2 1 -/* #undef OQS_ENABLE_SIG_snova_SNOVA_37_17_2_avx2 */ -#define OQS_ENABLE_SIG_snova_SNOVA_37_17_2_neon 1 -#define OQS_ENABLE_SIG_snova_SNOVA_25_8_3 1 -/* #undef OQS_ENABLE_SIG_snova_SNOVA_25_8_3_avx2 */ -#define OQS_ENABLE_SIG_snova_SNOVA_25_8_3_neon 1 -#define OQS_ENABLE_SIG_snova_SNOVA_56_25_2 1 -/* #undef OQS_ENABLE_SIG_snova_SNOVA_56_25_2_avx2 */ -#define OQS_ENABLE_SIG_snova_SNOVA_56_25_2_neon 1 -#define OQS_ENABLE_SIG_snova_SNOVA_49_11_3 1 -/* #undef OQS_ENABLE_SIG_snova_SNOVA_49_11_3_avx2 */ -#define OQS_ENABLE_SIG_snova_SNOVA_49_11_3_neon 1 -#define OQS_ENABLE_SIG_snova_SNOVA_37_8_4 1 -/* #undef OQS_ENABLE_SIG_snova_SNOVA_37_8_4_avx2 */ -#define OQS_ENABLE_SIG_snova_SNOVA_37_8_4_neon 1 -#define OQS_ENABLE_SIG_snova_SNOVA_24_5_5 1 -/* #undef OQS_ENABLE_SIG_snova_SNOVA_24_5_5_avx2 */ -#define OQS_ENABLE_SIG_snova_SNOVA_24_5_5_neon 1 -#define OQS_ENABLE_SIG_snova_SNOVA_60_10_4 1 -/* #undef OQS_ENABLE_SIG_snova_SNOVA_60_10_4_avx2 */ -#define OQS_ENABLE_SIG_snova_SNOVA_60_10_4_neon 1 -#define OQS_ENABLE_SIG_snova_SNOVA_29_6_5 1 -/* #undef OQS_ENABLE_SIG_snova_SNOVA_29_6_5_avx2 */ -#define OQS_ENABLE_SIG_snova_SNOVA_29_6_5_neon 1 -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_ADD_ALG_ENABLE_DEFINES_END -///// OQS_COPY_FROM_SLH_DSA_FRAGMENT_ADD_ALG_ENABLE_DEFINES_START -#define OQS_ENABLE_SIG_SLH_DSA 1 -#define OQS_ENABLE_SIG_slh_dsa_pure_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_pure_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_pure_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_pure_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_pure_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_pure_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_pure_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_pure_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_pure_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_pure_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_pure_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_pure_shake_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_256f 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_128s 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_128f 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_192s 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_192f 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_256s 1 -#define OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_256f 1 -///// OQS_COPY_FROM_SLH_DSA_FRAGMENT_ADD_ALG_ENABLE_DEFINES_END - -///// OQS_COPY_FROM_LIBJADE_FRAGMENT_ADD_ALG_ENABLE_DEFINES_START - -#define OQS_LIBJADE_BUILD 0 - -/* #undef OQS_ENABLE_LIBJADE_KEM_KYBER */ -/* #undef OQS_ENABLE_LIBJADE_KEM_kyber_512 */ -/* #undef OQS_ENABLE_LIBJADE_KEM_kyber_512_avx2 */ -/* #undef OQS_ENABLE_LIBJADE_KEM_kyber_768 */ -/* #undef OQS_ENABLE_LIBJADE_KEM_kyber_768_avx2 */ -///// OQS_COPY_FROM_LIBJADE_FRAGMENT_ADD_ALG_ENABLE_DEFINES_END - -/* #undef OQS_ENABLE_SIG_STFL_XMSS */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_sha256_h10 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_sha256_h16 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_sha256_h20 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_shake128_h10 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_shake128_h16 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_shake128_h20 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_sha512_h10 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_sha512_h16 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_sha512_h20 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_shake256_h10 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_shake256_h16 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_shake256_h20 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_sha256_h10_192 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_sha256_h16_192 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_sha256_h20_192 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_shake256_h10_192 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_shake256_h16_192 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_shake256_h20_192 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_shake256_h10_256 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_shake256_h16_256 */ -/* #undef OQS_ENABLE_SIG_STFL_xmss_shake256_h20_256 */ - -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_sha256_h20_2 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_sha256_h20_4 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_sha256_h40_2 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_sha256_h40_4 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_sha256_h40_8 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_sha256_h60_3 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_sha256_h60_6 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_sha256_h60_12 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_shake128_h20_2 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_shake128_h20_4 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_shake128_h40_2 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_shake128_h40_4 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_shake128_h40_8 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_shake128_h60_3 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_shake128_h60_6 */ -/* #undef OQS_ENABLE_SIG_STFL_xmssmt_shake128_h60_12 */ - - -/* #undef OQS_ENABLE_SIG_STFL_LMS */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h5_w1 */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h5_w2 */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h5_w4 */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h5_w8 */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h10_w1 */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h10_w2 */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h10_w4 */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h10_w8 */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h15_w1 */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h15_w2 */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h15_w4 */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h5_w8_h5_w8 */ -/* #undef OQS_ENABLE_SIG_STFL_lms_sha256_h10_w4_h5_w8 */ - -/* #undef OQS_HAZARDOUS_EXPERIMENTAL_ENABLE_SIG_STFL_KEY_SIG_GEN */ -/* #undef OQS_ALLOW_STFL_KEY_AND_SIG_GEN */ -/* #undef OQS_ALLOW_XMSS_KEY_AND_SIG_GEN */ -/* #undef OQS_ALLOW_LMS_KEY_AND_SIG_GEN */ diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/rand.h b/prebuilt_liboqs/linux-x86_64/include/oqs/rand.h deleted file mode 100644 index 962ce6c..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/rand.h +++ /dev/null @@ -1,66 +0,0 @@ -/** - * \file rand.h - * \brief Random number generator. - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_RANDOM_H -#define OQS_RANDOM_H - -#include -#include -#include - -#include - -#if defined(__cplusplus) -extern "C" { -#endif - -/** Algorithm identifier for system PRNG. */ -#define OQS_RAND_alg_system "system" -/** Algorithm identifier for using OpenSSL's PRNG. */ -#define OQS_RAND_alg_openssl "OpenSSL" - -/** - * Switches OQS_randombytes to use the specified algorithm. - * - * @warning In case you have set a custom algorithm using `OQS_randombytes_custom_algorithm` - * before, this function will overwrite it again. Hence, you have to set your custom - * algorithm again after calling this function. - * - * @param[in] algorithm The name of the algorithm to use. - * @return OQS_SUCCESS if `algorithm` is a supported algorithm name, OQS_ERROR otherwise. - */ -OQS_API OQS_STATUS OQS_randombytes_switch_algorithm(const char *algorithm); - -/** - * Switches OQS_randombytes to use the given function. - * - * This allows additional custom RNGs besides the provided ones. The provided RNG - * function must have the same signature as `OQS_randombytes`. - * - * @param[in] algorithm_ptr Pointer to the RNG function to use. - */ -OQS_API void OQS_randombytes_custom_algorithm(void (*algorithm_ptr)(uint8_t *, size_t)); - -/** - * Fills the given memory with the requested number of (pseudo)random bytes. - * - * This implementation uses whichever algorithm has been selected by - * OQS_randombytes_switch_algorithm. The default is OQS_randombytes_system, which - * reads bytes from a system specific default source. - * - * The caller is responsible for providing a buffer allocated with sufficient room. - * - * @param[out] random_array Pointer to the memory to fill with (pseudo)random bytes - * @param[in] bytes_to_read The number of random bytes to read into memory - */ -OQS_API void OQS_randombytes(uint8_t *random_array, size_t bytes_to_read); - -#if defined(__cplusplus) -} // extern "C" -#endif - -#endif // OQS_RANDOM_H diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/rand_nist.h b/prebuilt_liboqs/linux-x86_64/include/oqs/rand_nist.h deleted file mode 100644 index d124773..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/rand_nist.h +++ /dev/null @@ -1,47 +0,0 @@ -/** - * \file rand_nist.h - * \brief NIST DRBG - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_RAND_NIST_H -#define OQS_RAND_NIST_H - -#include -#include - -typedef struct { - unsigned char Key[32]; - unsigned char V[16]; - int reseed_counter; -} OQS_NIST_DRBG_struct; - -/** - * Initializes the NIST DRBG with a given seed and with 256-bit security. - * - * @param[in] entropy_input The seed; must be exactly 48 bytes - * @param[in] personalization_string An optional personalization string; - * may be NULL; if not NULL, must be at least 48 bytes long - */ -void OQS_randombytes_nist_kat_init_256bit(const uint8_t *entropy_input, const uint8_t *personalization_string); - -/** - * Fills the given memory with the requested number of pseudorandom bytes using the NIST DRBG. - * - * @param[out] random_array Pointer to the memory to fill with (pseudo)random bytes - * @param[in] bytes_to_read The number of random bytes to read into memory - */ -void OQS_randombytes_nist_kat(uint8_t *random_array, size_t bytes_to_read); - -/** - * Writes the current state of the NIST DRBG into the provided memory. - */ -void OQS_randombytes_nist_kat_get_state(void *out); - -/** - * Overwrites the current state of the NIST DRBG from the provided memory. - */ -void OQS_randombytes_nist_kat_set_state(const void *in); - -#endif // OQS_RAND_NIST_H diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/sha2.h b/prebuilt_liboqs/linux-x86_64/include/oqs/sha2.h deleted file mode 100644 index e7aaf54..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/sha2.h +++ /dev/null @@ -1,246 +0,0 @@ -/** - * \file sha2.h - * \brief SHA2 functions; not part of the OQS public API - * - * Contains the API and documentation for SHA2 digest implementation - * - * Note this is not part of the OQS public API: implementations within liboqs can use these - * functions, but external consumers of liboqs should not use these functions. - * - * \author Douglas Stebila - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_SHA2_H -#define OQS_SHA2_H - -#include -#include - -#include - -#if defined(__cplusplus) -extern "C" { -#endif - -/** - * \brief Process a message with SHA-256 and return the hash code in the output byte array. - * - * \warning The output array must be at least 32 bytes in length. - * - * \param output The output byte array - * \param input The message input byte array - * \param inplen The number of message bytes to process - */ -void OQS_SHA2_sha256(uint8_t *output, const uint8_t *input, size_t inplen); - -/** - * \brief Allocate and initialize the state for the SHA-256 incremental hashing API. - * - * \warning The state must be released by OQS_SHA2_sha256_inc_finalize - * or OQS_SHA2_sha256_inc_ctx_release. - * - * \param state Pointer to the state - */ -void OQS_SHA2_sha256_inc_init(OQS_SHA2_sha256_ctx *state); - -/** - * \brief Duplicate state for the SHA-256 incremental hashing API. - * - * \warning dest must be allocated by the caller. Caller is responsible - * for releasing dest by calling either OQS_SHA2_sha256_inc_finalize or - * OQS_SHA2_sha256_inc_ctx_release. - * - * \param dest The function state to copy into; must be initialized - * \param src The function state to copy; must be initialized - */ -void OQS_SHA2_sha256_inc_ctx_clone(OQS_SHA2_sha256_ctx *dest, const OQS_SHA2_sha256_ctx *src); - -/** - * \brief Process blocks with SHA-256 and update the state. - * - * \warning The state must be initialized by OQS_SHA2_sha256_inc_init or OQS_SHA2_sha256_inc_ctx_clone. - * - * \param state The state to update - * \param in Message input byte array - * \param inblocks The number of 64-byte blocks of message bytes to process - */ -void OQS_SHA2_sha256_inc_blocks(OQS_SHA2_sha256_ctx *state, const uint8_t *in, size_t inblocks); - -/** - * \brief Process message bytes with SHA-256 and update the state. - * - * \warning The state must be initialized by OQS_SHA2_sha256_inc_init or OQS_SHA2_sha256_inc_ctx_clone. - * - * \param state The state to update - * \param in Message input byte array - * \param len The number of bytes of message to process - */ -void OQS_SHA2_sha256_inc(OQS_SHA2_sha256_ctx *state, const uint8_t *in, size_t len); - -/** - * \brief Process more message bytes with SHA-256 and return the hash code in the output byte array. - * - * \warning The output array must be at least 32 bytes in length. The state is - * deallocated by this function and can not be used again after calling - * this function without calling OQS_SHA2_sha256_inc_init again. - * - * \param out The output byte array - * \param state The state - * \param in Additional message input byte array - * \param inlen The number of additional message bytes to process - */ -void OQS_SHA2_sha256_inc_finalize(uint8_t *out, OQS_SHA2_sha256_ctx *state, const uint8_t *in, size_t inlen); - -/** - * \brief Destroy state. - * - * \warning The state is deallocated by this function and can not be used again after calling - * this function without calling OQS_SHA2_sha256_inc_init again. - * - * \param state The state - */ -void OQS_SHA2_sha256_inc_ctx_release(OQS_SHA2_sha256_ctx *state); - -/** - * \brief Process a message with SHA-384 and return the hash code in the output byte array. - * - * \warning The output array must be at least 48 bytes in length. - * - * \param output The output byte array - * \param input The message input byte array - * \param inplen The number of message bytes to process - */ -void OQS_SHA2_sha384(uint8_t *output, const uint8_t *input, size_t inplen); - -/** - * \brief Allocate and initialize the state for the SHA-384 incremental hashing API. - * - * \warning The state must be released by OQS_SHA2_sha384_inc_finalize - * or OQS_SHA2_sha384_inc_ctx_release. - * - * \param state Pointer to the state - */ -void OQS_SHA2_sha384_inc_init(OQS_SHA2_sha384_ctx *state); - -/** - * \brief Duplicate state for the SHA-384 incremental hashing API. - * - * \warning dest must be allocated by the caller. Caller is responsible - * for releasing dest by calling either OQS_SHA2_sha384_inc_finalize or - * OQS_SHA2_sha384_inc_ctx_release. - * - * \param dest The function state to copy into; must be initialized - * \param src The function state to copy; must be initialized - */ -void OQS_SHA2_sha384_inc_ctx_clone(OQS_SHA2_sha384_ctx *dest, const OQS_SHA2_sha384_ctx *src); - -/** - * \brief Process blocks with SHA-384 and update the state. - * - * \warning The state must be initialized by OQS_SHA2_sha384_inc_init or OQS_SHA2_sha384_inc_ctx_clone. - * - * \param state The state to update - * \param in Message input byte array - * \param inblocks The number of 128-byte blocks of message bytes to process - */ -void OQS_SHA2_sha384_inc_blocks(OQS_SHA2_sha384_ctx *state, const uint8_t *in, size_t inblocks); - -/** - * \brief Process more message bytes with SHA-384 and return the hash code in the output byte array. - * - * \warning The output array must be at least 48 bytes in length. The state is - * deallocated by this function and can not be used again after calling - * this function without calling OQS_SHA2_sha384_inc_init again. - * - * \param out The output byte array - * \param state The state - * \param in Additional message input byte array - * \param inlen The number of additional message bytes to process - */ -void OQS_SHA2_sha384_inc_finalize(uint8_t *out, OQS_SHA2_sha384_ctx *state, const uint8_t *in, size_t inlen); - -/** - * \brief Destroy state. - * - * \warning The state is deallocated by this function and can not be used again after calling - * this function without calling OQS_SHA2_sha384_inc_init again. - * - * \param state The state - */ -void OQS_SHA2_sha384_inc_ctx_release(OQS_SHA2_sha384_ctx *state); - -/** - * \brief Process a message with SHA-512 and return the hash code in the output byte array. - * - * \warning The output array must be at least 64 bytes in length. - * - * \param output The output byte array - * \param input The message input byte array - * \param inplen The number of message bytes to process - */ -void OQS_SHA2_sha512(uint8_t *output, const uint8_t *input, size_t inplen); - -/** - * \brief Allocate and initialize the state for the SHA-512 incremental hashing API. - * - * \warning The state must be released by OQS_SHA2_sha512_inc_finalize - * or OQS_SHA2_sha512_inc_ctx_release. - * - * \param state Pointer to the state - */ -void OQS_SHA2_sha512_inc_init(OQS_SHA2_sha512_ctx *state); - -/** - * \brief Duplicate state for the SHA-512 incremental hashing API. - * - * \warning dest must be allocated by the caller. Caller is responsible - * for releasing dest by calling either OQS_SHA2_sha512_inc_finalize or - * OQS_SHA2_sha512_inc_ctx_release. - * - * \param dest The function state to copy into; must be initialized - * \param src The function state to copy; must be initialized - */ -void OQS_SHA2_sha512_inc_ctx_clone(OQS_SHA2_sha512_ctx *dest, const OQS_SHA2_sha512_ctx *src); - -/** - * \brief Process blocks with SHA-512 and update the state. - * - * \warning The state must be initialized by OQS_SHA2_sha512_inc_init or OQS_SHA2_sha512_inc_ctx_clone. - * - * \param state The state to update - * \param in Message input byte array - * \param inblocks The number of 128-byte blocks of message bytes to process - */ -void OQS_SHA2_sha512_inc_blocks(OQS_SHA2_sha512_ctx *state, const uint8_t *in, size_t inblocks); - -/** - * \brief Process more message bytes with SHA-512 and return the hash code in the output byte array. - * - * \warning The output array must be at least 64 bytes in length. The state is - * deallocated by this function and can not be used again after calling - * this function without calling OQS_SHA2_sha512_inc_init again. - * - * \param out The output byte array - * \param state The state - * \param in Additional message input byte array - * \param inlen The number of additional message bytes to process - */ -void OQS_SHA2_sha512_inc_finalize(uint8_t *out, OQS_SHA2_sha512_ctx *state, const uint8_t *in, size_t inlen); - -/** - * \brief Destroy state. - * - * \warning The state is deallocated by this function and can not be used again after calling - * this function without calling OQS_SHA2_sha512_inc_init again. - * - * \param state The state - */ -void OQS_SHA2_sha512_inc_ctx_release(OQS_SHA2_sha512_ctx *state); - -#if defined(__cplusplus) -} // extern "C" -#endif - -#endif // OQS_SHA2_H diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/sha2_ops.h b/prebuilt_liboqs/linux-x86_64/include/oqs/sha2_ops.h deleted file mode 100644 index 7b8ae8c..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/sha2_ops.h +++ /dev/null @@ -1,176 +0,0 @@ -/** - * \file sha2_ops.h - * \brief Header defining the callback API for OQS SHA2 - * - * \author Douglas Stebila - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_SHA2_OPS_H -#define OQS_SHA2_OPS_H - -#include -#include - -#include - -#if defined(__cplusplus) -extern "C" { -#endif - -/** Data structure for the state of the SHA-224 incremental hashing API. */ -typedef struct { - /** Internal state */ - void *ctx; - /** current number of bytes in data */ - size_t data_len; - /** unprocessed data buffer */ - uint8_t data[128]; -} OQS_SHA2_sha224_ctx; - -/** Data structure for the state of the SHA-256 incremental hashing API. */ -typedef struct { - /** Internal state */ - void *ctx; - /** current number of bytes in data */ - size_t data_len; - /** unprocessed data buffer */ - uint8_t data[128]; -} OQS_SHA2_sha256_ctx; - -/** Data structure for the state of the SHA-384 incremental hashing API. */ -typedef struct { - /** Internal state. */ - void *ctx; - /** current number of bytes in data */ - size_t data_len; - /** unprocessed data buffer */ - uint8_t data[128]; -} OQS_SHA2_sha384_ctx; - -/** Data structure for the state of the SHA-512 incremental hashing API. */ -typedef struct { - /** Internal state. */ - void *ctx; - /** current number of bytes in data */ - size_t data_len; - /** unprocessed data buffer */ - uint8_t data[128]; -} OQS_SHA2_sha512_ctx; - -/** Data structure implemented by cryptographic provider for SHA-2 operations. - */ -struct OQS_SHA2_callbacks { - /** - * Implementation of function OQS_SHA2_sha256. - */ - void (*SHA2_sha256)(uint8_t *output, const uint8_t *input, size_t inplen); - - /** - * Implementation of function OQS_SHA2_sha256_inc_init. - */ - void (*SHA2_sha256_inc_init)(OQS_SHA2_sha256_ctx *state); - - /** - * Implementation of function OQS_SHA2_sha256_inc_ctx_clone. - */ - void (*SHA2_sha256_inc_ctx_clone)(OQS_SHA2_sha256_ctx *dest, const OQS_SHA2_sha256_ctx *src); - - /** - * Implementation of function OQS_SHA2_sha256_inc. - */ - void (*SHA2_sha256_inc)(OQS_SHA2_sha256_ctx *state, const uint8_t *in, size_t len); - - /** - * Implementation of function OQS_SHA2_sha256_inc_blocks. - */ - void (*SHA2_sha256_inc_blocks)(OQS_SHA2_sha256_ctx *state, const uint8_t *in, size_t inblocks); - - /** - * Implementation of function OQS_SHA2_sha256_inc_finalize. - */ - void (*SHA2_sha256_inc_finalize)(uint8_t *out, OQS_SHA2_sha256_ctx *state, const uint8_t *in, size_t inlen); - - /** - * Implementation of function OQS_SHA2_sha256_inc_ctx_release. - */ - void (*SHA2_sha256_inc_ctx_release)(OQS_SHA2_sha256_ctx *state); - - /** - * Implementation of function OQS_SHA2_sha384. - */ - void (*SHA2_sha384)(uint8_t *output, const uint8_t *input, size_t inplen); - - /** - * Implementation of function OQS_SHA2_sha384_inc_init. - */ - void (*SHA2_sha384_inc_init)(OQS_SHA2_sha384_ctx *state); - - /** - * Implementation of function OQS_SHA2_sha384_inc_ctx_clone. - */ - void (*SHA2_sha384_inc_ctx_clone)(OQS_SHA2_sha384_ctx *dest, const OQS_SHA2_sha384_ctx *src); - - /** - * Implementation of function OQS_SHA2_sha384_inc_blocks. - */ - void (*SHA2_sha384_inc_blocks)(OQS_SHA2_sha384_ctx *state, const uint8_t *in, size_t inblocks); - - /** - * Implementation of function OQS_SHA2_sha384_inc_finalize. - */ - void (*SHA2_sha384_inc_finalize)(uint8_t *out, OQS_SHA2_sha384_ctx *state, const uint8_t *in, size_t inlen); - - /** - * Implementation of function OQS_SHA2_sha384_inc_ctx_release. - */ - void (*SHA2_sha384_inc_ctx_release)(OQS_SHA2_sha384_ctx *state); - - /** - * Implementation of function OQS_SHA2_sha512. - */ - void (*SHA2_sha512)(uint8_t *output, const uint8_t *input, size_t inplen); - - /** - * Implementation of function OQS_SHA2_sha512_inc_init. - */ - void (*SHA2_sha512_inc_init)(OQS_SHA2_sha512_ctx *state); - - /** - * Implementation of function OQS_SHA2_sha512_inc_ctx_clone. - */ - void (*SHA2_sha512_inc_ctx_clone)(OQS_SHA2_sha512_ctx *dest, const OQS_SHA2_sha512_ctx *src); - - /** - * Implementation of function OQS_SHA2_sha512_inc_blocks. - */ - void (*SHA2_sha512_inc_blocks)(OQS_SHA2_sha512_ctx *state, const uint8_t *in, size_t inblocks); - - /** - * Implementation of function OQS_SHA2_sha512_inc_finalize. - */ - void (*SHA2_sha512_inc_finalize)(uint8_t *out, OQS_SHA2_sha512_ctx *state, const uint8_t *in, size_t inlen); - - /** - * Implementation of function OQS_SHA2_sha512_inc_ctx_release. - */ - void (*SHA2_sha512_inc_ctx_release)(OQS_SHA2_sha512_ctx *state); -}; - -/** - * Set callback functions for SHA2 operations. - * - * This function may be called before OQS_init to switch the - * cryptographic provider for SHA2 operations. If it is not called, - * the default provider determined at build time will be used. - * - * @param[in] new_callbacks Callback functions defined in OQS_SHA2_callbacks - */ -OQS_API void OQS_SHA2_set_callbacks(struct OQS_SHA2_callbacks *new_callbacks); - -#if defined(__cplusplus) -} // extern "C" -#endif - -#endif // OQS_SHA2_OPS_H diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/sha3.h b/prebuilt_liboqs/linux-x86_64/include/oqs/sha3.h deleted file mode 100644 index 7fa9c9a..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/sha3.h +++ /dev/null @@ -1,400 +0,0 @@ -/** - * \file sha3.h - * \brief SHA3 and SHAKE functions; not part of the OQS public API - * - * Contains the API and documentation for SHA3 digest and SHAKE implementations. - * - * Note this is not part of the OQS public API: implementations within liboqs can use these - * functions, but external consumers of liboqs should not use these functions. - * - * \author John Underhill, Douglas Stebila - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_SHA3_H -#define OQS_SHA3_H - -#include -#include - -#include - -#if defined(__cplusplus) -extern "C" { -#endif - -/* SHA3 */ - -/** The SHA-256 byte absorption rate */ -#define OQS_SHA3_SHA3_256_RATE 136 - -/** - * \brief Process a message with SHA3-256 and return the digest in the output byte array. - * - * \warning The output array must be at least 32 bytes in length. - * - * \param output The output byte array - * \param input The message input byte array - * \param inplen The number of message bytes to process - */ -void OQS_SHA3_sha3_256(uint8_t *output, const uint8_t *input, size_t inplen); - -/** - * \brief Initialize the state for the incremental SHA3-256 API. - * - * \warning Caller is responsible for releasing state by calling - * OQS_SHA3_sha3_256_inc_ctx_release. - * - * \param state The function state to be allocated and initialized. - */ -void OQS_SHA3_sha3_256_inc_init(OQS_SHA3_sha3_256_inc_ctx *state); - -/** - * \brief The SHA3-256 absorb function. - * Absorb an input into the state. - * - * \param state The function state; must be initialized - * \param input The input array - * \param inlen The length of the input - */ -void OQS_SHA3_sha3_256_inc_absorb(OQS_SHA3_sha3_256_inc_ctx *state, const uint8_t *input, size_t inlen); - -/** - * \brief The SHA3-256 finalize-and-squeeze function. - * Finalizes the state and squeezes a 32 byte digest. - * - * \warning Output array must be at least 32 bytes. - * State cannot be used after this without calling OQS_SHA3_sha3_256_inc_reset. - * - * \param output The output byte array - * \param state The function state; must be initialized - */ -void OQS_SHA3_sha3_256_inc_finalize(uint8_t *output, OQS_SHA3_sha3_256_inc_ctx *state); - -/** - * \brief Release the state for the SHA3-256 incremental API. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_sha3_256_inc_ctx_release(OQS_SHA3_sha3_256_inc_ctx *state); - -/** - * \brief Resets the state for the SHA3-256 incremental API. - * Alternative to freeing and reinitializing the state. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_sha3_256_inc_ctx_reset(OQS_SHA3_sha3_256_inc_ctx *state); - -/** - * \brief Clone the state for the SHA3-256 incremental API. - * - * \param dest The function state to copy into; must be initialized - * \param src The function state to copy; must be initialized - */ -void OQS_SHA3_sha3_256_inc_ctx_clone(OQS_SHA3_sha3_256_inc_ctx *dest, const OQS_SHA3_sha3_256_inc_ctx *src); - -/** The SHA-384 byte absorption rate */ -#define OQS_SHA3_SHA3_384_RATE 104 - -/** - * \brief Process a message with SHA3-384 and return the digest in the output byte array. - * - * \warning The output array must be at least 48 bytes in length. - * - * \param output The output byte array - * \param input The message input byte array - * \param inplen The number of message bytes to process - */ -void OQS_SHA3_sha3_384(uint8_t *output, const uint8_t *input, size_t inplen); - -/** - * \brief Initialize the state for the incremental SHA3-384 API. - * - * \warning Caller is responsible for releasing state by calling - * OQS_SHA3_sha3_384_inc_ctx_release. - * - * \param state The function state to be allocated and initialized. - */ -void OQS_SHA3_sha3_384_inc_init(OQS_SHA3_sha3_384_inc_ctx *state); - -/** - * \brief The SHA3-384 absorb function. - * Absorb an input into the state. - * - * \param state The function state; must be initialized - * \param input The input array - * \param inlen The length of the input - */ -void OQS_SHA3_sha3_384_inc_absorb(OQS_SHA3_sha3_384_inc_ctx *state, const uint8_t *input, size_t inlen); - -/** - * \brief The SHA3-384 finalize-and-squeeze function. - * Finalizes the state and squeezes a 48 byte digest. - * - * \warning Output array must be at least 48 bytes. - * State cannot be used after this without calling OQS_SHA3_sha3_384_inc_reset. - * - * \param output The output byte array - * \param state The function state; must be initialized - */ -void OQS_SHA3_sha3_384_inc_finalize(uint8_t *output, OQS_SHA3_sha3_384_inc_ctx *state); - -/** - * \brief Release the state for the SHA3-384 incremental API. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_sha3_384_inc_ctx_release(OQS_SHA3_sha3_384_inc_ctx *state); - -/** - * \brief Resets the state for the SHA3-384 incremental API. - * Alternative to freeing and reinitializing the state. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_sha3_384_inc_ctx_reset(OQS_SHA3_sha3_384_inc_ctx *state); - -/** - * \brief Clone the state for the SHA3-384 incremental API. - * - * \param dest The function state to copy into; must be initialized - * \param src The function state to copy; must be initialized - */ -void OQS_SHA3_sha3_384_inc_ctx_clone(OQS_SHA3_sha3_384_inc_ctx *dest, const OQS_SHA3_sha3_384_inc_ctx *src); - -/** The SHA-512 byte absorption rate */ -#define OQS_SHA3_SHA3_512_RATE 72 - -/** - * \brief Process a message with SHA3-512 and return the digest in the output byte array. - * - * \warning The output array must be at least 64 bytes in length. - * - * \param output The output byte array - * \param input The message input byte array - * \param inplen The number of message bytes to process - */ -void OQS_SHA3_sha3_512(uint8_t *output, const uint8_t *input, size_t inplen); - -/** - * \brief Initialize the state for the incremental SHA3-512 API. - * - * \warning Caller is responsible for releasing state by calling - * OQS_SHA3_sha3_512_inc_ctx_release. - * - * \param state The function state to be allocated and initialized. - */ -void OQS_SHA3_sha3_512_inc_init(OQS_SHA3_sha3_512_inc_ctx *state); - -/** - * \brief The SHA3-512 absorb function. - * Absorb an input into the state. - * - * \param state The function state; must be initialized - * \param input The input array - * \param inlen The length of the input - */ -void OQS_SHA3_sha3_512_inc_absorb(OQS_SHA3_sha3_512_inc_ctx *state, const uint8_t *input, size_t inlen); - -/** - * \brief The SHA3-512 finalize-and-squeeze function. - * Finalizes the state and squeezes a 64 byte digest. - * - * \warning Output array must be at least 64 bytes. - * State cannot be used after this without calling OQS_SHA3_sha3_512_inc_reset. - * - * \param output The output byte array - * \param state The function state; must be initialized - */ -void OQS_SHA3_sha3_512_inc_finalize(uint8_t *output, OQS_SHA3_sha3_512_inc_ctx *state); - -/** - * \brief Release the state for the SHA3-512 incremental API. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_sha3_512_inc_ctx_release(OQS_SHA3_sha3_512_inc_ctx *state); - -/** - * \brief Resets the state for the SHA3-512 incremental API. - * Alternative to freeing and reinitializing the state. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_sha3_512_inc_ctx_reset(OQS_SHA3_sha3_512_inc_ctx *state); - -/** - * \brief Clone the state for the SHA3-512 incremental API. - * - * \param dest The function state to copy into; must be initialized - * \param src The function state to copy; must be initialized - */ -void OQS_SHA3_sha3_512_inc_ctx_clone(OQS_SHA3_sha3_512_inc_ctx *dest, const OQS_SHA3_sha3_512_inc_ctx *src); - -/* SHAKE */ - -/** The SHAKE-128 byte absorption rate */ -#define OQS_SHA3_SHAKE128_RATE 168 - -/** - * \brief Seed a SHAKE-128 instance, and generate an array of pseudo-random bytes. - * - * \warning The output array length must not be zero. - * - * \param output The output byte array - * \param outlen The number of output bytes to generate - * \param input The input seed byte array - * \param inplen The number of seed bytes to process - */ -void OQS_SHA3_shake128(uint8_t *output, size_t outlen, const uint8_t *input, size_t inplen); - -/** - * \brief Initialize the state for the incremental SHAKE-128 API. - * - * \warning Caller is responsible for releasing state by calling - * OQS_SHA3_shake128_inc_ctx_release. - * - * \param state The function state to be initialized; must be allocated - */ -void OQS_SHA3_shake128_inc_init(OQS_SHA3_shake128_inc_ctx *state); - -/** - * \brief The SHAKE-128 absorb function. - * Absorb an input into the state. - * - * \warning State must be initialized. - * - * \param state The function state; must be initialized - * \param input input buffer - * \param inlen length of input buffer - */ -void OQS_SHA3_shake128_inc_absorb(OQS_SHA3_shake128_inc_ctx *state, const uint8_t *input, size_t inlen); - -/** - * \brief The SHAKE-128 finalize function. - * Prepares the state for squeezing. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_shake128_inc_finalize(OQS_SHA3_shake128_inc_ctx *state); - -/** - * \brief The SHAKE-128 squeeze function. - * Extracts to an output byte array. - * - * \param output output buffer - * \param outlen bytes of outbut buffer - * \param state The function state; must be initialized and finalized - */ -void OQS_SHA3_shake128_inc_squeeze(uint8_t *output, size_t outlen, OQS_SHA3_shake128_inc_ctx *state); - -/** - * \brief Frees the state for the incremental SHAKE-128 API. - * - * \param state The state to free - */ -void OQS_SHA3_shake128_inc_ctx_release(OQS_SHA3_shake128_inc_ctx *state); - -/** - * \brief Copies the state for the SHAKE-128 incremental API. - * - * \warning Caller is responsible for releasing dest by calling - * OQS_SHA3_shake128_inc_ctx_release. - * - * \param dest The function state to copy into; must be initialized - * \param src The function state to copy; must be initialized - */ -void OQS_SHA3_shake128_inc_ctx_clone(OQS_SHA3_shake128_inc_ctx *dest, const OQS_SHA3_shake128_inc_ctx *src); - -/** - * \brief Resets the state for the SHAKE-128 incremental API. Allows a context - * to be re-used without free and init calls. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_shake128_inc_ctx_reset(OQS_SHA3_shake128_inc_ctx *state); - -/** The SHAKE-256 byte absorption rate */ -#define OQS_SHA3_SHAKE256_RATE 136 - -/** - * \brief Seed a SHAKE-256 instance, and generate an array of pseudo-random bytes. - * - * \warning The output array length must not be zero. - * - * \param output The output byte array - * \param outlen The number of output bytes to generate - * \param input The input seed byte array - * \param inplen The number of seed bytes to process - */ -void OQS_SHA3_shake256(uint8_t *output, size_t outlen, const uint8_t *input, size_t inplen); - -/** - * \brief Initialize the state for the incremental SHAKE-256 API. - * - * \param state The function state to be initialized; must be allocated - */ -void OQS_SHA3_shake256_inc_init(OQS_SHA3_shake256_inc_ctx *state); - -/** - * \brief The SHAKE-256 absorb function. - * Absorb an input message array directly into the state. - * - * \warning State must be initialized by the caller. - * - * \param state The function state; must be initialized - * \param input input buffer - * \param inlen length of input buffer - */ -void OQS_SHA3_shake256_inc_absorb(OQS_SHA3_shake256_inc_ctx *state, const uint8_t *input, size_t inlen); - -/** - * \brief The SHAKE-256 finalize function. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_shake256_inc_finalize(OQS_SHA3_shake256_inc_ctx *state); - -/** - * \brief The SHAKE-256 squeeze function. - * Extracts to an output byte array. - * - * \param output output buffer - * \param outlen bytes of outbut buffer - * \param state The function state; must be initialized - */ -void OQS_SHA3_shake256_inc_squeeze(uint8_t *output, size_t outlen, OQS_SHA3_shake256_inc_ctx *state); - -/** - * \brief Frees the state for the incremental SHAKE-256 API. - * - * \param state The state to free - */ -void OQS_SHA3_shake256_inc_ctx_release(OQS_SHA3_shake256_inc_ctx *state); - -/** - * \brief Copies the state for the incremental SHAKE-256 API. - * - * \warning dest must be allocated. dest must be freed by calling - * OQS_SHA3_shake256_inc_ctx_release. - * - * \param dest The state to copy into; must be initialized - * \param src The state to copy from; must be initialized - */ -void OQS_SHA3_shake256_inc_ctx_clone(OQS_SHA3_shake256_inc_ctx *dest, const OQS_SHA3_shake256_inc_ctx *src); - -/** - * \brief Resets the state for the SHAKE-256 incremental API. Allows a context - * to be re-used without free and init calls. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_shake256_inc_ctx_reset(OQS_SHA3_shake256_inc_ctx *state); - -#if defined(__cplusplus) -} // extern "C" -#endif - -#endif // OQS_SHA3_H diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/sha3_ops.h b/prebuilt_liboqs/linux-x86_64/include/oqs/sha3_ops.h deleted file mode 100644 index 694fc21..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/sha3_ops.h +++ /dev/null @@ -1,256 +0,0 @@ -/** - * \file sha3_ops.h - * \brief Header defining the callback API for OQS SHA3 and SHAKE - * - * \author John Underhill, Douglas Stebila - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_SHA3_OPS_H -#define OQS_SHA3_OPS_H - -#include -#include - -#include - -#if defined(__cplusplus) -extern "C" { -#endif - -/** Data structure for the state of the incremental SHA3-256 API. */ -typedef struct { - /** Internal state. */ - void *ctx; -} OQS_SHA3_sha3_256_inc_ctx; - -/** Data structure for the state of the incremental SHA3-384 API. */ -typedef struct { - /** Internal state. */ - void *ctx; -} OQS_SHA3_sha3_384_inc_ctx; - -/** Data structure for the state of the incremental SHA3-512 API. */ -typedef struct { - /** Internal state. */ - void *ctx; -} OQS_SHA3_sha3_512_inc_ctx; - -/** Data structure for the state of the incremental SHAKE-128 API. */ -typedef struct { - /** Internal state. */ - void *ctx; -} OQS_SHA3_shake128_inc_ctx; - -/** Data structure for the state of the incremental SHAKE-256 API. */ -typedef struct { - /** Internal state. */ - void *ctx; -} OQS_SHA3_shake256_inc_ctx; - -/** Data structure implemented by cryptographic provider for SHA-3 operations. - */ -struct OQS_SHA3_callbacks { - /** - * Implementation of function OQS_SHA3_sha3_256. - */ - void (*SHA3_sha3_256)(uint8_t *output, const uint8_t *input, size_t inplen); - - /** - * Implementation of function OQS_SHA3_sha3_256_inc_init. - */ - void (*SHA3_sha3_256_inc_init)(OQS_SHA3_sha3_256_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_sha3_256_inc_absorb. - */ - void (*SHA3_sha3_256_inc_absorb)(OQS_SHA3_sha3_256_inc_ctx *state, const uint8_t *input, size_t inlen); - - /** - * Implementation of function OQS_SHA3_sha3_256_inc_finalize. - */ - void (*SHA3_sha3_256_inc_finalize)(uint8_t *output, OQS_SHA3_sha3_256_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_sha3_256_inc_ctx_release. - */ - void (*SHA3_sha3_256_inc_ctx_release)(OQS_SHA3_sha3_256_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_sha3_256_inc_ctx_reset. - */ - void (*SHA3_sha3_256_inc_ctx_reset)(OQS_SHA3_sha3_256_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_sha3_256_inc_ctx_clone. - */ - void (*SHA3_sha3_256_inc_ctx_clone)(OQS_SHA3_sha3_256_inc_ctx *dest, const OQS_SHA3_sha3_256_inc_ctx *src); - - /** - * Implementation of function OQS_SHA3_sha3_384. - */ - void (*SHA3_sha3_384)(uint8_t *output, const uint8_t *input, size_t inplen); - - /** - * Implementation of function OQS_SHA3_sha3_384_inc_init. - */ - void (*SHA3_sha3_384_inc_init)(OQS_SHA3_sha3_384_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_sha3_384_inc_absorb. - */ - void (*SHA3_sha3_384_inc_absorb)(OQS_SHA3_sha3_384_inc_ctx *state, const uint8_t *input, size_t inlen); - - /** - * Implementation of function OQS_SHA3_sha3_384_inc_finalize. - */ - void (*SHA3_sha3_384_inc_finalize)(uint8_t *output, OQS_SHA3_sha3_384_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_sha3_384_inc_ctx_release. - */ - void (*SHA3_sha3_384_inc_ctx_release)(OQS_SHA3_sha3_384_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_sha3_384_inc_ctx_reset. - */ - void (*SHA3_sha3_384_inc_ctx_reset)(OQS_SHA3_sha3_384_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_sha3_384_inc_ctx_clone. - */ - void (*SHA3_sha3_384_inc_ctx_clone)(OQS_SHA3_sha3_384_inc_ctx *dest, const OQS_SHA3_sha3_384_inc_ctx *src); - - /** - * Implementation of function OQS_SHA3_sha3_512. - */ - void (*SHA3_sha3_512)(uint8_t *output, const uint8_t *input, size_t inplen); - - /** - * Implementation of function OQS_SHA3_sha3_512_inc_init. - */ - void (*SHA3_sha3_512_inc_init)(OQS_SHA3_sha3_512_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_sha3_512_inc_absorb. - */ - void (*SHA3_sha3_512_inc_absorb)(OQS_SHA3_sha3_512_inc_ctx *state, const uint8_t *input, size_t inlen); - - /** - * Implementation of function OQS_SHA3_sha3_512_inc_finalize. - */ - void (*SHA3_sha3_512_inc_finalize)(uint8_t *output, OQS_SHA3_sha3_512_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_sha3_512_inc_ctx_release. - */ - void (*SHA3_sha3_512_inc_ctx_release)(OQS_SHA3_sha3_512_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_sha3_512_inc_ctx_reset. - */ - void (*SHA3_sha3_512_inc_ctx_reset)(OQS_SHA3_sha3_512_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_sha3_512_inc_ctx_clone. - */ - void (*SHA3_sha3_512_inc_ctx_clone)(OQS_SHA3_sha3_512_inc_ctx *dest, const OQS_SHA3_sha3_512_inc_ctx *src); - - /** - * Implementation of function OQS_SHA3_shake128. - */ - void (*SHA3_shake128)(uint8_t *output, size_t outlen, const uint8_t *input, size_t inplen); - - /** - * Implementation of function OQS_SHA3_shake128_inc_init. - */ - void (*SHA3_shake128_inc_init)(OQS_SHA3_shake128_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake128_inc_absorb. - */ - void (*SHA3_shake128_inc_absorb)(OQS_SHA3_shake128_inc_ctx *state, const uint8_t *input, size_t inlen); - - /** - * Implementation of function OQS_SHA3_shake128_inc_finalize. - */ - void (*SHA3_shake128_inc_finalize)(OQS_SHA3_shake128_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake128_inc_squeeze. - */ - void (*SHA3_shake128_inc_squeeze)(uint8_t *output, size_t outlen, OQS_SHA3_shake128_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake128_inc_ctx_release. - */ - void (*SHA3_shake128_inc_ctx_release)(OQS_SHA3_shake128_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake128_inc_ctx_clone. - */ - void (*SHA3_shake128_inc_ctx_clone)(OQS_SHA3_shake128_inc_ctx *dest, const OQS_SHA3_shake128_inc_ctx *src); - - /** - * Implementation of function OQS_SHA3_shake128_inc_ctx_reset. - */ - void (*SHA3_shake128_inc_ctx_reset)(OQS_SHA3_shake128_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake256. - */ - void (*SHA3_shake256)(uint8_t *output, size_t outlen, const uint8_t *input, size_t inplen); - - /** - * Implementation of function OQS_SHA3_shake256_inc_init. - */ - void (*SHA3_shake256_inc_init)(OQS_SHA3_shake256_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake256_inc_absorb. - */ - void (*SHA3_shake256_inc_absorb)(OQS_SHA3_shake256_inc_ctx *state, const uint8_t *input, size_t inlen); - - /** - * Implementation of function OQS_SHA3_shake256_inc_finalize. - */ - void (*SHA3_shake256_inc_finalize)(OQS_SHA3_shake256_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake256_inc_squeeze. - */ - void (*SHA3_shake256_inc_squeeze)(uint8_t *output, size_t outlen, OQS_SHA3_shake256_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake256_inc_ctx_release. - */ - void (*SHA3_shake256_inc_ctx_release)(OQS_SHA3_shake256_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake256_inc_ctx_clone. - */ - void (*SHA3_shake256_inc_ctx_clone)(OQS_SHA3_shake256_inc_ctx *dest, const OQS_SHA3_shake256_inc_ctx *src); - - /** - * Implementation of function OQS_SHA3_shake256_inc_ctx_reset. - */ - void (*SHA3_shake256_inc_ctx_reset)(OQS_SHA3_shake256_inc_ctx *state); -}; - -/** - * Set callback functions for SHA3 operations. - * - * This function may be called before OQS_init to switch the - * cryptographic provider for SHA3 operations. If it is not called, - * the default provider determined at build time will be used. - * - * @param new_callbacks Callback functions defined in OQS_SHA3_callbacks struct - */ -OQS_API void OQS_SHA3_set_callbacks(struct OQS_SHA3_callbacks *new_callbacks); - -#if defined(__cplusplus) -} // extern "C" -#endif - -#endif // OQS_SHA3_OPS_H diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/sha3x4.h b/prebuilt_liboqs/linux-x86_64/include/oqs/sha3x4.h deleted file mode 100644 index aabea5b..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/sha3x4.h +++ /dev/null @@ -1,252 +0,0 @@ -/** - * \file sha3x4.h - * \brief SHA3, SHAKE, and cSHAKE functions; not part of the OQS public API - * - * Contains the API and documentation for SHA3 digest and SHAKE implementations. - * - * Note this is not part of the OQS public API: implementations within liboqs can use these - * functions, but external consumers of liboqs should not use these functions. - * - * \author John Underhill, Douglas Stebila - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_SHA3X4_H -#define OQS_SHA3X4_H - -#include -#include - -#include - -#if defined(__cplusplus) -extern "C" { -#endif - -/** - * \brief Seed 4 parallel SHAKE-128 instances, and generate 4 arrays of pseudo-random bytes. - * - * \warning The output array length must not be zero. - * - * \param out0 The first output byte array - * \param out1 The second output byte array - * \param out2 The third output byte array - * \param out3 The fourth output byte array - * \param outlen The number of output bytes to generate in every output array - * \param in0 The first input seed byte array - * \param in1 The second input seed byte array - * \param in2 The third input seed byte array - * \param in3 The fourth input seed byte array - * \param inlen The number of seed bytes to process from every input array - */ -void OQS_SHA3_shake128_x4( - uint8_t *out0, - uint8_t *out1, - uint8_t *out2, - uint8_t *out3, - size_t outlen, - const uint8_t *in0, - const uint8_t *in1, - const uint8_t *in2, - const uint8_t *in3, - size_t inlen); - -/** - * \brief Initialize the state for four-way parallel incremental SHAKE-128 API. - * - * \param state The function state to be initialized; must be allocated - */ -void OQS_SHA3_shake128_x4_inc_init(OQS_SHA3_shake128_x4_inc_ctx *state); - -/** - * \brief Four-way parallel SHAKE-128 absorb function. - * Absorb four input messages of the same length into four parallel states. - * - * \warning State must be initialized by the caller. - * - * \param state The function state; must be initialized - * \param in0 The input to be absorbed into first instance - * \param in1 The input to be absorbed into first instance - * \param in2 The input to be absorbed into first instance - * \param in3 The input to be absorbed into first instance - * \param inlen The number of bytes to process from each input array - */ -void OQS_SHA3_shake128_x4_inc_absorb( - OQS_SHA3_shake128_x4_inc_ctx *state, - const uint8_t *in0, - const uint8_t *in1, - const uint8_t *in2, - const uint8_t *in3, - size_t inlen); - -/** - * \brief Four-way parallel SHAKE-128 finalize function. - * Prepares the states for squeezing. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_shake128_x4_inc_finalize(OQS_SHA3_shake128_x4_inc_ctx *state); - -/** - * \brief Four-way parallel SHAKE-128 squeeze function. - * Extracts from four parallel states into four output buffers - * - * \param out0 output buffer for the first instance - * \param out1 output buffer for the second instance - * \param out2 output buffer for the third instance - * \param out3 output buffer for the fourth instance - * \param outlen bytes of outbut buffer - * \param state The function state; must be initialized and finalized. - */ -void OQS_SHA3_shake128_x4_inc_squeeze( - uint8_t *out0, - uint8_t *out1, - uint8_t *out2, - uint8_t *out3, - size_t outlen, - OQS_SHA3_shake128_x4_inc_ctx *state); - -/** - * \brief Frees the state for the four-way parallel incremental SHAKE-128 API. - * - * \param state The state to free - */ -void OQS_SHA3_shake128_x4_inc_ctx_release(OQS_SHA3_shake128_x4_inc_ctx *state); - -/** - * \brief Copies the state for the four-way parallel incremental SHAKE-128 API. - * - * \param dest The state to copy into; must be initialized - * \param src The state to copy from; must be initialized - */ -void OQS_SHA3_shake128_x4_inc_ctx_clone( - OQS_SHA3_shake128_x4_inc_ctx *dest, - const OQS_SHA3_shake128_x4_inc_ctx *src); - -/** - * \brief Resets the state for the four-way parallel incremental SHAKE-128 API. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_shake128_x4_inc_ctx_reset(OQS_SHA3_shake128_x4_inc_ctx *state); - -/* SHAKE256 */ - -/** - * \brief Seed 4 parallel SHAKE-256 instances, and generate 4 arrays of pseudo-random bytes. - * - * Uses a vectorized (AVX2) implementation of SHAKE-256 if available. - * - * \warning The output array length must not be zero. - * - * \param out0 The first output byte array - * \param out1 The second output byte array - * \param out2 The third output byte array - * \param out3 The fourth output byte array - * \param outlen The number of output bytes to generate in every output array - * \param in0 The first input seed byte array - * \param in1 The second input seed byte array - * \param in2 The third input seed byte array - * \param in3 The fourth input seed byte array - * \param inlen The number of seed bytes to process from every input array - */ -void OQS_SHA3_shake256_x4( - uint8_t *out0, - uint8_t *out1, - uint8_t *out2, - uint8_t *out3, - size_t outlen, - const uint8_t *in0, - const uint8_t *in1, - const uint8_t *in2, - const uint8_t *in3, - size_t inlen); - -/** - * \brief Initialize the state for four-way parallel incremental SHAKE-256 API. - * - * \param state The function state to be initialized; must be allocated - */ -void OQS_SHA3_shake256_x4_inc_init(OQS_SHA3_shake256_x4_inc_ctx *state); - -/** - * \brief Four-way parallel SHAKE-256 absorb function. - * Absorb four input messages of the same length into four parallel states. - * - * \warning State must be initialized by the caller. - * - * \param state The function state; must be initialized - * \param in0 The input to be absorbed into first instance - * \param in1 The input to be absorbed into first instance - * \param in2 The input to be absorbed into first instance - * \param in3 The input to be absorbed into first instance - * \param inlen The number of bytes to process from each input array - */ -void OQS_SHA3_shake256_x4_inc_absorb( - OQS_SHA3_shake256_x4_inc_ctx *state, - const uint8_t *in0, - const uint8_t *in1, - const uint8_t *in2, - const uint8_t *in3, - size_t inlen); - -/** - * \brief Four-way parallel SHAKE-256 finalize function. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_shake256_x4_inc_finalize(OQS_SHA3_shake256_x4_inc_ctx *state); - -/** - * \brief Four-way parallel SHAKE-256 squeeze function. - * Extracts from four parallel states into four output buffers - * - * \param out0 output buffer for the first instance - * \param out1 output buffer for the second instance - * \param out2 output buffer for the third instance - * \param out3 output buffer for the fourth instance - * \param outlen bytes of outbut buffer - * \param state The function state; must be initialized and finalized - */ -void OQS_SHA3_shake256_x4_inc_squeeze( - uint8_t *out0, - uint8_t *out1, - uint8_t *out2, - uint8_t *out3, - size_t outlen, - OQS_SHA3_shake256_x4_inc_ctx *state); - -/** - * \brief Frees the state for the four-way parallel incremental SHAKE-256 API. - * - * \param state The state to free - */ -void OQS_SHA3_shake256_x4_inc_ctx_release(OQS_SHA3_shake256_x4_inc_ctx *state); - -/** - * \brief Copies the state for the four-way parallel incremental SHAKE-256 API. - * - * \warning dest must be allocated. dest must be freed by calling - * OQS_SHA3_shake256_inc_ctx_release. - * - * \param dest The state to copy into; must be initialized - * \param src The state to copy from; must be initialized - */ -void OQS_SHA3_shake256_x4_inc_ctx_clone( - OQS_SHA3_shake256_x4_inc_ctx *dest, - const OQS_SHA3_shake256_x4_inc_ctx *src); - -/** - * \brief Resets the state for the four-way parallel incremental SHAKE-256 API. - * Allows a context to be re-used without free and init calls. - * - * \param state The function state; must be initialized - */ -void OQS_SHA3_shake256_x4_inc_ctx_reset(OQS_SHA3_shake256_x4_inc_ctx *state); - -#if defined(__cplusplus) -} // extern "C" -#endif - -#endif // OQS_SHA3X4_H diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/sha3x4_ops.h b/prebuilt_liboqs/linux-x86_64/include/oqs/sha3x4_ops.h deleted file mode 100644 index 32e4cc3..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/sha3x4_ops.h +++ /dev/null @@ -1,182 +0,0 @@ -/** - * \file sha3x4_ops.h - * \brief Header defining the callback API for OQS SHA3 and SHAKE - * - * \author John Underhill, Douglas Stebila - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_SHA3X4_OPS_H -#define OQS_SHA3X4_OPS_H - -#include -#include - -#include - -#if defined(__cplusplus) -extern "C" { -#endif - -/** Data structure for the state of the four-way parallel incremental SHAKE-128 API. */ -typedef struct { - /** Internal state. */ - void *ctx; -} OQS_SHA3_shake128_x4_inc_ctx; - -/** Data structure for the state of the four-way parallel incremental SHAKE-256 API. */ -typedef struct { - /** Internal state. */ - void *ctx; -} OQS_SHA3_shake256_x4_inc_ctx; - -/** Data structure implemented by cryptographic provider for the - * four-way parallel incremental SHAKE-256 operations. - */ -struct OQS_SHA3_x4_callbacks { - /** - * Implementation of function OQS_SHA3_shake128_x4. - */ - void (*SHA3_shake128_x4)( - uint8_t *out0, - uint8_t *out1, - uint8_t *out2, - uint8_t *out3, - size_t outlen, - const uint8_t *in0, - const uint8_t *in1, - const uint8_t *in2, - const uint8_t *in3, - size_t inlen); - - /** - * Implementation of function OQS_SHA3_shake128_x4_inc_init. - */ - void (*SHA3_shake128_x4_inc_init)(OQS_SHA3_shake128_x4_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake128_x4_inc_absorb. - */ - void (*SHA3_shake128_x4_inc_absorb)( - OQS_SHA3_shake128_x4_inc_ctx *state, - const uint8_t *in0, - const uint8_t *in1, - const uint8_t *in2, - const uint8_t *in3, - size_t inlen); - - /** - * Implementation of function OQS_SHA3_shake128_x4_inc_finalize. - */ - void (*SHA3_shake128_x4_inc_finalize)(OQS_SHA3_shake128_x4_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake128_x4_inc_squeeze. - */ - void (*SHA3_shake128_x4_inc_squeeze)( - uint8_t *out0, - uint8_t *out1, - uint8_t *out2, - uint8_t *out3, - size_t outlen, - OQS_SHA3_shake128_x4_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake128_x4_inc_ctx_release. - */ - void (*SHA3_shake128_x4_inc_ctx_release)(OQS_SHA3_shake128_x4_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake128_x4_inc_ctx_clone. - */ - void (*SHA3_shake128_x4_inc_ctx_clone)( - OQS_SHA3_shake128_x4_inc_ctx *dest, - const OQS_SHA3_shake128_x4_inc_ctx *src); - - /** - * Implementation of function OQS_SHA3_shake128_x4_inc_ctx_reset. - */ - void (*SHA3_shake128_x4_inc_ctx_reset)(OQS_SHA3_shake128_x4_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake256_x4. - */ - void (*SHA3_shake256_x4)( - uint8_t *out0, - uint8_t *out1, - uint8_t *out2, - uint8_t *out3, - size_t outlen, - const uint8_t *in0, - const uint8_t *in1, - const uint8_t *in2, - const uint8_t *in3, - size_t inlen); - - /** - * Implementation of function OQS_SHA3_shake256_x4_inc_init. - */ - void (*SHA3_shake256_x4_inc_init)(OQS_SHA3_shake256_x4_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake256_x4_inc_absorb. - */ - void (*SHA3_shake256_x4_inc_absorb)( - OQS_SHA3_shake256_x4_inc_ctx *state, - const uint8_t *in0, - const uint8_t *in1, - const uint8_t *in2, - const uint8_t *in3, - size_t inlen); - - /** - * Implementation of function OQS_SHA3_shake256_x4_inc_finalize. - */ - void (*SHA3_shake256_x4_inc_finalize)(OQS_SHA3_shake256_x4_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake256_x4_inc_squeeze. - */ - void (*SHA3_shake256_x4_inc_squeeze)( - uint8_t *out0, - uint8_t *out1, - uint8_t *out2, - uint8_t *out3, - size_t outlen, - OQS_SHA3_shake256_x4_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake256_x4_inc_ctx_release. - */ - void (*SHA3_shake256_x4_inc_ctx_release)(OQS_SHA3_shake256_x4_inc_ctx *state); - - /** - * Implementation of function OQS_SHA3_shake256_x4_inc_ctx_clone. - */ - void (*SHA3_shake256_x4_inc_ctx_clone)( - OQS_SHA3_shake256_x4_inc_ctx *dest, - const OQS_SHA3_shake256_x4_inc_ctx *src); - - /** - * Implementation of function OQS_SHA3_shake256_x4_inc_ctx_reset. - */ - void (*SHA3_shake256_x4_inc_ctx_reset)(OQS_SHA3_shake256_x4_inc_ctx *state); -}; - -/** - * Set callback functions for 4-parallel SHA3 operations. - * - * This function may be called before OQS_init to switch the - * cryptographic provider for 4-parallel SHA3 operations. If it is not - * called, the default provider determined at build time will be used. - * - * @param new_callbacks Callback functions defined in OQS_SHA3_x4_callbacks struct - */ -OQS_API void OQS_SHA3_x4_set_callbacks(struct OQS_SHA3_x4_callbacks *new_callbacks); - -#if defined(__cplusplus) -} // extern "C" -#endif - -#endif // OQS_SHA3X4_OPS_H diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/sig.h b/prebuilt_liboqs/linux-x86_64/include/oqs/sig.h deleted file mode 100644 index d356e3f..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/sig.h +++ /dev/null @@ -1,770 +0,0 @@ -/** - * \file sig.h - * \brief Signature schemes - * - * The file `tests/example_sig.c` contains two examples on using the OQS_SIG API. - * - * The first example uses the individual scheme's algorithms directly and uses - * no dynamic memory allocation -- all buffers are allocated on the stack, with - * sizes indicated using preprocessor macros. Since algorithms can be disabled at - * compile-time, the programmer should wrap the code in \#ifdefs. - * - * The second example uses an OQS_SIG object to use an algorithm specified at - * runtime. Therefore it uses dynamic memory allocation -- all buffers must be - * malloc'ed by the programmer, with sizes indicated using the corresponding length - * member of the OQS_SIG object in question. Since algorithms can be disabled at - * compile-time, the programmer should check that the OQS_SIG object is not `NULL`. - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_SIG_H -#define OQS_SIG_H - -#include -#include -#include - -#include - -#if defined(__cplusplus) -extern "C" { -#endif - -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_ALG_IDENTIFIER_START -/** Algorithm identifier for ML-DSA-44 */ -#define OQS_SIG_alg_ml_dsa_44 "ML-DSA-44" -/** Algorithm identifier for ML-DSA-65 */ -#define OQS_SIG_alg_ml_dsa_65 "ML-DSA-65" -/** Algorithm identifier for ML-DSA-87 */ -#define OQS_SIG_alg_ml_dsa_87 "ML-DSA-87" -/** Algorithm identifier for Falcon-512 */ -#define OQS_SIG_alg_falcon_512 "Falcon-512" -/** Algorithm identifier for Falcon-1024 */ -#define OQS_SIG_alg_falcon_1024 "Falcon-1024" -/** Algorithm identifier for Falcon-padded-512 */ -#define OQS_SIG_alg_falcon_padded_512 "Falcon-padded-512" -/** Algorithm identifier for Falcon-padded-1024 */ -#define OQS_SIG_alg_falcon_padded_1024 "Falcon-padded-1024" -/** Algorithm identifier for SPHINCS+-SHA2-128f-simple */ -#define OQS_SIG_alg_sphincs_sha2_128f_simple "SPHINCS+-SHA2-128f-simple" -/** Algorithm identifier for SPHINCS+-SHA2-128s-simple */ -#define OQS_SIG_alg_sphincs_sha2_128s_simple "SPHINCS+-SHA2-128s-simple" -/** Algorithm identifier for SPHINCS+-SHA2-192f-simple */ -#define OQS_SIG_alg_sphincs_sha2_192f_simple "SPHINCS+-SHA2-192f-simple" -/** Algorithm identifier for SPHINCS+-SHA2-192s-simple */ -#define OQS_SIG_alg_sphincs_sha2_192s_simple "SPHINCS+-SHA2-192s-simple" -/** Algorithm identifier for SPHINCS+-SHA2-256f-simple */ -#define OQS_SIG_alg_sphincs_sha2_256f_simple "SPHINCS+-SHA2-256f-simple" -/** Algorithm identifier for SPHINCS+-SHA2-256s-simple */ -#define OQS_SIG_alg_sphincs_sha2_256s_simple "SPHINCS+-SHA2-256s-simple" -/** Algorithm identifier for SPHINCS+-SHAKE-128f-simple */ -#define OQS_SIG_alg_sphincs_shake_128f_simple "SPHINCS+-SHAKE-128f-simple" -/** Algorithm identifier for SPHINCS+-SHAKE-128s-simple */ -#define OQS_SIG_alg_sphincs_shake_128s_simple "SPHINCS+-SHAKE-128s-simple" -/** Algorithm identifier for SPHINCS+-SHAKE-192f-simple */ -#define OQS_SIG_alg_sphincs_shake_192f_simple "SPHINCS+-SHAKE-192f-simple" -/** Algorithm identifier for SPHINCS+-SHAKE-192s-simple */ -#define OQS_SIG_alg_sphincs_shake_192s_simple "SPHINCS+-SHAKE-192s-simple" -/** Algorithm identifier for SPHINCS+-SHAKE-256f-simple */ -#define OQS_SIG_alg_sphincs_shake_256f_simple "SPHINCS+-SHAKE-256f-simple" -/** Algorithm identifier for SPHINCS+-SHAKE-256s-simple */ -#define OQS_SIG_alg_sphincs_shake_256s_simple "SPHINCS+-SHAKE-256s-simple" -/** Algorithm identifier for MAYO-1 */ -#define OQS_SIG_alg_mayo_1 "MAYO-1" -/** Algorithm identifier for MAYO-2 */ -#define OQS_SIG_alg_mayo_2 "MAYO-2" -/** Algorithm identifier for MAYO-3 */ -#define OQS_SIG_alg_mayo_3 "MAYO-3" -/** Algorithm identifier for MAYO-5 */ -#define OQS_SIG_alg_mayo_5 "MAYO-5" -/** Algorithm identifier for cross-rsdp-128-balanced */ -#define OQS_SIG_alg_cross_rsdp_128_balanced "cross-rsdp-128-balanced" -/** Algorithm identifier for cross-rsdp-128-fast */ -#define OQS_SIG_alg_cross_rsdp_128_fast "cross-rsdp-128-fast" -/** Algorithm identifier for cross-rsdp-128-small */ -#define OQS_SIG_alg_cross_rsdp_128_small "cross-rsdp-128-small" -/** Algorithm identifier for cross-rsdp-192-balanced */ -#define OQS_SIG_alg_cross_rsdp_192_balanced "cross-rsdp-192-balanced" -/** Algorithm identifier for cross-rsdp-192-fast */ -#define OQS_SIG_alg_cross_rsdp_192_fast "cross-rsdp-192-fast" -/** Algorithm identifier for cross-rsdp-192-small */ -#define OQS_SIG_alg_cross_rsdp_192_small "cross-rsdp-192-small" -/** Algorithm identifier for cross-rsdp-256-balanced */ -#define OQS_SIG_alg_cross_rsdp_256_balanced "cross-rsdp-256-balanced" -/** Algorithm identifier for cross-rsdp-256-fast */ -#define OQS_SIG_alg_cross_rsdp_256_fast "cross-rsdp-256-fast" -/** Algorithm identifier for cross-rsdp-256-small */ -#define OQS_SIG_alg_cross_rsdp_256_small "cross-rsdp-256-small" -/** Algorithm identifier for cross-rsdpg-128-balanced */ -#define OQS_SIG_alg_cross_rsdpg_128_balanced "cross-rsdpg-128-balanced" -/** Algorithm identifier for cross-rsdpg-128-fast */ -#define OQS_SIG_alg_cross_rsdpg_128_fast "cross-rsdpg-128-fast" -/** Algorithm identifier for cross-rsdpg-128-small */ -#define OQS_SIG_alg_cross_rsdpg_128_small "cross-rsdpg-128-small" -/** Algorithm identifier for cross-rsdpg-192-balanced */ -#define OQS_SIG_alg_cross_rsdpg_192_balanced "cross-rsdpg-192-balanced" -/** Algorithm identifier for cross-rsdpg-192-fast */ -#define OQS_SIG_alg_cross_rsdpg_192_fast "cross-rsdpg-192-fast" -/** Algorithm identifier for cross-rsdpg-192-small */ -#define OQS_SIG_alg_cross_rsdpg_192_small "cross-rsdpg-192-small" -/** Algorithm identifier for cross-rsdpg-256-balanced */ -#define OQS_SIG_alg_cross_rsdpg_256_balanced "cross-rsdpg-256-balanced" -/** Algorithm identifier for cross-rsdpg-256-fast */ -#define OQS_SIG_alg_cross_rsdpg_256_fast "cross-rsdpg-256-fast" -/** Algorithm identifier for cross-rsdpg-256-small */ -#define OQS_SIG_alg_cross_rsdpg_256_small "cross-rsdpg-256-small" -/** Algorithm identifier for OV-Is */ -#define OQS_SIG_alg_uov_ov_Is "OV-Is" -/** Algorithm identifier for OV-Ip */ -#define OQS_SIG_alg_uov_ov_Ip "OV-Ip" -/** Algorithm identifier for OV-III */ -#define OQS_SIG_alg_uov_ov_III "OV-III" -/** Algorithm identifier for OV-V */ -#define OQS_SIG_alg_uov_ov_V "OV-V" -/** Algorithm identifier for OV-Is-pkc */ -#define OQS_SIG_alg_uov_ov_Is_pkc "OV-Is-pkc" -/** Algorithm identifier for OV-Ip-pkc */ -#define OQS_SIG_alg_uov_ov_Ip_pkc "OV-Ip-pkc" -/** Algorithm identifier for OV-III-pkc */ -#define OQS_SIG_alg_uov_ov_III_pkc "OV-III-pkc" -/** Algorithm identifier for OV-V-pkc */ -#define OQS_SIG_alg_uov_ov_V_pkc "OV-V-pkc" -/** Algorithm identifier for OV-Is-pkc-skc */ -#define OQS_SIG_alg_uov_ov_Is_pkc_skc "OV-Is-pkc-skc" -/** Algorithm identifier for OV-Ip-pkc-skc */ -#define OQS_SIG_alg_uov_ov_Ip_pkc_skc "OV-Ip-pkc-skc" -/** Algorithm identifier for OV-III-pkc-skc */ -#define OQS_SIG_alg_uov_ov_III_pkc_skc "OV-III-pkc-skc" -/** Algorithm identifier for OV-V-pkc-skc */ -#define OQS_SIG_alg_uov_ov_V_pkc_skc "OV-V-pkc-skc" -/** Algorithm identifier for SNOVA_24_5_4 */ -#define OQS_SIG_alg_snova_SNOVA_24_5_4 "SNOVA_24_5_4" -/** Algorithm identifier for SNOVA_24_5_4_SHAKE */ -#define OQS_SIG_alg_snova_SNOVA_24_5_4_SHAKE "SNOVA_24_5_4_SHAKE" -/** Algorithm identifier for SNOVA_24_5_4_esk */ -#define OQS_SIG_alg_snova_SNOVA_24_5_4_esk "SNOVA_24_5_4_esk" -/** Algorithm identifier for SNOVA_24_5_4_SHAKE_esk */ -#define OQS_SIG_alg_snova_SNOVA_24_5_4_SHAKE_esk "SNOVA_24_5_4_SHAKE_esk" -/** Algorithm identifier for SNOVA_37_17_2 */ -#define OQS_SIG_alg_snova_SNOVA_37_17_2 "SNOVA_37_17_2" -/** Algorithm identifier for SNOVA_25_8_3 */ -#define OQS_SIG_alg_snova_SNOVA_25_8_3 "SNOVA_25_8_3" -/** Algorithm identifier for SNOVA_56_25_2 */ -#define OQS_SIG_alg_snova_SNOVA_56_25_2 "SNOVA_56_25_2" -/** Algorithm identifier for SNOVA_49_11_3 */ -#define OQS_SIG_alg_snova_SNOVA_49_11_3 "SNOVA_49_11_3" -/** Algorithm identifier for SNOVA_37_8_4 */ -#define OQS_SIG_alg_snova_SNOVA_37_8_4 "SNOVA_37_8_4" -/** Algorithm identifier for SNOVA_24_5_5 */ -#define OQS_SIG_alg_snova_SNOVA_24_5_5 "SNOVA_24_5_5" -/** Algorithm identifier for SNOVA_60_10_4 */ -#define OQS_SIG_alg_snova_SNOVA_60_10_4 "SNOVA_60_10_4" -/** Algorithm identifier for SNOVA_29_6_5 */ -#define OQS_SIG_alg_snova_SNOVA_29_6_5 "SNOVA_29_6_5" -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_ALG_IDENTIFIER_END -///// OQS_COPY_FROM_SLH_DSA_FRAGMENT_ALGID_START -/** Algorithm identifier for slh_dsa_pure_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_pure_sha2_128s "SLH_DSA_PURE_SHA2_128S" -/** Algorithm identifier for slh_dsa_pure_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_pure_sha2_128f "SLH_DSA_PURE_SHA2_128F" -/** Algorithm identifier for slh_dsa_pure_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_pure_sha2_192s "SLH_DSA_PURE_SHA2_192S" -/** Algorithm identifier for slh_dsa_pure_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_pure_sha2_192f "SLH_DSA_PURE_SHA2_192F" -/** Algorithm identifier for slh_dsa_pure_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_pure_sha2_256s "SLH_DSA_PURE_SHA2_256S" -/** Algorithm identifier for slh_dsa_pure_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_pure_sha2_256f "SLH_DSA_PURE_SHA2_256F" -/** Algorithm identifier for slh_dsa_pure_shake_128s */ -#define OQS_SIG_alg_slh_dsa_pure_shake_128s "SLH_DSA_PURE_SHAKE_128S" -/** Algorithm identifier for slh_dsa_pure_shake_128f */ -#define OQS_SIG_alg_slh_dsa_pure_shake_128f "SLH_DSA_PURE_SHAKE_128F" -/** Algorithm identifier for slh_dsa_pure_shake_192s */ -#define OQS_SIG_alg_slh_dsa_pure_shake_192s "SLH_DSA_PURE_SHAKE_192S" -/** Algorithm identifier for slh_dsa_pure_shake_192f */ -#define OQS_SIG_alg_slh_dsa_pure_shake_192f "SLH_DSA_PURE_SHAKE_192F" -/** Algorithm identifier for slh_dsa_pure_shake_256s */ -#define OQS_SIG_alg_slh_dsa_pure_shake_256s "SLH_DSA_PURE_SHAKE_256S" -/** Algorithm identifier for slh_dsa_pure_shake_256f */ -#define OQS_SIG_alg_slh_dsa_pure_shake_256f "SLH_DSA_PURE_SHAKE_256F" -/** Algorithm identifier for slh_dsa_sha2_224_prehash_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_sha2_128s "SLH_DSA_SHA2_224_PREHASH_SHA2_128S" -/** Algorithm identifier for slh_dsa_sha2_224_prehash_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_sha2_128f "SLH_DSA_SHA2_224_PREHASH_SHA2_128F" -/** Algorithm identifier for slh_dsa_sha2_224_prehash_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_sha2_192s "SLH_DSA_SHA2_224_PREHASH_SHA2_192S" -/** Algorithm identifier for slh_dsa_sha2_224_prehash_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_sha2_192f "SLH_DSA_SHA2_224_PREHASH_SHA2_192F" -/** Algorithm identifier for slh_dsa_sha2_224_prehash_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_sha2_256s "SLH_DSA_SHA2_224_PREHASH_SHA2_256S" -/** Algorithm identifier for slh_dsa_sha2_224_prehash_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_sha2_256f "SLH_DSA_SHA2_224_PREHASH_SHA2_256F" -/** Algorithm identifier for slh_dsa_sha2_224_prehash_shake_128s */ -#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_shake_128s "SLH_DSA_SHA2_224_PREHASH_SHAKE_128S" -/** Algorithm identifier for slh_dsa_sha2_224_prehash_shake_128f */ -#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_shake_128f "SLH_DSA_SHA2_224_PREHASH_SHAKE_128F" -/** Algorithm identifier for slh_dsa_sha2_224_prehash_shake_192s */ -#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_shake_192s "SLH_DSA_SHA2_224_PREHASH_SHAKE_192S" -/** Algorithm identifier for slh_dsa_sha2_224_prehash_shake_192f */ -#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_shake_192f "SLH_DSA_SHA2_224_PREHASH_SHAKE_192F" -/** Algorithm identifier for slh_dsa_sha2_224_prehash_shake_256s */ -#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_shake_256s "SLH_DSA_SHA2_224_PREHASH_SHAKE_256S" -/** Algorithm identifier for slh_dsa_sha2_224_prehash_shake_256f */ -#define OQS_SIG_alg_slh_dsa_sha2_224_prehash_shake_256f "SLH_DSA_SHA2_224_PREHASH_SHAKE_256F" -/** Algorithm identifier for slh_dsa_sha2_256_prehash_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_sha2_128s "SLH_DSA_SHA2_256_PREHASH_SHA2_128S" -/** Algorithm identifier for slh_dsa_sha2_256_prehash_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_sha2_128f "SLH_DSA_SHA2_256_PREHASH_SHA2_128F" -/** Algorithm identifier for slh_dsa_sha2_256_prehash_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_sha2_192s "SLH_DSA_SHA2_256_PREHASH_SHA2_192S" -/** Algorithm identifier for slh_dsa_sha2_256_prehash_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_sha2_192f "SLH_DSA_SHA2_256_PREHASH_SHA2_192F" -/** Algorithm identifier for slh_dsa_sha2_256_prehash_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_sha2_256s "SLH_DSA_SHA2_256_PREHASH_SHA2_256S" -/** Algorithm identifier for slh_dsa_sha2_256_prehash_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_sha2_256f "SLH_DSA_SHA2_256_PREHASH_SHA2_256F" -/** Algorithm identifier for slh_dsa_sha2_256_prehash_shake_128s */ -#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_shake_128s "SLH_DSA_SHA2_256_PREHASH_SHAKE_128S" -/** Algorithm identifier for slh_dsa_sha2_256_prehash_shake_128f */ -#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_shake_128f "SLH_DSA_SHA2_256_PREHASH_SHAKE_128F" -/** Algorithm identifier for slh_dsa_sha2_256_prehash_shake_192s */ -#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_shake_192s "SLH_DSA_SHA2_256_PREHASH_SHAKE_192S" -/** Algorithm identifier for slh_dsa_sha2_256_prehash_shake_192f */ -#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_shake_192f "SLH_DSA_SHA2_256_PREHASH_SHAKE_192F" -/** Algorithm identifier for slh_dsa_sha2_256_prehash_shake_256s */ -#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_shake_256s "SLH_DSA_SHA2_256_PREHASH_SHAKE_256S" -/** Algorithm identifier for slh_dsa_sha2_256_prehash_shake_256f */ -#define OQS_SIG_alg_slh_dsa_sha2_256_prehash_shake_256f "SLH_DSA_SHA2_256_PREHASH_SHAKE_256F" -/** Algorithm identifier for slh_dsa_sha2_384_prehash_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_sha2_128s "SLH_DSA_SHA2_384_PREHASH_SHA2_128S" -/** Algorithm identifier for slh_dsa_sha2_384_prehash_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_sha2_128f "SLH_DSA_SHA2_384_PREHASH_SHA2_128F" -/** Algorithm identifier for slh_dsa_sha2_384_prehash_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_sha2_192s "SLH_DSA_SHA2_384_PREHASH_SHA2_192S" -/** Algorithm identifier for slh_dsa_sha2_384_prehash_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_sha2_192f "SLH_DSA_SHA2_384_PREHASH_SHA2_192F" -/** Algorithm identifier for slh_dsa_sha2_384_prehash_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_sha2_256s "SLH_DSA_SHA2_384_PREHASH_SHA2_256S" -/** Algorithm identifier for slh_dsa_sha2_384_prehash_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_sha2_256f "SLH_DSA_SHA2_384_PREHASH_SHA2_256F" -/** Algorithm identifier for slh_dsa_sha2_384_prehash_shake_128s */ -#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_shake_128s "SLH_DSA_SHA2_384_PREHASH_SHAKE_128S" -/** Algorithm identifier for slh_dsa_sha2_384_prehash_shake_128f */ -#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_shake_128f "SLH_DSA_SHA2_384_PREHASH_SHAKE_128F" -/** Algorithm identifier for slh_dsa_sha2_384_prehash_shake_192s */ -#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_shake_192s "SLH_DSA_SHA2_384_PREHASH_SHAKE_192S" -/** Algorithm identifier for slh_dsa_sha2_384_prehash_shake_192f */ -#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_shake_192f "SLH_DSA_SHA2_384_PREHASH_SHAKE_192F" -/** Algorithm identifier for slh_dsa_sha2_384_prehash_shake_256s */ -#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_shake_256s "SLH_DSA_SHA2_384_PREHASH_SHAKE_256S" -/** Algorithm identifier for slh_dsa_sha2_384_prehash_shake_256f */ -#define OQS_SIG_alg_slh_dsa_sha2_384_prehash_shake_256f "SLH_DSA_SHA2_384_PREHASH_SHAKE_256F" -/** Algorithm identifier for slh_dsa_sha2_512_prehash_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_sha2_128s "SLH_DSA_SHA2_512_PREHASH_SHA2_128S" -/** Algorithm identifier for slh_dsa_sha2_512_prehash_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_sha2_128f "SLH_DSA_SHA2_512_PREHASH_SHA2_128F" -/** Algorithm identifier for slh_dsa_sha2_512_prehash_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_sha2_192s "SLH_DSA_SHA2_512_PREHASH_SHA2_192S" -/** Algorithm identifier for slh_dsa_sha2_512_prehash_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_sha2_192f "SLH_DSA_SHA2_512_PREHASH_SHA2_192F" -/** Algorithm identifier for slh_dsa_sha2_512_prehash_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_sha2_256s "SLH_DSA_SHA2_512_PREHASH_SHA2_256S" -/** Algorithm identifier for slh_dsa_sha2_512_prehash_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_sha2_256f "SLH_DSA_SHA2_512_PREHASH_SHA2_256F" -/** Algorithm identifier for slh_dsa_sha2_512_prehash_shake_128s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_shake_128s "SLH_DSA_SHA2_512_PREHASH_SHAKE_128S" -/** Algorithm identifier for slh_dsa_sha2_512_prehash_shake_128f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_shake_128f "SLH_DSA_SHA2_512_PREHASH_SHAKE_128F" -/** Algorithm identifier for slh_dsa_sha2_512_prehash_shake_192s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_shake_192s "SLH_DSA_SHA2_512_PREHASH_SHAKE_192S" -/** Algorithm identifier for slh_dsa_sha2_512_prehash_shake_192f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_shake_192f "SLH_DSA_SHA2_512_PREHASH_SHAKE_192F" -/** Algorithm identifier for slh_dsa_sha2_512_prehash_shake_256s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_shake_256s "SLH_DSA_SHA2_512_PREHASH_SHAKE_256S" -/** Algorithm identifier for slh_dsa_sha2_512_prehash_shake_256f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_prehash_shake_256f "SLH_DSA_SHA2_512_PREHASH_SHAKE_256F" -/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_sha2_128s "SLH_DSA_SHA2_512_224_PREHASH_SHA2_128S" -/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_sha2_128f "SLH_DSA_SHA2_512_224_PREHASH_SHA2_128F" -/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_sha2_192s "SLH_DSA_SHA2_512_224_PREHASH_SHA2_192S" -/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_sha2_192f "SLH_DSA_SHA2_512_224_PREHASH_SHA2_192F" -/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_sha2_256s "SLH_DSA_SHA2_512_224_PREHASH_SHA2_256S" -/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_sha2_256f "SLH_DSA_SHA2_512_224_PREHASH_SHA2_256F" -/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_shake_128s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_shake_128s "SLH_DSA_SHA2_512_224_PREHASH_SHAKE_128S" -/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_shake_128f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_shake_128f "SLH_DSA_SHA2_512_224_PREHASH_SHAKE_128F" -/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_shake_192s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_shake_192s "SLH_DSA_SHA2_512_224_PREHASH_SHAKE_192S" -/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_shake_192f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_shake_192f "SLH_DSA_SHA2_512_224_PREHASH_SHAKE_192F" -/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_shake_256s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_shake_256s "SLH_DSA_SHA2_512_224_PREHASH_SHAKE_256S" -/** Algorithm identifier for slh_dsa_sha2_512_224_prehash_shake_256f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_224_prehash_shake_256f "SLH_DSA_SHA2_512_224_PREHASH_SHAKE_256F" -/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_sha2_128s "SLH_DSA_SHA2_512_256_PREHASH_SHA2_128S" -/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_sha2_128f "SLH_DSA_SHA2_512_256_PREHASH_SHA2_128F" -/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_sha2_192s "SLH_DSA_SHA2_512_256_PREHASH_SHA2_192S" -/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_sha2_192f "SLH_DSA_SHA2_512_256_PREHASH_SHA2_192F" -/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_sha2_256s "SLH_DSA_SHA2_512_256_PREHASH_SHA2_256S" -/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_sha2_256f "SLH_DSA_SHA2_512_256_PREHASH_SHA2_256F" -/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_shake_128s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_shake_128s "SLH_DSA_SHA2_512_256_PREHASH_SHAKE_128S" -/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_shake_128f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_shake_128f "SLH_DSA_SHA2_512_256_PREHASH_SHAKE_128F" -/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_shake_192s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_shake_192s "SLH_DSA_SHA2_512_256_PREHASH_SHAKE_192S" -/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_shake_192f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_shake_192f "SLH_DSA_SHA2_512_256_PREHASH_SHAKE_192F" -/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_shake_256s */ -#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_shake_256s "SLH_DSA_SHA2_512_256_PREHASH_SHAKE_256S" -/** Algorithm identifier for slh_dsa_sha2_512_256_prehash_shake_256f */ -#define OQS_SIG_alg_slh_dsa_sha2_512_256_prehash_shake_256f "SLH_DSA_SHA2_512_256_PREHASH_SHAKE_256F" -/** Algorithm identifier for slh_dsa_sha3_224_prehash_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_sha2_128s "SLH_DSA_SHA3_224_PREHASH_SHA2_128S" -/** Algorithm identifier for slh_dsa_sha3_224_prehash_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_sha2_128f "SLH_DSA_SHA3_224_PREHASH_SHA2_128F" -/** Algorithm identifier for slh_dsa_sha3_224_prehash_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_sha2_192s "SLH_DSA_SHA3_224_PREHASH_SHA2_192S" -/** Algorithm identifier for slh_dsa_sha3_224_prehash_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_sha2_192f "SLH_DSA_SHA3_224_PREHASH_SHA2_192F" -/** Algorithm identifier for slh_dsa_sha3_224_prehash_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_sha2_256s "SLH_DSA_SHA3_224_PREHASH_SHA2_256S" -/** Algorithm identifier for slh_dsa_sha3_224_prehash_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_sha2_256f "SLH_DSA_SHA3_224_PREHASH_SHA2_256F" -/** Algorithm identifier for slh_dsa_sha3_224_prehash_shake_128s */ -#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_shake_128s "SLH_DSA_SHA3_224_PREHASH_SHAKE_128S" -/** Algorithm identifier for slh_dsa_sha3_224_prehash_shake_128f */ -#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_shake_128f "SLH_DSA_SHA3_224_PREHASH_SHAKE_128F" -/** Algorithm identifier for slh_dsa_sha3_224_prehash_shake_192s */ -#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_shake_192s "SLH_DSA_SHA3_224_PREHASH_SHAKE_192S" -/** Algorithm identifier for slh_dsa_sha3_224_prehash_shake_192f */ -#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_shake_192f "SLH_DSA_SHA3_224_PREHASH_SHAKE_192F" -/** Algorithm identifier for slh_dsa_sha3_224_prehash_shake_256s */ -#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_shake_256s "SLH_DSA_SHA3_224_PREHASH_SHAKE_256S" -/** Algorithm identifier for slh_dsa_sha3_224_prehash_shake_256f */ -#define OQS_SIG_alg_slh_dsa_sha3_224_prehash_shake_256f "SLH_DSA_SHA3_224_PREHASH_SHAKE_256F" -/** Algorithm identifier for slh_dsa_sha3_256_prehash_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_sha2_128s "SLH_DSA_SHA3_256_PREHASH_SHA2_128S" -/** Algorithm identifier for slh_dsa_sha3_256_prehash_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_sha2_128f "SLH_DSA_SHA3_256_PREHASH_SHA2_128F" -/** Algorithm identifier for slh_dsa_sha3_256_prehash_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_sha2_192s "SLH_DSA_SHA3_256_PREHASH_SHA2_192S" -/** Algorithm identifier for slh_dsa_sha3_256_prehash_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_sha2_192f "SLH_DSA_SHA3_256_PREHASH_SHA2_192F" -/** Algorithm identifier for slh_dsa_sha3_256_prehash_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_sha2_256s "SLH_DSA_SHA3_256_PREHASH_SHA2_256S" -/** Algorithm identifier for slh_dsa_sha3_256_prehash_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_sha2_256f "SLH_DSA_SHA3_256_PREHASH_SHA2_256F" -/** Algorithm identifier for slh_dsa_sha3_256_prehash_shake_128s */ -#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_shake_128s "SLH_DSA_SHA3_256_PREHASH_SHAKE_128S" -/** Algorithm identifier for slh_dsa_sha3_256_prehash_shake_128f */ -#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_shake_128f "SLH_DSA_SHA3_256_PREHASH_SHAKE_128F" -/** Algorithm identifier for slh_dsa_sha3_256_prehash_shake_192s */ -#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_shake_192s "SLH_DSA_SHA3_256_PREHASH_SHAKE_192S" -/** Algorithm identifier for slh_dsa_sha3_256_prehash_shake_192f */ -#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_shake_192f "SLH_DSA_SHA3_256_PREHASH_SHAKE_192F" -/** Algorithm identifier for slh_dsa_sha3_256_prehash_shake_256s */ -#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_shake_256s "SLH_DSA_SHA3_256_PREHASH_SHAKE_256S" -/** Algorithm identifier for slh_dsa_sha3_256_prehash_shake_256f */ -#define OQS_SIG_alg_slh_dsa_sha3_256_prehash_shake_256f "SLH_DSA_SHA3_256_PREHASH_SHAKE_256F" -/** Algorithm identifier for slh_dsa_sha3_384_prehash_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_sha2_128s "SLH_DSA_SHA3_384_PREHASH_SHA2_128S" -/** Algorithm identifier for slh_dsa_sha3_384_prehash_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_sha2_128f "SLH_DSA_SHA3_384_PREHASH_SHA2_128F" -/** Algorithm identifier for slh_dsa_sha3_384_prehash_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_sha2_192s "SLH_DSA_SHA3_384_PREHASH_SHA2_192S" -/** Algorithm identifier for slh_dsa_sha3_384_prehash_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_sha2_192f "SLH_DSA_SHA3_384_PREHASH_SHA2_192F" -/** Algorithm identifier for slh_dsa_sha3_384_prehash_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_sha2_256s "SLH_DSA_SHA3_384_PREHASH_SHA2_256S" -/** Algorithm identifier for slh_dsa_sha3_384_prehash_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_sha2_256f "SLH_DSA_SHA3_384_PREHASH_SHA2_256F" -/** Algorithm identifier for slh_dsa_sha3_384_prehash_shake_128s */ -#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_shake_128s "SLH_DSA_SHA3_384_PREHASH_SHAKE_128S" -/** Algorithm identifier for slh_dsa_sha3_384_prehash_shake_128f */ -#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_shake_128f "SLH_DSA_SHA3_384_PREHASH_SHAKE_128F" -/** Algorithm identifier for slh_dsa_sha3_384_prehash_shake_192s */ -#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_shake_192s "SLH_DSA_SHA3_384_PREHASH_SHAKE_192S" -/** Algorithm identifier for slh_dsa_sha3_384_prehash_shake_192f */ -#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_shake_192f "SLH_DSA_SHA3_384_PREHASH_SHAKE_192F" -/** Algorithm identifier for slh_dsa_sha3_384_prehash_shake_256s */ -#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_shake_256s "SLH_DSA_SHA3_384_PREHASH_SHAKE_256S" -/** Algorithm identifier for slh_dsa_sha3_384_prehash_shake_256f */ -#define OQS_SIG_alg_slh_dsa_sha3_384_prehash_shake_256f "SLH_DSA_SHA3_384_PREHASH_SHAKE_256F" -/** Algorithm identifier for slh_dsa_sha3_512_prehash_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_sha2_128s "SLH_DSA_SHA3_512_PREHASH_SHA2_128S" -/** Algorithm identifier for slh_dsa_sha3_512_prehash_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_sha2_128f "SLH_DSA_SHA3_512_PREHASH_SHA2_128F" -/** Algorithm identifier for slh_dsa_sha3_512_prehash_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_sha2_192s "SLH_DSA_SHA3_512_PREHASH_SHA2_192S" -/** Algorithm identifier for slh_dsa_sha3_512_prehash_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_sha2_192f "SLH_DSA_SHA3_512_PREHASH_SHA2_192F" -/** Algorithm identifier for slh_dsa_sha3_512_prehash_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_sha2_256s "SLH_DSA_SHA3_512_PREHASH_SHA2_256S" -/** Algorithm identifier for slh_dsa_sha3_512_prehash_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_sha2_256f "SLH_DSA_SHA3_512_PREHASH_SHA2_256F" -/** Algorithm identifier for slh_dsa_sha3_512_prehash_shake_128s */ -#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_shake_128s "SLH_DSA_SHA3_512_PREHASH_SHAKE_128S" -/** Algorithm identifier for slh_dsa_sha3_512_prehash_shake_128f */ -#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_shake_128f "SLH_DSA_SHA3_512_PREHASH_SHAKE_128F" -/** Algorithm identifier for slh_dsa_sha3_512_prehash_shake_192s */ -#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_shake_192s "SLH_DSA_SHA3_512_PREHASH_SHAKE_192S" -/** Algorithm identifier for slh_dsa_sha3_512_prehash_shake_192f */ -#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_shake_192f "SLH_DSA_SHA3_512_PREHASH_SHAKE_192F" -/** Algorithm identifier for slh_dsa_sha3_512_prehash_shake_256s */ -#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_shake_256s "SLH_DSA_SHA3_512_PREHASH_SHAKE_256S" -/** Algorithm identifier for slh_dsa_sha3_512_prehash_shake_256f */ -#define OQS_SIG_alg_slh_dsa_sha3_512_prehash_shake_256f "SLH_DSA_SHA3_512_PREHASH_SHAKE_256F" -/** Algorithm identifier for slh_dsa_shake_128_prehash_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_shake_128_prehash_sha2_128s "SLH_DSA_SHAKE_128_PREHASH_SHA2_128S" -/** Algorithm identifier for slh_dsa_shake_128_prehash_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_shake_128_prehash_sha2_128f "SLH_DSA_SHAKE_128_PREHASH_SHA2_128F" -/** Algorithm identifier for slh_dsa_shake_128_prehash_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_shake_128_prehash_sha2_192s "SLH_DSA_SHAKE_128_PREHASH_SHA2_192S" -/** Algorithm identifier for slh_dsa_shake_128_prehash_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_shake_128_prehash_sha2_192f "SLH_DSA_SHAKE_128_PREHASH_SHA2_192F" -/** Algorithm identifier for slh_dsa_shake_128_prehash_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_shake_128_prehash_sha2_256s "SLH_DSA_SHAKE_128_PREHASH_SHA2_256S" -/** Algorithm identifier for slh_dsa_shake_128_prehash_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_shake_128_prehash_sha2_256f "SLH_DSA_SHAKE_128_PREHASH_SHA2_256F" -/** Algorithm identifier for slh_dsa_shake_128_prehash_shake_128s */ -#define OQS_SIG_alg_slh_dsa_shake_128_prehash_shake_128s "SLH_DSA_SHAKE_128_PREHASH_SHAKE_128S" -/** Algorithm identifier for slh_dsa_shake_128_prehash_shake_128f */ -#define OQS_SIG_alg_slh_dsa_shake_128_prehash_shake_128f "SLH_DSA_SHAKE_128_PREHASH_SHAKE_128F" -/** Algorithm identifier for slh_dsa_shake_128_prehash_shake_192s */ -#define OQS_SIG_alg_slh_dsa_shake_128_prehash_shake_192s "SLH_DSA_SHAKE_128_PREHASH_SHAKE_192S" -/** Algorithm identifier for slh_dsa_shake_128_prehash_shake_192f */ -#define OQS_SIG_alg_slh_dsa_shake_128_prehash_shake_192f "SLH_DSA_SHAKE_128_PREHASH_SHAKE_192F" -/** Algorithm identifier for slh_dsa_shake_128_prehash_shake_256s */ -#define OQS_SIG_alg_slh_dsa_shake_128_prehash_shake_256s "SLH_DSA_SHAKE_128_PREHASH_SHAKE_256S" -/** Algorithm identifier for slh_dsa_shake_128_prehash_shake_256f */ -#define OQS_SIG_alg_slh_dsa_shake_128_prehash_shake_256f "SLH_DSA_SHAKE_128_PREHASH_SHAKE_256F" -/** Algorithm identifier for slh_dsa_shake_256_prehash_sha2_128s */ -#define OQS_SIG_alg_slh_dsa_shake_256_prehash_sha2_128s "SLH_DSA_SHAKE_256_PREHASH_SHA2_128S" -/** Algorithm identifier for slh_dsa_shake_256_prehash_sha2_128f */ -#define OQS_SIG_alg_slh_dsa_shake_256_prehash_sha2_128f "SLH_DSA_SHAKE_256_PREHASH_SHA2_128F" -/** Algorithm identifier for slh_dsa_shake_256_prehash_sha2_192s */ -#define OQS_SIG_alg_slh_dsa_shake_256_prehash_sha2_192s "SLH_DSA_SHAKE_256_PREHASH_SHA2_192S" -/** Algorithm identifier for slh_dsa_shake_256_prehash_sha2_192f */ -#define OQS_SIG_alg_slh_dsa_shake_256_prehash_sha2_192f "SLH_DSA_SHAKE_256_PREHASH_SHA2_192F" -/** Algorithm identifier for slh_dsa_shake_256_prehash_sha2_256s */ -#define OQS_SIG_alg_slh_dsa_shake_256_prehash_sha2_256s "SLH_DSA_SHAKE_256_PREHASH_SHA2_256S" -/** Algorithm identifier for slh_dsa_shake_256_prehash_sha2_256f */ -#define OQS_SIG_alg_slh_dsa_shake_256_prehash_sha2_256f "SLH_DSA_SHAKE_256_PREHASH_SHA2_256F" -/** Algorithm identifier for slh_dsa_shake_256_prehash_shake_128s */ -#define OQS_SIG_alg_slh_dsa_shake_256_prehash_shake_128s "SLH_DSA_SHAKE_256_PREHASH_SHAKE_128S" -/** Algorithm identifier for slh_dsa_shake_256_prehash_shake_128f */ -#define OQS_SIG_alg_slh_dsa_shake_256_prehash_shake_128f "SLH_DSA_SHAKE_256_PREHASH_SHAKE_128F" -/** Algorithm identifier for slh_dsa_shake_256_prehash_shake_192s */ -#define OQS_SIG_alg_slh_dsa_shake_256_prehash_shake_192s "SLH_DSA_SHAKE_256_PREHASH_SHAKE_192S" -/** Algorithm identifier for slh_dsa_shake_256_prehash_shake_192f */ -#define OQS_SIG_alg_slh_dsa_shake_256_prehash_shake_192f "SLH_DSA_SHAKE_256_PREHASH_SHAKE_192F" -/** Algorithm identifier for slh_dsa_shake_256_prehash_shake_256s */ -#define OQS_SIG_alg_slh_dsa_shake_256_prehash_shake_256s "SLH_DSA_SHAKE_256_PREHASH_SHAKE_256S" -/** Algorithm identifier for slh_dsa_shake_256_prehash_shake_256f */ -#define OQS_SIG_alg_slh_dsa_shake_256_prehash_shake_256f "SLH_DSA_SHAKE_256_PREHASH_SHAKE_256F" -///// OQS_COPY_FROM_SLH_DSA_FRAGMENT_ALGID_END -// EDIT-WHEN-ADDING-SIG -///// OQS_COPY_FROM_SLH_DSA_FRAGMENT_ALGS_LENGTH_START - -/** Number of algorithm identifiers above. */ -#define OQS_SIG_SLH_DSA_algs_length 156 -///// OQS_COPY_FROM_SLH_DSA_FRAGMENT_ALGS_LENGTH_END -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_ALGS_LENGTH_START - -/** Number of algorithm identifiers above. */ -#define OQS_SIG_algs_length 65 + OQS_SIG_SLH_DSA_algs_length -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_ALGS_LENGTH_END - -/** - * Returns identifiers for available signature schemes in liboqs. Used with OQS_SIG_new. - * - * Note that algorithm identifiers are present in this list even when the algorithm is disabled - * at compile time. - * - * @param[in] i Index of the algorithm identifier to return, 0 <= i < OQS_SIG_algs_length - * @return Algorithm identifier as a string, or NULL. - */ -OQS_API const char *OQS_SIG_alg_identifier(size_t i); - -/** - * Returns the number of signature mechanisms in liboqs. They can be enumerated with - * OQS_SIG_alg_identifier. - * - * Note that some mechanisms may be disabled at compile time. - * - * @return The number of signature mechanisms. - */ -OQS_API int OQS_SIG_alg_count(void); - -/** - * Indicates whether the specified algorithm was enabled at compile-time or not. - * - * @param[in] method_name Name of the desired algorithm; one of the names in `OQS_SIG_algs`. - * @return 1 if enabled, 0 if disabled or not found - */ -OQS_API int OQS_SIG_alg_is_enabled(const char *method_name); - -/** - * Signature schemes object - */ -typedef struct OQS_SIG { - - /** Printable string representing the name of the signature scheme. */ - const char *method_name; - - /** - * Printable string representing the version of the cryptographic algorithm. - * - * Implementations with the same method_name and same alg_version will be interoperable. - * See README.md for information about algorithm compatibility. - */ - const char *alg_version; - - /** The NIST security level (1, 2, 3, 4, 5) claimed in this algorithm's original NIST submission. */ - uint8_t claimed_nist_level; - - /** Whether the signature offers EUF-CMA security (TRUE) or not (FALSE). */ - bool euf_cma; - - /** Whether the signature offers SUF-CMA security (TRUE) or not (FALSE). */ - bool suf_cma; - - /** Whether the signature supports signing with a context string (TRUE) or not (FALSE). */ - bool sig_with_ctx_support; - - /** The length, in bytes, of public keys for this signature scheme. */ - size_t length_public_key; - /** The length, in bytes, of secret keys for this signature scheme. */ - size_t length_secret_key; - /** The (maximum) length, in bytes, of signatures for this signature scheme. */ - size_t length_signature; - - /** - * Keypair generation algorithm. - * - * Caller is responsible for allocating sufficient memory for `public_key` and - * `secret_key`, based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_SIG_*_length_*`. - * - * @param[out] public_key The public key represented as a byte string. - * @param[out] secret_key The secret key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*keypair)(uint8_t *public_key, uint8_t *secret_key); - - /** - * Signature generation algorithm. - * - * Caller is responsible for allocating sufficient memory for `signature`, - * based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_SIG_*_length_*`. - * - * @param[out] signature The signature on the message represented as a byte string. - * @param[out] signature_len The actual length of the signature. May be smaller than `length_signature` for some algorithms since some algorithms have variable length signatures. - * @param[in] message The message to sign represented as a byte string. - * @param[in] message_len The length of the message to sign. - * @param[in] secret_key The secret key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*sign)(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); - - /** - * Signature generation algorithm, with custom context string. - * - * Caller is responsible for allocating sufficient memory for `signature`, - * based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_SIG_*_length_*`. - * - * @param[out] signature The signature on the message represented as a byte string. - * @param[out] signature_len The actual length of the signature. May be smaller than `length_signature` for some algorithms since some algorithms have variable length signatures. - * @param[in] message The message to sign represented as a byte string. - * @param[in] message_len The length of the message to sign. - * @param[in] ctx_str The context string used for the signature. This value can be set to NULL if a context string is not needed (i.e., for algorithms that do not support context strings or if an empty context string is used). - * @param[in] ctx_str_len The context string used for the signature. This value can be set to 0 if a context string is not needed (i.e., for algorithms that do not support context strings or if an empty context string is used). - * @param[in] secret_key The secret key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*sign_with_ctx_str)(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str, size_t ctx_str_len, const uint8_t *secret_key); - - /** - * Signature verification algorithm. - * - * @param[in] message The message represented as a byte string. - * @param[in] message_len The length of the message. - * @param[in] signature The signature on the message represented as a byte string. - * @param[in] signature_len The length of the signature. - * @param[in] public_key The public key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*verify)(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); - - /** - * Signature verification algorithm, with custom context string. - * - * @param[in] message The message represented as a byte string. - * @param[in] message_len The length of the message. - * @param[in] signature The signature on the message represented as a byte string. - * @param[in] signature_len The length of the signature. - * @param[in] ctx_str The context string for the signature. This value can be set to NULL if a context string is not needed (i.e., for algorithms that do not support context strings or if an empty context string is used). - * @param[in] ctx_str_len The length of the context string. This value can be set to 0 if a context string is not needed (i.e., for algorithms that do not support context strings or if an empty context string is used). - * @param[in] public_key The public key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*verify_with_ctx_str)(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str, size_t ctx_str_len, const uint8_t *public_key); - - -} OQS_SIG; - -/** - * Constructs an OQS_SIG object for a particular algorithm. - * - * Callers should always check whether the return value is `NULL`, which indicates either than an - * invalid algorithm name was provided, or that the requested algorithm was disabled at compile-time. - * - * @param[in] method_name Name of the desired algorithm; one of the names in `OQS_SIG_algs`. - * @return An OQS_SIG for the particular algorithm, or `NULL` if the algorithm has been disabled at compile-time. - */ -OQS_API OQS_SIG *OQS_SIG_new(const char *method_name); - -/** - * Keypair generation algorithm. - * - * Caller is responsible for allocating sufficient memory for `public_key` and - * `secret_key`, based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_SIG_*_length_*`. - * - * @param[in] sig The OQS_SIG object representing the signature scheme. - * @param[out] public_key The public key represented as a byte string. - * @param[out] secret_key The secret key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_SIG_keypair(const OQS_SIG *sig, uint8_t *public_key, uint8_t *secret_key); - -/** - * Signature generation algorithm. - * - * Caller is responsible for allocating sufficient memory for `signnature`, - * based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_SIG_*_length_*`. - * - * @param[in] sig The OQS_SIG object representing the signature scheme. - * @param[out] signature The signature on the message represented as a byte string. - * @param[out] signature_len The length of the signature. - * @param[in] message The message to sign represented as a byte string. - * @param[in] message_len The length of the message to sign. - * @param[in] secret_key The secret key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_SIG_sign(const OQS_SIG *sig, uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); - -/** - * Signature generation algorithm, with custom context string. - * - * Caller is responsible for allocating sufficient memory for `signature`, - * based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_SIG_*_length_*`. - * - * @param[in] sig The OQS_SIG object representing the signature scheme. - * @param[out] signature The signature on the message represented as a byte string. - * @param[out] signature_len The actual length of the signature. May be smaller than `length_signature` for some algorithms since some algorithms have variable length signatures. - * @param[in] message The message to sign represented as a byte string. - * @param[in] message_len The length of the message to sign. - * @param[in] ctx_str The context string used for the signature. This value can be set to NULL if a context string is not needed (i.e., for algorithms that do not support context strings or if an empty context string is used). - * @param[in] ctx_str_len The context string used for the signature. This value can be set to 0 if a context string is not needed (i.e., for algorithms that do not support context strings or if an empty context string is used). - * @param[in] secret_key The secret key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_SIG_sign_with_ctx_str(const OQS_SIG *sig, uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx_str, size_t ctx_str_len, const uint8_t *secret_key); - -/** - * Signature verification algorithm. - * - * @param[in] sig The OQS_SIG object representing the signature scheme. - * @param[in] message The message represented as a byte string. - * @param[in] message_len The length of the message. - * @param[in] signature The signature on the message represented as a byte string. - * @param[in] signature_len The length of the signature. - * @param[in] public_key The public key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_SIG_verify(const OQS_SIG *sig, const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); - -/** - * Signature verification algorithm, with custom context string. - * - * @param[in] sig The OQS_SIG object representing the signature scheme. - * @param[in] message The message represented as a byte string. - * @param[in] message_len The length of the message. - * @param[in] signature The signature on the message represented as a byte string. - * @param[in] signature_len The length of the signature. - * @param[in] ctx_str The context string used for the signature. This value can be set to NULL if a context string is not needed (i.e., for algorithms that do not support context strings or if an empty context string is used). - * @param[in] ctx_str_len The context string used for the signature. This value can be set to 0 if a context string is not needed (i.e., for algorithms that do not support context strings or if an empty context string is used). - * @param[in] public_key The public key represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_SIG_verify_with_ctx_str(const OQS_SIG *sig, const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx_str, size_t ctx_str_len, const uint8_t *public_key); - -/** - * Frees an OQS_SIG object that was constructed by OQS_SIG_new. - * - * @param[in] sig The OQS_SIG object to free. - */ -OQS_API void OQS_SIG_free(OQS_SIG *sig); - -/** - * Indicates whether the specified signature algorithm supports signing with a context string. - * - * @param[in] alg_name Name of the desired algorithm; one of the names in `OQS_SIG_algs`. - * @return true if the algorithm supports context string signing, false otherwise. - */ -OQS_API bool OQS_SIG_supports_ctx_str(const char *alg_name); - -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_INCLUDE_START -#ifdef OQS_ENABLE_SIG_ML_DSA -#include -#endif /* OQS_ENABLE_SIG_ML_DSA */ -#ifdef OQS_ENABLE_SIG_FALCON -#include -#endif /* OQS_ENABLE_SIG_FALCON */ -#ifdef OQS_ENABLE_SIG_SPHINCS -#include -#endif /* OQS_ENABLE_SIG_SPHINCS */ -#ifdef OQS_ENABLE_SIG_MAYO -#include -#endif /* OQS_ENABLE_SIG_MAYO */ -#ifdef OQS_ENABLE_SIG_CROSS -#include -#endif /* OQS_ENABLE_SIG_CROSS */ -#ifdef OQS_ENABLE_SIG_UOV -#include -#endif /* OQS_ENABLE_SIG_UOV */ -#ifdef OQS_ENABLE_SIG_SNOVA -#include -#endif /* OQS_ENABLE_SIG_SNOVA */ -///// OQS_COPY_FROM_UPSTREAM_FRAGMENT_INCLUDE_END -///// OQS_COPY_FROM_SLH_DSA_FRAGMENT_INCLUDE_START -#ifdef OQS_ENABLE_SIG_SLH_DSA -#include -#endif /* OQS_ENABLE_SIG_SLH_DSA */ -///// OQS_COPY_FROM_SLH_DSA_FRAGMENT_INCLUDE_END -// EDIT-WHEN-ADDING-SIG - -#if defined(__cplusplus) -} // extern "C" -#endif - -#endif // OQS_SIG_H diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/sig_cross.h b/prebuilt_liboqs/linux-x86_64/include/oqs/sig_cross.h deleted file mode 100644 index 2832622..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/sig_cross.h +++ /dev/null @@ -1,242 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_SIG_CROSS_H -#define OQS_SIG_CROSS_H - -#include - -#if defined(OQS_ENABLE_SIG_cross_rsdp_128_balanced) -#define OQS_SIG_cross_rsdp_128_balanced_length_public_key 77 -#define OQS_SIG_cross_rsdp_128_balanced_length_secret_key 32 -#define OQS_SIG_cross_rsdp_128_balanced_length_signature 13152 - -OQS_SIG *OQS_SIG_cross_rsdp_128_balanced_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_balanced_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_balanced_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_balanced_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_balanced_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_balanced_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdp_128_fast) -#define OQS_SIG_cross_rsdp_128_fast_length_public_key 77 -#define OQS_SIG_cross_rsdp_128_fast_length_secret_key 32 -#define OQS_SIG_cross_rsdp_128_fast_length_signature 18432 - -OQS_SIG *OQS_SIG_cross_rsdp_128_fast_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_fast_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_fast_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_fast_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_fast_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_fast_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdp_128_small) -#define OQS_SIG_cross_rsdp_128_small_length_public_key 77 -#define OQS_SIG_cross_rsdp_128_small_length_secret_key 32 -#define OQS_SIG_cross_rsdp_128_small_length_signature 12432 - -OQS_SIG *OQS_SIG_cross_rsdp_128_small_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_small_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_small_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_small_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_small_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_128_small_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdp_192_balanced) -#define OQS_SIG_cross_rsdp_192_balanced_length_public_key 115 -#define OQS_SIG_cross_rsdp_192_balanced_length_secret_key 48 -#define OQS_SIG_cross_rsdp_192_balanced_length_signature 29853 - -OQS_SIG *OQS_SIG_cross_rsdp_192_balanced_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_balanced_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_balanced_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_balanced_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_balanced_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_balanced_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdp_192_fast) -#define OQS_SIG_cross_rsdp_192_fast_length_public_key 115 -#define OQS_SIG_cross_rsdp_192_fast_length_secret_key 48 -#define OQS_SIG_cross_rsdp_192_fast_length_signature 41406 - -OQS_SIG *OQS_SIG_cross_rsdp_192_fast_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_fast_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_fast_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_fast_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_fast_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_fast_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdp_192_small) -#define OQS_SIG_cross_rsdp_192_small_length_public_key 115 -#define OQS_SIG_cross_rsdp_192_small_length_secret_key 48 -#define OQS_SIG_cross_rsdp_192_small_length_signature 28391 - -OQS_SIG *OQS_SIG_cross_rsdp_192_small_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_small_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_small_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_small_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_small_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_192_small_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdp_256_balanced) -#define OQS_SIG_cross_rsdp_256_balanced_length_public_key 153 -#define OQS_SIG_cross_rsdp_256_balanced_length_secret_key 64 -#define OQS_SIG_cross_rsdp_256_balanced_length_signature 53527 - -OQS_SIG *OQS_SIG_cross_rsdp_256_balanced_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_balanced_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_balanced_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_balanced_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_balanced_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_balanced_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdp_256_fast) -#define OQS_SIG_cross_rsdp_256_fast_length_public_key 153 -#define OQS_SIG_cross_rsdp_256_fast_length_secret_key 64 -#define OQS_SIG_cross_rsdp_256_fast_length_signature 74590 - -OQS_SIG *OQS_SIG_cross_rsdp_256_fast_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_fast_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_fast_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_fast_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_fast_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_fast_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdp_256_small) -#define OQS_SIG_cross_rsdp_256_small_length_public_key 153 -#define OQS_SIG_cross_rsdp_256_small_length_secret_key 64 -#define OQS_SIG_cross_rsdp_256_small_length_signature 50818 - -OQS_SIG *OQS_SIG_cross_rsdp_256_small_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_small_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_small_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_small_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_small_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdp_256_small_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdpg_128_balanced) -#define OQS_SIG_cross_rsdpg_128_balanced_length_public_key 54 -#define OQS_SIG_cross_rsdpg_128_balanced_length_secret_key 32 -#define OQS_SIG_cross_rsdpg_128_balanced_length_signature 9120 - -OQS_SIG *OQS_SIG_cross_rsdpg_128_balanced_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_balanced_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_balanced_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_balanced_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_balanced_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_balanced_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdpg_128_fast) -#define OQS_SIG_cross_rsdpg_128_fast_length_public_key 54 -#define OQS_SIG_cross_rsdpg_128_fast_length_secret_key 32 -#define OQS_SIG_cross_rsdpg_128_fast_length_signature 11980 - -OQS_SIG *OQS_SIG_cross_rsdpg_128_fast_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_fast_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_fast_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_fast_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_fast_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_fast_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdpg_128_small) -#define OQS_SIG_cross_rsdpg_128_small_length_public_key 54 -#define OQS_SIG_cross_rsdpg_128_small_length_secret_key 32 -#define OQS_SIG_cross_rsdpg_128_small_length_signature 8960 - -OQS_SIG *OQS_SIG_cross_rsdpg_128_small_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_small_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_small_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_small_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_small_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_128_small_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdpg_192_balanced) -#define OQS_SIG_cross_rsdpg_192_balanced_length_public_key 83 -#define OQS_SIG_cross_rsdpg_192_balanced_length_secret_key 48 -#define OQS_SIG_cross_rsdpg_192_balanced_length_signature 22464 - -OQS_SIG *OQS_SIG_cross_rsdpg_192_balanced_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_balanced_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_balanced_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_balanced_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_balanced_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_balanced_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdpg_192_fast) -#define OQS_SIG_cross_rsdpg_192_fast_length_public_key 83 -#define OQS_SIG_cross_rsdpg_192_fast_length_secret_key 48 -#define OQS_SIG_cross_rsdpg_192_fast_length_signature 26772 - -OQS_SIG *OQS_SIG_cross_rsdpg_192_fast_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_fast_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_fast_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_fast_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_fast_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_fast_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdpg_192_small) -#define OQS_SIG_cross_rsdpg_192_small_length_public_key 83 -#define OQS_SIG_cross_rsdpg_192_small_length_secret_key 48 -#define OQS_SIG_cross_rsdpg_192_small_length_signature 20452 - -OQS_SIG *OQS_SIG_cross_rsdpg_192_small_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_small_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_small_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_small_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_small_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_192_small_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdpg_256_balanced) -#define OQS_SIG_cross_rsdpg_256_balanced_length_public_key 106 -#define OQS_SIG_cross_rsdpg_256_balanced_length_secret_key 64 -#define OQS_SIG_cross_rsdpg_256_balanced_length_signature 40100 - -OQS_SIG *OQS_SIG_cross_rsdpg_256_balanced_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_balanced_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_balanced_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_balanced_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_balanced_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_balanced_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdpg_256_fast) -#define OQS_SIG_cross_rsdpg_256_fast_length_public_key 106 -#define OQS_SIG_cross_rsdpg_256_fast_length_secret_key 64 -#define OQS_SIG_cross_rsdpg_256_fast_length_signature 48102 - -OQS_SIG *OQS_SIG_cross_rsdpg_256_fast_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_fast_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_fast_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_fast_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_fast_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_fast_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_cross_rsdpg_256_small) -#define OQS_SIG_cross_rsdpg_256_small_length_public_key 106 -#define OQS_SIG_cross_rsdpg_256_small_length_secret_key 64 -#define OQS_SIG_cross_rsdpg_256_small_length_signature 36454 - -OQS_SIG *OQS_SIG_cross_rsdpg_256_small_new(void); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_small_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_small_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_small_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_small_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_cross_rsdpg_256_small_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#endif diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/sig_falcon.h b/prebuilt_liboqs/linux-x86_64/include/oqs/sig_falcon.h deleted file mode 100644 index 1721fe1..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/sig_falcon.h +++ /dev/null @@ -1,60 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_SIG_FALCON_H -#define OQS_SIG_FALCON_H - -#include - -#if defined(OQS_ENABLE_SIG_falcon_512) -#define OQS_SIG_falcon_512_length_public_key 897 -#define OQS_SIG_falcon_512_length_secret_key 1281 -#define OQS_SIG_falcon_512_length_signature 752 - -OQS_SIG *OQS_SIG_falcon_512_new(void); -OQS_API OQS_STATUS OQS_SIG_falcon_512_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_falcon_512_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_falcon_512_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_falcon_512_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_falcon_512_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_falcon_1024) -#define OQS_SIG_falcon_1024_length_public_key 1793 -#define OQS_SIG_falcon_1024_length_secret_key 2305 -#define OQS_SIG_falcon_1024_length_signature 1462 - -OQS_SIG *OQS_SIG_falcon_1024_new(void); -OQS_API OQS_STATUS OQS_SIG_falcon_1024_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_falcon_1024_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_falcon_1024_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_falcon_1024_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_falcon_1024_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_falcon_padded_512) -#define OQS_SIG_falcon_padded_512_length_public_key 897 -#define OQS_SIG_falcon_padded_512_length_secret_key 1281 -#define OQS_SIG_falcon_padded_512_length_signature 666 - -OQS_SIG *OQS_SIG_falcon_padded_512_new(void); -OQS_API OQS_STATUS OQS_SIG_falcon_padded_512_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_falcon_padded_512_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_falcon_padded_512_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_falcon_padded_512_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_falcon_padded_512_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_falcon_padded_1024) -#define OQS_SIG_falcon_padded_1024_length_public_key 1793 -#define OQS_SIG_falcon_padded_1024_length_secret_key 2305 -#define OQS_SIG_falcon_padded_1024_length_signature 1280 - -OQS_SIG *OQS_SIG_falcon_padded_1024_new(void); -OQS_API OQS_STATUS OQS_SIG_falcon_padded_1024_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_falcon_padded_1024_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_falcon_padded_1024_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_falcon_padded_1024_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_falcon_padded_1024_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#endif diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/sig_mayo.h b/prebuilt_liboqs/linux-x86_64/include/oqs/sig_mayo.h deleted file mode 100644 index 237492e..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/sig_mayo.h +++ /dev/null @@ -1,60 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_SIG_MAYO_H -#define OQS_SIG_MAYO_H - -#include - -#if defined(OQS_ENABLE_SIG_mayo_1) -#define OQS_SIG_mayo_1_length_public_key 1420 -#define OQS_SIG_mayo_1_length_secret_key 24 -#define OQS_SIG_mayo_1_length_signature 454 - -OQS_SIG *OQS_SIG_mayo_1_new(void); -OQS_API OQS_STATUS OQS_SIG_mayo_1_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_mayo_1_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_mayo_1_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_mayo_1_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_mayo_1_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_mayo_2) -#define OQS_SIG_mayo_2_length_public_key 4912 -#define OQS_SIG_mayo_2_length_secret_key 24 -#define OQS_SIG_mayo_2_length_signature 186 - -OQS_SIG *OQS_SIG_mayo_2_new(void); -OQS_API OQS_STATUS OQS_SIG_mayo_2_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_mayo_2_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_mayo_2_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_mayo_2_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_mayo_2_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_mayo_3) -#define OQS_SIG_mayo_3_length_public_key 2986 -#define OQS_SIG_mayo_3_length_secret_key 32 -#define OQS_SIG_mayo_3_length_signature 681 - -OQS_SIG *OQS_SIG_mayo_3_new(void); -OQS_API OQS_STATUS OQS_SIG_mayo_3_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_mayo_3_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_mayo_3_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_mayo_3_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_mayo_3_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_mayo_5) -#define OQS_SIG_mayo_5_length_public_key 5554 -#define OQS_SIG_mayo_5_length_secret_key 40 -#define OQS_SIG_mayo_5_length_signature 964 - -OQS_SIG *OQS_SIG_mayo_5_new(void); -OQS_API OQS_STATUS OQS_SIG_mayo_5_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_mayo_5_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_mayo_5_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_mayo_5_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_mayo_5_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#endif diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/sig_ml_dsa.h b/prebuilt_liboqs/linux-x86_64/include/oqs/sig_ml_dsa.h deleted file mode 100644 index e5f00f4..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/sig_ml_dsa.h +++ /dev/null @@ -1,47 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_SIG_ML_DSA_H -#define OQS_SIG_ML_DSA_H - -#include - -#if defined(OQS_ENABLE_SIG_ml_dsa_44) -#define OQS_SIG_ml_dsa_44_length_public_key 1312 -#define OQS_SIG_ml_dsa_44_length_secret_key 2560 -#define OQS_SIG_ml_dsa_44_length_signature 2420 - -OQS_SIG *OQS_SIG_ml_dsa_44_new(void); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_44_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_44_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_44_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_44_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_44_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_ml_dsa_65) -#define OQS_SIG_ml_dsa_65_length_public_key 1952 -#define OQS_SIG_ml_dsa_65_length_secret_key 4032 -#define OQS_SIG_ml_dsa_65_length_signature 3309 - -OQS_SIG *OQS_SIG_ml_dsa_65_new(void); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_65_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_65_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_65_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_65_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_65_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_ml_dsa_87) -#define OQS_SIG_ml_dsa_87_length_public_key 2592 -#define OQS_SIG_ml_dsa_87_length_secret_key 4896 -#define OQS_SIG_ml_dsa_87_length_signature 4627 - -OQS_SIG *OQS_SIG_ml_dsa_87_new(void); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_87_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_87_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_87_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_87_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_ml_dsa_87_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#endif diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/sig_slh_dsa.h b/prebuilt_liboqs/linux-x86_64/include/oqs/sig_slh_dsa.h deleted file mode 100644 index f56ee2e..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/sig_slh_dsa.h +++ /dev/null @@ -1,2192 +0,0 @@ - -// SPDX-License-Identifier: MIT - -#ifndef OQS_SIG_SLH_DSA_H -#define OQS_SIG_SLH_DSA_H - -#include - -#if defined(OQS_ENABLE_SIG_slh_dsa_pure_sha2_128s) -#define OQS_SIG_slh_dsa_pure_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_pure_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_pure_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_pure_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_pure_shake_128s) -#define OQS_SIG_slh_dsa_pure_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_pure_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_pure_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_pure_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_pure_sha2_128f) -#define OQS_SIG_slh_dsa_pure_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_pure_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_pure_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_pure_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_pure_shake_128f) -#define OQS_SIG_slh_dsa_pure_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_pure_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_pure_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_pure_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_pure_sha2_192s) -#define OQS_SIG_slh_dsa_pure_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_pure_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_pure_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_pure_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_pure_shake_192s) -#define OQS_SIG_slh_dsa_pure_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_pure_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_pure_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_pure_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_pure_sha2_192f) -#define OQS_SIG_slh_dsa_pure_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_pure_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_pure_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_pure_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_pure_shake_192f) -#define OQS_SIG_slh_dsa_pure_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_pure_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_pure_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_pure_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_pure_sha2_256s) -#define OQS_SIG_slh_dsa_pure_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_pure_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_pure_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_pure_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_pure_shake_256s) -#define OQS_SIG_slh_dsa_pure_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_pure_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_pure_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_pure_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_pure_sha2_256f) -#define OQS_SIG_slh_dsa_pure_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_pure_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_pure_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_pure_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_pure_shake_256f) -#define OQS_SIG_slh_dsa_pure_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_pure_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_pure_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_pure_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_pure_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_128s) -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_128s) -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_128s) -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_128s) -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s) -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_128s) -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_128s) -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_128s) -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_128s) -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_128s) -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_128s) -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_shake_128_prehash_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_128s) -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_shake_256_prehash_sha2_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_128s) -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_128s) -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_128s) -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_128s) -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_128s) -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_128s) -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_128s) -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_224_prehash_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_128s) -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_256_prehash_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_128s) -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_384_prehash_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_128s) -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_512_prehash_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_128s) -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_shake_128_prehash_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_128s) -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_128s_length_public_key 32 -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_128s_length_secret_key 64 -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_128s_length_signature 7856 - -OQS_SIG *OQS_SIG_slh_dsa_shake_256_prehash_shake_128s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_128s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_128s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_128s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_128s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_128s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_128f) -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_128f) -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_128f) -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_128f) -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f) -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f) -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_128f) -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_128f) -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_128f) -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_128f) -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_128f) -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_shake_128_prehash_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_128f) -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_shake_256_prehash_sha2_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_128f) -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_128f) -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_128f) -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_128f) -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_128f) -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_128f) -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_128f) -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_224_prehash_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_128f) -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_256_prehash_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_128f) -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_384_prehash_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_128f) -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_512_prehash_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_128f) -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_shake_128_prehash_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_128f) -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_128f_length_public_key 32 -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_128f_length_secret_key 64 -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_128f_length_signature 17088 - -OQS_SIG *OQS_SIG_slh_dsa_shake_256_prehash_shake_128f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_128f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_128f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_128f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_128f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_128f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_192s) -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_192s) -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_192s) -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_192s) -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s) -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_192s) -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_192s) -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_192s) -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_192s) -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_192s) -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_192s) -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_shake_128_prehash_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_192s) -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_shake_256_prehash_sha2_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_192s) -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_192s) -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_192s) -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_192s) -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_192s) -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_192s) -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_192s) -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_224_prehash_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_192s) -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_256_prehash_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_192s) -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_384_prehash_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_192s) -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_512_prehash_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_192s) -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_shake_128_prehash_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_192s) -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_192s_length_public_key 48 -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_192s_length_secret_key 96 -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_192s_length_signature 16224 - -OQS_SIG *OQS_SIG_slh_dsa_shake_256_prehash_shake_192s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_192s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_192s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_192s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_192s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_192s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_192f) -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_192f) -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_192f) -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_192f) -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f) -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_192f) -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_192f) -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_192f) -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_192f) -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_192f) -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_192f) -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_shake_128_prehash_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_192f) -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_shake_256_prehash_sha2_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_192f) -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_192f) -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_192f) -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_192f) -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_192f) -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_192f) -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_192f) -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_224_prehash_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_192f) -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_256_prehash_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_192f) -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_384_prehash_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_192f) -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_512_prehash_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_192f) -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_shake_128_prehash_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_192f) -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_192f_length_public_key 48 -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_192f_length_secret_key 96 -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_192f_length_signature 35664 - -OQS_SIG *OQS_SIG_slh_dsa_shake_256_prehash_shake_192f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_192f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_192f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_192f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_192f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_192f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_256s) -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_256s) -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_256s) -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_256s) -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s) -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_256s) -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_256s) -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_256s) -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_256s) -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_256s) -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_256s) -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_shake_128_prehash_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_256s) -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_shake_256_prehash_sha2_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_256s) -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_256s) -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_256s) -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_256s) -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_256s) -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_256s) -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_256s) -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_224_prehash_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_256s) -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_256_prehash_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_256s) -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_384_prehash_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_256s) -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_512_prehash_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_256s) -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_shake_128_prehash_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_256s) -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_256s_length_public_key 64 -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_256s_length_secret_key 128 -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_256s_length_signature 29792 - -OQS_SIG *OQS_SIG_slh_dsa_shake_256_prehash_shake_256s_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_256s_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_256s_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_256s_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_256s_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_256s_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_sha2_256f) -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_sha2_256f) -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_sha2_256f) -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_sha2_256f) -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f) -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_sha2_256f) -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_sha2_256f) -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_sha2_256f) -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_sha2_256f) -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_sha2_256f) -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_sha2_256f) -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_shake_128_prehash_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_shake_128_prehash_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_sha2_256f) -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_shake_256_prehash_sha2_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_shake_256_prehash_sha2_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_sha2_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_224_prehash_shake_256f) -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_224_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_256_prehash_shake_256f) -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_256_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_384_prehash_shake_256f) -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_384_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_prehash_shake_256f) -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_224_prehash_shake_256f) -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_224_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha2_512_256_prehash_shake_256f) -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha2_512_256_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_224_prehash_shake_256f) -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_224_prehash_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_224_prehash_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_224_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_256_prehash_shake_256f) -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_256_prehash_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_256_prehash_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_256_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_384_prehash_shake_256f) -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_384_prehash_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_384_prehash_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_384_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_sha3_512_prehash_shake_256f) -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_sha3_512_prehash_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_sha3_512_prehash_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_sha3_512_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_128_prehash_shake_256f) -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_shake_128_prehash_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_shake_128_prehash_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_128_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - - -#if defined(OQS_ENABLE_SIG_slh_dsa_shake_256_prehash_shake_256f) -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_256f_length_public_key 64 -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_256f_length_secret_key 128 -#define OQS_SIG_slh_dsa_shake_256_prehash_shake_256f_length_signature 49856 - -OQS_SIG *OQS_SIG_slh_dsa_shake_256_prehash_shake_256f_new(void); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_256f_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_256f_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_256f_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_256f_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_slh_dsa_shake_256_prehash_shake_256f_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#endif diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/sig_snova.h b/prebuilt_liboqs/linux-x86_64/include/oqs/sig_snova.h deleted file mode 100644 index 55243ed..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/sig_snova.h +++ /dev/null @@ -1,164 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_SIG_SNOVA_H -#define OQS_SIG_SNOVA_H - -#include - -#if defined(OQS_ENABLE_SIG_snova_SNOVA_24_5_4) -#define OQS_SIG_snova_SNOVA_24_5_4_length_public_key 1016 -#define OQS_SIG_snova_SNOVA_24_5_4_length_secret_key 48 -#define OQS_SIG_snova_SNOVA_24_5_4_length_signature 248 - -OQS_SIG *OQS_SIG_snova_SNOVA_24_5_4_new(void); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_snova_SNOVA_24_5_4_SHAKE) -#define OQS_SIG_snova_SNOVA_24_5_4_SHAKE_length_public_key 1016 -#define OQS_SIG_snova_SNOVA_24_5_4_SHAKE_length_secret_key 48 -#define OQS_SIG_snova_SNOVA_24_5_4_SHAKE_length_signature 248 - -OQS_SIG *OQS_SIG_snova_SNOVA_24_5_4_SHAKE_new(void); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_SHAKE_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_SHAKE_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_SHAKE_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_SHAKE_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_SHAKE_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_snova_SNOVA_24_5_4_esk) -#define OQS_SIG_snova_SNOVA_24_5_4_esk_length_public_key 1016 -#define OQS_SIG_snova_SNOVA_24_5_4_esk_length_secret_key 36848 -#define OQS_SIG_snova_SNOVA_24_5_4_esk_length_signature 248 - -OQS_SIG *OQS_SIG_snova_SNOVA_24_5_4_esk_new(void); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_esk_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_esk_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_esk_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_esk_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_esk_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_snova_SNOVA_24_5_4_SHAKE_esk) -#define OQS_SIG_snova_SNOVA_24_5_4_SHAKE_esk_length_public_key 1016 -#define OQS_SIG_snova_SNOVA_24_5_4_SHAKE_esk_length_secret_key 36848 -#define OQS_SIG_snova_SNOVA_24_5_4_SHAKE_esk_length_signature 248 - -OQS_SIG *OQS_SIG_snova_SNOVA_24_5_4_SHAKE_esk_new(void); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_SHAKE_esk_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_SHAKE_esk_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_SHAKE_esk_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_SHAKE_esk_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_4_SHAKE_esk_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_snova_SNOVA_37_17_2) -#define OQS_SIG_snova_SNOVA_37_17_2_length_public_key 9842 -#define OQS_SIG_snova_SNOVA_37_17_2_length_secret_key 48 -#define OQS_SIG_snova_SNOVA_37_17_2_length_signature 124 - -OQS_SIG *OQS_SIG_snova_SNOVA_37_17_2_new(void); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_37_17_2_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_37_17_2_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_37_17_2_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_37_17_2_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_37_17_2_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_snova_SNOVA_25_8_3) -#define OQS_SIG_snova_SNOVA_25_8_3_length_public_key 2320 -#define OQS_SIG_snova_SNOVA_25_8_3_length_secret_key 48 -#define OQS_SIG_snova_SNOVA_25_8_3_length_signature 165 - -OQS_SIG *OQS_SIG_snova_SNOVA_25_8_3_new(void); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_25_8_3_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_25_8_3_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_25_8_3_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_25_8_3_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_25_8_3_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_snova_SNOVA_56_25_2) -#define OQS_SIG_snova_SNOVA_56_25_2_length_public_key 31266 -#define OQS_SIG_snova_SNOVA_56_25_2_length_secret_key 48 -#define OQS_SIG_snova_SNOVA_56_25_2_length_signature 178 - -OQS_SIG *OQS_SIG_snova_SNOVA_56_25_2_new(void); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_56_25_2_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_56_25_2_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_56_25_2_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_56_25_2_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_56_25_2_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_snova_SNOVA_49_11_3) -#define OQS_SIG_snova_SNOVA_49_11_3_length_public_key 6006 -#define OQS_SIG_snova_SNOVA_49_11_3_length_secret_key 48 -#define OQS_SIG_snova_SNOVA_49_11_3_length_signature 286 - -OQS_SIG *OQS_SIG_snova_SNOVA_49_11_3_new(void); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_49_11_3_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_49_11_3_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_49_11_3_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_49_11_3_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_49_11_3_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_snova_SNOVA_37_8_4) -#define OQS_SIG_snova_SNOVA_37_8_4_length_public_key 4112 -#define OQS_SIG_snova_SNOVA_37_8_4_length_secret_key 48 -#define OQS_SIG_snova_SNOVA_37_8_4_length_signature 376 - -OQS_SIG *OQS_SIG_snova_SNOVA_37_8_4_new(void); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_37_8_4_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_37_8_4_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_37_8_4_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_37_8_4_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_37_8_4_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_snova_SNOVA_24_5_5) -#define OQS_SIG_snova_SNOVA_24_5_5_length_public_key 1579 -#define OQS_SIG_snova_SNOVA_24_5_5_length_secret_key 48 -#define OQS_SIG_snova_SNOVA_24_5_5_length_signature 379 - -OQS_SIG *OQS_SIG_snova_SNOVA_24_5_5_new(void); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_5_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_5_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_5_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_5_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_24_5_5_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_snova_SNOVA_60_10_4) -#define OQS_SIG_snova_SNOVA_60_10_4_length_public_key 8016 -#define OQS_SIG_snova_SNOVA_60_10_4_length_secret_key 48 -#define OQS_SIG_snova_SNOVA_60_10_4_length_signature 576 - -OQS_SIG *OQS_SIG_snova_SNOVA_60_10_4_new(void); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_60_10_4_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_60_10_4_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_60_10_4_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_60_10_4_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_60_10_4_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_snova_SNOVA_29_6_5) -#define OQS_SIG_snova_SNOVA_29_6_5_length_public_key 2716 -#define OQS_SIG_snova_SNOVA_29_6_5_length_secret_key 48 -#define OQS_SIG_snova_SNOVA_29_6_5_length_signature 454 - -OQS_SIG *OQS_SIG_snova_SNOVA_29_6_5_new(void); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_29_6_5_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_29_6_5_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_29_6_5_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_29_6_5_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_snova_SNOVA_29_6_5_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#endif diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/sig_sphincs.h b/prebuilt_liboqs/linux-x86_64/include/oqs/sig_sphincs.h deleted file mode 100644 index 5b3e4f9..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/sig_sphincs.h +++ /dev/null @@ -1,164 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_SIG_SPHINCS_H -#define OQS_SIG_SPHINCS_H - -#include - -#if defined(OQS_ENABLE_SIG_sphincs_sha2_128f_simple) -#define OQS_SIG_sphincs_sha2_128f_simple_length_public_key 32 -#define OQS_SIG_sphincs_sha2_128f_simple_length_secret_key 64 -#define OQS_SIG_sphincs_sha2_128f_simple_length_signature 17088 - -OQS_SIG *OQS_SIG_sphincs_sha2_128f_simple_new(void); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_128f_simple_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_128f_simple_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_128f_simple_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_128f_simple_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_128f_simple_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_sphincs_sha2_128s_simple) -#define OQS_SIG_sphincs_sha2_128s_simple_length_public_key 32 -#define OQS_SIG_sphincs_sha2_128s_simple_length_secret_key 64 -#define OQS_SIG_sphincs_sha2_128s_simple_length_signature 7856 - -OQS_SIG *OQS_SIG_sphincs_sha2_128s_simple_new(void); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_128s_simple_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_128s_simple_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_128s_simple_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_128s_simple_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_128s_simple_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_sphincs_sha2_192f_simple) -#define OQS_SIG_sphincs_sha2_192f_simple_length_public_key 48 -#define OQS_SIG_sphincs_sha2_192f_simple_length_secret_key 96 -#define OQS_SIG_sphincs_sha2_192f_simple_length_signature 35664 - -OQS_SIG *OQS_SIG_sphincs_sha2_192f_simple_new(void); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_192f_simple_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_192f_simple_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_192f_simple_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_192f_simple_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_192f_simple_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_sphincs_sha2_192s_simple) -#define OQS_SIG_sphincs_sha2_192s_simple_length_public_key 48 -#define OQS_SIG_sphincs_sha2_192s_simple_length_secret_key 96 -#define OQS_SIG_sphincs_sha2_192s_simple_length_signature 16224 - -OQS_SIG *OQS_SIG_sphincs_sha2_192s_simple_new(void); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_192s_simple_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_192s_simple_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_192s_simple_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_192s_simple_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_192s_simple_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_sphincs_sha2_256f_simple) -#define OQS_SIG_sphincs_sha2_256f_simple_length_public_key 64 -#define OQS_SIG_sphincs_sha2_256f_simple_length_secret_key 128 -#define OQS_SIG_sphincs_sha2_256f_simple_length_signature 49856 - -OQS_SIG *OQS_SIG_sphincs_sha2_256f_simple_new(void); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_256f_simple_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_256f_simple_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_256f_simple_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_256f_simple_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_256f_simple_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_sphincs_sha2_256s_simple) -#define OQS_SIG_sphincs_sha2_256s_simple_length_public_key 64 -#define OQS_SIG_sphincs_sha2_256s_simple_length_secret_key 128 -#define OQS_SIG_sphincs_sha2_256s_simple_length_signature 29792 - -OQS_SIG *OQS_SIG_sphincs_sha2_256s_simple_new(void); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_256s_simple_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_256s_simple_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_256s_simple_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_256s_simple_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_sha2_256s_simple_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_sphincs_shake_128f_simple) -#define OQS_SIG_sphincs_shake_128f_simple_length_public_key 32 -#define OQS_SIG_sphincs_shake_128f_simple_length_secret_key 64 -#define OQS_SIG_sphincs_shake_128f_simple_length_signature 17088 - -OQS_SIG *OQS_SIG_sphincs_shake_128f_simple_new(void); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_128f_simple_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_128f_simple_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_128f_simple_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_128f_simple_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_128f_simple_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_sphincs_shake_128s_simple) -#define OQS_SIG_sphincs_shake_128s_simple_length_public_key 32 -#define OQS_SIG_sphincs_shake_128s_simple_length_secret_key 64 -#define OQS_SIG_sphincs_shake_128s_simple_length_signature 7856 - -OQS_SIG *OQS_SIG_sphincs_shake_128s_simple_new(void); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_128s_simple_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_128s_simple_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_128s_simple_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_128s_simple_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_128s_simple_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_sphincs_shake_192f_simple) -#define OQS_SIG_sphincs_shake_192f_simple_length_public_key 48 -#define OQS_SIG_sphincs_shake_192f_simple_length_secret_key 96 -#define OQS_SIG_sphincs_shake_192f_simple_length_signature 35664 - -OQS_SIG *OQS_SIG_sphincs_shake_192f_simple_new(void); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_192f_simple_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_192f_simple_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_192f_simple_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_192f_simple_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_192f_simple_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_sphincs_shake_192s_simple) -#define OQS_SIG_sphincs_shake_192s_simple_length_public_key 48 -#define OQS_SIG_sphincs_shake_192s_simple_length_secret_key 96 -#define OQS_SIG_sphincs_shake_192s_simple_length_signature 16224 - -OQS_SIG *OQS_SIG_sphincs_shake_192s_simple_new(void); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_192s_simple_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_192s_simple_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_192s_simple_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_192s_simple_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_192s_simple_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_sphincs_shake_256f_simple) -#define OQS_SIG_sphincs_shake_256f_simple_length_public_key 64 -#define OQS_SIG_sphincs_shake_256f_simple_length_secret_key 128 -#define OQS_SIG_sphincs_shake_256f_simple_length_signature 49856 - -OQS_SIG *OQS_SIG_sphincs_shake_256f_simple_new(void); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_256f_simple_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_256f_simple_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_256f_simple_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_256f_simple_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_256f_simple_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_sphincs_shake_256s_simple) -#define OQS_SIG_sphincs_shake_256s_simple_length_public_key 64 -#define OQS_SIG_sphincs_shake_256s_simple_length_secret_key 128 -#define OQS_SIG_sphincs_shake_256s_simple_length_signature 29792 - -OQS_SIG *OQS_SIG_sphincs_shake_256s_simple_new(void); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_256s_simple_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_256s_simple_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_256s_simple_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_256s_simple_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_sphincs_shake_256s_simple_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#endif diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/sig_stfl.h b/prebuilt_liboqs/linux-x86_64/include/oqs/sig_stfl.h deleted file mode 100644 index 8e81df4..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/sig_stfl.h +++ /dev/null @@ -1,740 +0,0 @@ -/** - * \file sig_stfl.h - * \brief Stateful Signature schemes - * - * The file `tests/example_sig_stfl.c` contains an example on using the OQS_SIG_STFL API. - * - * SPDX-License-Identifier: MIT - */ - -#ifndef OQS_SIG_STATEFUL_H -#define OQS_SIG_STATEFUL_H - -#include -#include -#include - -#include - -/* - * Developer's Notes: - * Stateful signatures are based on the one-time use of a secret key. A pool of secret keys is created for this purpose. - * The state of these keys is tracked to ensure that they are used only once to generate a signature. - * - * As such, product-specific environments do play a role in ensuring the safety of the keys. - * Secret keys must be stored securely. - * The key index/counter must be updated after each signature generation. - * The secret key must be protected in a thread-safe manner. - * - * Applications therefore are required to provide environment-specific callback functions to - * - store private key - * - lock/unlock private key - * - * See below for details - * OQS_SIG_STFL_SECRET_KEY_SET_lock - * OQS_SIG_STFL_SECRET_KEY_SET_unlock - * OQS_SIG_STFL_SECRET_KEY_SET_mutex - * OQS_SIG_STFL_SECRET_KEY_SET_store_cb - * - */ - -#if defined(__cplusplus) -extern "C" -{ -#endif - -/** Algorithm identifier for XMSS-SHA2_10_256 */ -#define OQS_SIG_STFL_alg_xmss_sha256_h10 "XMSS-SHA2_10_256" -/** Algorithm identifier for XMSS-SHA2_16_256 */ -#define OQS_SIG_STFL_alg_xmss_sha256_h16 "XMSS-SHA2_16_256" -/** Algorithm identifier for XMSS-SHA2_20_256 */ -#define OQS_SIG_STFL_alg_xmss_sha256_h20 "XMSS-SHA2_20_256" -/** Algorithm identifier for XMSS-SHAKE_10_256 */ -#define OQS_SIG_STFL_alg_xmss_shake128_h10 "XMSS-SHAKE_10_256" -/** Algorithm identifier for XMSS-SHAKE_16_256 */ -#define OQS_SIG_STFL_alg_xmss_shake128_h16 "XMSS-SHAKE_16_256" -/** Algorithm identifier for XMSS-SHAKE_20_256 */ -#define OQS_SIG_STFL_alg_xmss_shake128_h20 "XMSS-SHAKE_20_256" -/** Algorithm identifier for XMSS-SHA2_10_512 */ -#define OQS_SIG_STFL_alg_xmss_sha512_h10 "XMSS-SHA2_10_512" -/** Algorithm identifier for XMSS-SHA2_16_512 */ -#define OQS_SIG_STFL_alg_xmss_sha512_h16 "XMSS-SHA2_16_512" -/** Algorithm identifier for XMSS-SHA2_20_512 */ -#define OQS_SIG_STFL_alg_xmss_sha512_h20 "XMSS-SHA2_20_512" -/** Algorithm identifier for XMSS-SHAKE_10_512 */ -#define OQS_SIG_STFL_alg_xmss_shake256_h10 "XMSS-SHAKE_10_512" -/** Algorithm identifier for XMSS-SHAKE_16_512 */ -#define OQS_SIG_STFL_alg_xmss_shake256_h16 "XMSS-SHAKE_16_512" -/** Algorithm identifier for XMSS-SHAKE_20_512 */ -#define OQS_SIG_STFL_alg_xmss_shake256_h20 "XMSS-SHAKE_20_512" -/** Algorithm identifier for XMSS-SHA2_10_192 */ -#define OQS_SIG_STFL_alg_xmss_sha256_h10_192 "XMSS-SHA2_10_192" -/** Algorithm identifier for XMSS-SHA2_16_192 */ -#define OQS_SIG_STFL_alg_xmss_sha256_h16_192 "XMSS-SHA2_16_192" -/** Algorithm identifier for XMSS-SHA2_20_192 */ -#define OQS_SIG_STFL_alg_xmss_sha256_h20_192 "XMSS-SHA2_20_192" -/** Algorithm identifier for XMSS-SHAKE256_10_192 */ -#define OQS_SIG_STFL_alg_xmss_shake256_h10_192 "XMSS-SHAKE256_10_192" -/** Algorithm identifier for XMSS-SHAKE256_16_192 */ -#define OQS_SIG_STFL_alg_xmss_shake256_h16_192 "XMSS-SHAKE256_16_192" -/** Algorithm identifier for XMSS-SHAKE256_20_192 */ -#define OQS_SIG_STFL_alg_xmss_shake256_h20_192 "XMSS-SHAKE256_20_192" -/** Algorithm identifier for XMSS-SHAKE256_10_256 */ -#define OQS_SIG_STFL_alg_xmss_shake256_h10_256 "XMSS-SHAKE256_10_256" -/** Algorithm identifier for XMSS-SHAKE256_16_256 */ -#define OQS_SIG_STFL_alg_xmss_shake256_h16_256 "XMSS-SHAKE256_16_256" -/** Algorithm identifier for XMSS-SHAKE256_20_256 */ -#define OQS_SIG_STFL_alg_xmss_shake256_h20_256 "XMSS-SHAKE256_20_256" - -/** Algorithm identifier for XMSSMT-SHA2_20/2_256 */ -#define OQS_SIG_STFL_alg_xmssmt_sha256_h20_2 "XMSSMT-SHA2_20/2_256" -/** Algorithm identifier for XMSSMT-SHA2_20/4_256 */ -#define OQS_SIG_STFL_alg_xmssmt_sha256_h20_4 "XMSSMT-SHA2_20/4_256" -/** Algorithm identifier for XMSSMT-SHA2_40/2_256 */ -#define OQS_SIG_STFL_alg_xmssmt_sha256_h40_2 "XMSSMT-SHA2_40/2_256" -/** Algorithm identifier for XMSSMT-SHA2_40/4_256 */ -#define OQS_SIG_STFL_alg_xmssmt_sha256_h40_4 "XMSSMT-SHA2_40/4_256" -/** Algorithm identifier for XMSSMT-SHA2_40/8_256 */ -#define OQS_SIG_STFL_alg_xmssmt_sha256_h40_8 "XMSSMT-SHA2_40/8_256" -/** Algorithm identifier for XMSSMT-SHA2_60/3_256 */ -#define OQS_SIG_STFL_alg_xmssmt_sha256_h60_3 "XMSSMT-SHA2_60/3_256" -/** Algorithm identifier for XMSSMT-SHA2_60/6_256 */ -#define OQS_SIG_STFL_alg_xmssmt_sha256_h60_6 "XMSSMT-SHA2_60/6_256" -/** Algorithm identifier for XMSSMT-SHA2_60/12_256 */ -#define OQS_SIG_STFL_alg_xmssmt_sha256_h60_12 "XMSSMT-SHA2_60/12_256" -/** Algorithm identifier for XMSSMT-SHAKE_20/2_256 */ -#define OQS_SIG_STFL_alg_xmssmt_shake128_h20_2 "XMSSMT-SHAKE_20/2_256" -/** Algorithm identifier for XMSSMT-SHAKE_20/4_256 */ -#define OQS_SIG_STFL_alg_xmssmt_shake128_h20_4 "XMSSMT-SHAKE_20/4_256" -/** Algorithm identifier for XMSSMT-SHAKE_40/2_256 */ -#define OQS_SIG_STFL_alg_xmssmt_shake128_h40_2 "XMSSMT-SHAKE_40/2_256" -/** Algorithm identifier for XMSSMT-SHAKE_40/4_256 */ -#define OQS_SIG_STFL_alg_xmssmt_shake128_h40_4 "XMSSMT-SHAKE_40/4_256" -/** Algorithm identifier for XMSSMT-SHAKE_40/8_256 */ -#define OQS_SIG_STFL_alg_xmssmt_shake128_h40_8 "XMSSMT-SHAKE_40/8_256" -/** Algorithm identifier for XMSSMT-SHAKE_60/3_256 */ -#define OQS_SIG_STFL_alg_xmssmt_shake128_h60_3 "XMSSMT-SHAKE_60/3_256" -/** Algorithm identifier for XMSSMT-SHAKE_60/6_256 */ -#define OQS_SIG_STFL_alg_xmssmt_shake128_h60_6 "XMSSMT-SHAKE_60/6_256" -/** Algorithm identifier for XMSSMT-SHAKE_60/12_256 */ -#define OQS_SIG_STFL_alg_xmssmt_shake128_h60_12 "XMSSMT-SHAKE_60/12_256" - -/* Defined LMS parameter identifiers */ -/** Algorithm identifier for LMS-SHA256_H5_W1 */ -#define OQS_SIG_STFL_alg_lms_sha256_h5_w1 "LMS_SHA256_H5_W1" //"5/1" -/** Algorithm identifier for LMS-SHA256_H5_W2 */ -#define OQS_SIG_STFL_alg_lms_sha256_h5_w2 "LMS_SHA256_H5_W2" //"5/2" -/** Algorithm identifier for LMS-SHA256_H5_W4 */ -#define OQS_SIG_STFL_alg_lms_sha256_h5_w4 "LMS_SHA256_H5_W4" //"5/4" -/** Algorithm identifier for LMS-SHA256_H5_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h5_w8 "LMS_SHA256_H5_W8" //"5/8" - -/** Algorithm identifier for LMS-SHA256_H10_W1 */ -#define OQS_SIG_STFL_alg_lms_sha256_h10_w1 "LMS_SHA256_H10_W1" //"10/1" -/** Algorithm identifier for LMS-SHA256_H10_W2 */ -#define OQS_SIG_STFL_alg_lms_sha256_h10_w2 "LMS_SHA256_H10_W2" //"10/2" -/** Algorithm identifier for LMS-SHA256_H10_W4 */ -#define OQS_SIG_STFL_alg_lms_sha256_h10_w4 "LMS_SHA256_H10_W4" //"10/4" -/** Algorithm identifier for LMS-SHA256_H10_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h10_w8 "LMS_SHA256_H10_W8" //"10/8" - -/** Algorithm identifier for LMS-SHA256_H15_W1 */ -#define OQS_SIG_STFL_alg_lms_sha256_h15_w1 "LMS_SHA256_H15_W1" //"15/1" -/** Algorithm identifier for LMS-SHA256_H15_W2 */ -#define OQS_SIG_STFL_alg_lms_sha256_h15_w2 "LMS_SHA256_H15_W2" //"15/2" -/** Algorithm identifier for LMS-SHA256_H15_W4 */ -#define OQS_SIG_STFL_alg_lms_sha256_h15_w4 "LMS_SHA256_H15_W4" //"15/4" -/** Algorithm identifier for LMS-SHA256_H15_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h15_w8 "LMS_SHA256_H15_W8" //"15/8" - -/** Algorithm identifier for LMS-SHA256_H20_W1 */ -#define OQS_SIG_STFL_alg_lms_sha256_h20_w1 "LMS_SHA256_H20_W1" //"20/1" -/** Algorithm identifier for LMS-SHA256_H20_W2 */ -#define OQS_SIG_STFL_alg_lms_sha256_h20_w2 "LMS_SHA256_H20_W2" //"20/2" -/** Algorithm identifier for LMS-SHA256_H20_W4 */ -#define OQS_SIG_STFL_alg_lms_sha256_h20_w4 "LMS_SHA256_H20_W4" //"20/4" -/** Algorithm identifier for LMS-SHA256_H20_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h20_w8 "LMS_SHA256_H20_W8" //"20/8" - -/** Algorithm identifier for LMS-SHA256_H25_W1 */ -#define OQS_SIG_STFL_alg_lms_sha256_h25_w1 "LMS_SHA256_H25_W1" //"25/1" -/** Algorithm identifier for LMS-SHA256_H25_W2 */ -#define OQS_SIG_STFL_alg_lms_sha256_h25_w2 "LMS_SHA256_H25_W2" //"25/2" -/** Algorithm identifier for LMS-SHA256_H25_W4 */ -#define OQS_SIG_STFL_alg_lms_sha256_h25_w4 "LMS_SHA256_H25_W4" //"25/4" -/** Algorithm identifier for LMS-SHA256_H25_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h25_w8 "LMS_SHA256_H25_W8" //"25/8" - -// 2-Level LMS -/** Algorithm identifier for LMS-SHA256_H5_W8_H5_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h5_w8_h5_w8 "LMS_SHA256_H5_W8_H5_W8" //"5/8, 5/8" - -// RFC 6554 -/** Algorithm identifier for LMS-SHA256_H10_W4_H5_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h10_w4_h5_w8 "LMS_SHA256_H10_W4_H5_W8" //"10/4, 5/8" - -/** Algorithm identifier for LMS-SHA256_H10_W8_H5_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h10_w8_h5_w8 "LMS_SHA256_H10_W8_H5_W8" //"10/8, 5/8" -/** Algorithm identifier for LMS-SHA256_H10_W2_H10_W2 */ -#define OQS_SIG_STFL_alg_lms_sha256_h10_w2_h10_w2 "LMS_SHA256_H10_W2_H10_W2" //"10/2, 10/2" -/** Algorithm identifier for LMS-SHA256_H10_W4_H10_W4 */ -#define OQS_SIG_STFL_alg_lms_sha256_h10_w4_h10_w4 "LMS_SHA256_H10_W4_H10_W4" //"10/4, 10/4" -/** Algorithm identifier for LMS-SHA256_H10_W8_H10_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h10_w8_h10_w8 "LMS_SHA256_H10_W8_H10_W8" //"10/8, 10/8" - -/** Algorithm identifier for LMS-SHA256_H15_W8_H5_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h15_w8_h5_w8 "LMS_SHA256_H15_W8_H5_W8" //"15/8, 5/8" -/** Algorithm identifier for LMS-SHA256_H15_W8_H10_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h15_w8_h10_w8 "LMS_SHA256_H15_W8_H10_W8" //"15/8, 10/8" -/** Algorithm identifier for LMS-SHA256_H15_W8_H15_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h15_w8_h15_w8 "LMS_SHA256_H15_W8_H15_W8" //"15/8, 15/8" - -/** Algorithm identifier for LMS-SHA256_H20_W8_H5_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h20_w8_h5_w8 "LMS_SHA256_H20_W8_H5_W8" //"20/8, 5/8" -/** Algorithm identifier for LMS-SHA256_H20_W8_H10_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h20_w8_h10_w8 "LMS_SHA256_H20_W8_H10_W8" //"20/8, 10/8" -/** Algorithm identifier for LMS-SHA256_H20_W8_H15_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h20_w8_h15_w8 "LMS_SHA256_H20_W8_H15_W8" //"20/8, 15/8" -/** Algorithm identifier for LMS-SHA256_H20_W8_H20_W8 */ -#define OQS_SIG_STFL_alg_lms_sha256_h20_w8_h20_w8 "LMS_SHA256_H20_W8_H20_W8" //"20/8, 20/8" - -/** Total number of stateful variants defined above, used to create the tracking array */ -#define OQS_SIG_STFL_algs_length 70 - -typedef struct OQS_SIG_STFL_SECRET_KEY OQS_SIG_STFL_SECRET_KEY; - -/** - * Application provided function to securely store data - * @param[in] sk_buf pointer to the data to be saved - * @param[in] buf_len length of the data to be stored - * @param[out] context pass back application data related to secret key data storage. - * return OQS_SUCCESS if successful, otherwise OQS_ERROR - */ -typedef OQS_STATUS (*secure_store_sk)(uint8_t *sk_buf, size_t buf_len, void *context); - -/** - * Application provided function to lock secret key object serialize access - * @param[in] mutex pointer to mutex struct - * return OQS_SUCCESS if successful, otherwise OQS_ERROR - */ -typedef OQS_STATUS (*lock_key)(void *mutex); - -/** - * Application provided function to unlock secret key object - * @param[in] mutex pointer to mutex struct - * return OQS_SUCCESS if successful, otherwise OQS_ERROR - */ -typedef OQS_STATUS (*unlock_key)(void *mutex); - -/** - * Returns identifiers for available signature schemes in liboqs. Used with `OQS_SIG_STFL_new`. - * - * Note that algorithm identifiers are present in this list even when the algorithm is disabled - * at compile time. - * - * @param[in] i Index of the algorithm identifier to return, 0 <= i < OQS_SIG_algs_length - * @return Algorithm identifier as a string, or NULL. - */ -OQS_API const char *OQS_SIG_STFL_alg_identifier(size_t i); - -/** - * Returns the number of stateful signature mechanisms in liboqs. They can be enumerated with - * OQS_SIG_STFL_alg_identifier. - * - * Note that some mechanisms may be disabled at compile time. - * - * @return The number of stateful signature mechanisms. - */ -OQS_API int OQS_SIG_STFL_alg_count(void); - -/** - * Indicates whether the specified algorithm was enabled at compile-time or not. - * - * @param[in] method_name Name of the desired algorithm; one of the names in `OQS_SIG_STFL_algs`. - * @return 1 if enabled, 0 if disabled or not found - */ -OQS_API int OQS_SIG_STFL_alg_is_enabled(const char *method_name); - -#ifndef OQS_ALLOW_STFL_KEY_AND_SIG_GEN - -/** Signature schemes object */ -typedef struct OQS_SIG OQS_SIG; - -/** Stateful signature scheme object */ -#define OQS_SIG_STFL OQS_SIG -#else - -/** Stateful signature scheme object */ -typedef struct OQS_SIG_STFL { - - /** - * A local ordinal representing the LMS/XMSS OID parameter of the signature scheme. - * This OID is unrelated to ASN.1 OID, it's only for LMS/XMSS internal usage. - */ - uint32_t oid; - - /** Printable string representing the name of the signature scheme. */ - const char *method_name; - - /** - * Printable string representing the version of the cryptographic algorithm. - * - * Implementations with the same method_name and same alg_version will be interoperable. - * See README.md for information about algorithm compatibility. - */ - const char *alg_version; - - /** Whether the signature offers EUF-CMA security (TRUE) or not (FALSE). */ - bool euf_cma; - - /** Whether the signature offers SUF-CMA security (TRUE) or not (FALSE). */ - bool suf_cma; - - /** The (maximum) length, in bytes, of public keys for this signature scheme. */ - size_t length_public_key; - /** The (maximum) length, in bytes, of secret keys for this signature scheme. */ - size_t length_secret_key; - /** The (maximum) length, in bytes, of signatures for this signature scheme. */ - size_t length_signature; - - /** - * Keypair generation algorithm. - * - * Caller is responsible for allocating sufficient memory for `public_key` - * based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_SIG_STFL_*_length_*`. - * - * @param[out] public_key The public key is represented as a byte string. - * @param[out] secret_key The secret key object - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*keypair)(uint8_t *public_key, OQS_SIG_STFL_SECRET_KEY *secret_key); - - /** - * Signature generation algorithm. - * - * For stateful signatures, there is always a limited number of signatures that can be used, - * The private key signature counter is increased by one once a signature is successfully generated, - * When the signature counter reaches the maximum number of available signatures, the signature generation always fails. - * - * Caller is responsible for allocating sufficient memory for `signature`, - * based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_SIG_STFL_*_length_*`. - * - * @param[out] signature The signature on the message is represented as a byte string. - * @param[out] signature_len The length of the signature. - * @param[in] message The message to sign is represented as a byte string. - * @param[in] message_len The length of the message to sign. - * @param[in] secret_key The secret key object pointer. - * @return OQS_SUCCESS or OQS_ERROR - * - * @note Internally, if `lock/unlock` functions and `mutex` are set, it will attempt to lock the private key and unlock - * the private key after the Signing operation is completed. - */ - OQS_STATUS (*sign)(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, OQS_SIG_STFL_SECRET_KEY *secret_key); - - /** - * Signature verification algorithm. - * - * @param[in] message The message is represented as a byte string. - * @param[in] message_len The length of the message. - * @param[in] signature The signature on the message is represented as a byte string. - * @param[in] signature_len The length of the signature. - * @param[in] public_key The public key is represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*verify)(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); - - /** - * Query the number of remaining signatures. - * - * The remaining signatures are the number of signatures available before the private key runs out of its total signature and expires. - * - * @param[out] remain The number of remaining signatures - * @param[in] secret_key The secret key object pointer. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*sigs_remaining)(unsigned long long *remain, const OQS_SIG_STFL_SECRET_KEY *secret_key); - - /** - * Query the total number of signatures. - * - * The total number of signatures is the constant number present in how many signatures can be generated from a private key. - * - * @param[out] total The total number of signatures - * @param[in] secret_key The secret key key object pointer. - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*sigs_total)(unsigned long long *total, const OQS_SIG_STFL_SECRET_KEY *secret_key); - -} OQS_SIG_STFL; -#endif //OQS_ALLOW_STFL_KEY_AND_SIG_GEN - -/** - * @brief OQS_SIG_STFL_SECRET_KEY object for stateful signature schemes - */ - -typedef struct OQS_SIG_STFL_SECRET_KEY { - - /** The (maximum) length, in bytes, of secret keys for this signature scheme. */ - size_t length_secret_key; - - /** The variant-specific secret key data must be allocated at the initialization. */ - void *secret_key_data; - - /** The mutual exclusion struct */ - void *mutex; - - /** Application-managed data related to secure storage of secret key data */ - void *context; - - /** - * Serialize the stateful secret key. - * - * This function encodes the stateful secret key represented by `sk` into a byte stream - * for storage or transfer. The `sk_buf_ptr` will point to the allocated memory containing - * the byte stream. Users must free the `sk_buf_ptr` using `OQS_MEM_secure_free` after use. - * The `sk_len` will contain the length of the byte stream. - * - * @param[out] sk_buf_ptr Pointer to the byte stream representing the serialized secret key. - * @param[out] sk_buf_len Pointer to the length of the serialized byte stream. - * @param[in] sk Pointer to the `OQS_SIG_STFL_SECRET_KEY` object to serialize. - * @return The number of bytes in the serialized byte stream upon success, or an OQS error code on failure. - * - * @attention The caller is responsible for ensuring that `sk` is a valid object before calling this function. - */ - OQS_STATUS (*serialize_key)(uint8_t **sk_buf_ptr, size_t *sk_buf_len, const OQS_SIG_STFL_SECRET_KEY *sk); - - /** - * Deserialize a byte stream into the internal representation of a stateful secret key. - * - * This function takes a series of bytes representing a stateful secret key and initializes - * the internal `OQS_SIG_STFL_SECRET_KEY` object with the key material. This is particularly - * useful for reconstructing key objects from persisted or transmitted state. - * - * @param[out] sk Pointer to an uninitialized `OQS_SIG_STFL_SECRET_KEY` object to hold the secret key. - * @param[in] sk_buf Pointer to the byte stream containing the serialized secret key data. - * @param[in] sk_buf_len The length of the secret key byte stream. - * @param[in] context Pointer to application-specific data, handled externally, associated with the key. - * @returns OQS_SUCCESS if the deserialization succeeds, with the `sk` object populated with the key material. - * - * @attention The caller is responsible for ensuring that `sk_buf` is securely deallocated when it's no longer needed. - */ - OQS_STATUS (*deserialize_key)(OQS_SIG_STFL_SECRET_KEY *sk, const uint8_t *sk_buf, const size_t sk_buf_len, void *context); - - /** - * Secret Key Locking Function - * - * @param[in] mutex application defined mutex - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*lock_key)(void *mutex); - - /** - * Secret Key Unlocking / Releasing Function - * - * @param[in] mutex application defined mutex - * @return OQS_SUCCESS or OQS_ERROR - */ - OQS_STATUS (*unlock_key)(void *mutex); - - /** - * Store Secret Key Function - * - * Callback function used to securely store key data after a signature generation. - * When populated, this pointer points to the application-supplied secure storage function. - * @param[in] sk_buf The serialized secret key data to secure store - * @param[in] sk_buf_len length of data to secure - * @param[in] context application supplied data used to locate where this secret key - * is stored (passed in at the time the function pointer was set). - * - * @return OQS_SUCCESS or OQS_ERROR - * Ideally written to a secure device. - */ - OQS_STATUS (*secure_store_scrt_key)(uint8_t *sk_buf, size_t sk_buf_len, void *context); - - /** - * Free internal variant-specific data - * - * @param[in] sk The secret key represented as OQS_SIG_STFL_SECRET_KEY object. - * @return None. - */ - void (*free_key)(OQS_SIG_STFL_SECRET_KEY *sk); - - /** - * Set Secret Key Store Callback Function - * - * This function is used to establish a callback mechanism for secure storage - * of private keys involved in stateful signature Signing operation. The secure storage - * and the management of private keys is the responsibility of the adopting application. - * Therefore, before invoking stateful signature generation, a callback function and - * associated context data must be provided by the application to manage the storage. - * - * The `context` argument is designed to hold information requisite for private key storage, - * such as a hardware security module (HSM) context, a file path, or other relevant data. - * This context is passed to the libOQS when the callback function is registered. - * - * @param[in] sk A pointer to the secret key object that requires secure storage management - * after signature Signing operations. - * @param[in] store_cb A pointer to the callback function provided by the application - * for storing and updating the private key securely. - * @param[in] context Application-specific context information for the private key storage, - * furnished when setting the callback function via - * OQS_SIG_STFL_SECRET_KEY_set_store_cb(). - * @return None. - */ - void (*set_scrt_key_store_cb)(OQS_SIG_STFL_SECRET_KEY *sk, secure_store_sk store_cb, void *context); -} OQS_SIG_STFL_SECRET_KEY; - -/** - * Constructs an OQS_SIG_STFL object for a particular algorithm. - * - * Callers should always check whether the return value is `NULL`, which indicates either than an - * invalid algorithm name was provided, or that the requested algorithm was disabled at compile-time. - * - * @param[in] method_name Name of the desired algorithm; one of the names in `OQS_SIG_STFL_algs`. - * @return An OQS_SIG_STFL for the particular algorithm, or `NULL` if the algorithm has been disabled at compile-time. - */ -OQS_API OQS_SIG_STFL *OQS_SIG_STFL_new(const char *method_name); - -/** - * Keypair generation algorithm. - * - * Caller is responsible for allocating sufficient memory for `public_key` based - * on the `length_*` members in this object or the per-scheme compile-time macros - * `OQS_SIG_STFL_*_length_*`. The caller is also responsible for initializing - * `secret_key` using the OQS_SIG_STFL_SECRET_KEY(*) function. - * - * @param[in] sig The OQS_SIG_STFL object representing the signature scheme. - * @param[out] public_key The public key is represented as a byte string. - * @param[out] secret_key The secret key object pointer. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_SIG_STFL_keypair(const OQS_SIG_STFL *sig, uint8_t *public_key, OQS_SIG_STFL_SECRET_KEY *secret_key); - -/** - * Signature generation algorithm. - * - * For stateful signatures, there is always a limited number of signatures that can be used, - * The private key signature counter is increased by one once a signature is successfully generated, - * When the signature counter reaches the maximum number of available signatures, the signature generation always fails. - * - * Caller is responsible for allocating sufficient memory for `signature`, - * based on the `length_*` members in this object or the per-scheme - * compile-time macros `OQS_SIG_STFL_*_length_*`. - * - * @param[in] sig The OQS_SIG_STFL object representing the signature scheme. - * @param[out] signature The signature on the message is represented as a byte string. - * @param[out] signature_len The length of the signature. - * @param[in] message The message to sign is represented as a byte string. - * @param[in] message_len The length of the message to sign. - * @param[in] secret_key The secret key object pointer. - * @return OQS_SUCCESS or OQS_ERROR - * - * @note Internally, if `lock/unlock` functions and `mutex` are set, it will attempt to lock the private key and unlock - * the private key after the Signing operation is completed. - */ -OQS_API OQS_STATUS OQS_SIG_STFL_sign(const OQS_SIG_STFL *sig, uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, OQS_SIG_STFL_SECRET_KEY *secret_key); - -/** - * Signature verification algorithm. - * - * @param[in] sig The OQS_SIG_STFL object representing the signature scheme. - * @param[in] message The message is represented as a byte string. - * @param[in] message_len The length of the message. - * @param[in] signature The signature on the message is represented as a byte string. - * @param[in] signature_len The length of the signature. - * @param[in] public_key The public key is represented as a byte string. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_SIG_STFL_verify(const OQS_SIG_STFL *sig, const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); - -/** - * Query the number of remaining signatures. - * - * The remaining signatures are the number of signatures available before the private key runs out of its total signature and expires. - * - * @param[in] sig The OQS_SIG_STFL object representing the signature scheme. - * @param[in] remain The number of remaining signatures. - * @param[in] secret_key The secret key object. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_SIG_STFL_sigs_remaining(const OQS_SIG_STFL *sig, unsigned long long *remain, const OQS_SIG_STFL_SECRET_KEY *secret_key); - -/** - * Query the total number of signatures. - * - * The total number of signatures is the constant number present in how many signatures can be generated from a private key. - * - * @param[in] sig The OQS_SIG_STFL object representing the signature scheme. - * @param[out] max The number of remaining signatures - * @param[in] secret_key The secret key object. - * @return OQS_SUCCESS or OQS_ERROR - */ -OQS_API OQS_STATUS OQS_SIG_STFL_sigs_total(const OQS_SIG_STFL *sig, unsigned long long *max, const OQS_SIG_STFL_SECRET_KEY *secret_key); - -/** - * Free an OQS_SIG_STFL object that was constructed by OQS_SIG_STFL_new. - * - */ -OQS_API void OQS_SIG_STFL_free(OQS_SIG_STFL *sig); - -/** - * Construct an OQS_SIG_STFL_SECRET_KEY object for a particular algorithm. - * - * Callers should always check whether the return value is `NULL`, which indicates either than an - * invalid algorithm name was provided, or that the requested algorithm was disabled at compile-time. - * - * @param[in] method_name Name of the desired algorithm; one of the names in `OQS_SIG_STFL_algs`. - * @return An OQS_SIG_STFL_SECRET_KEY for the particular algorithm, or `NULL` if the algorithm has been disabled at compile-time. - */ -OQS_API OQS_SIG_STFL_SECRET_KEY *OQS_SIG_STFL_SECRET_KEY_new(const char *method_name); - -/** - * Free an OQS_SIG_STFL_SECRET_KEY object that was constructed by OQS_SECRET_KEY_new. - * - * @param[in] sk The OQS_SIG_STFL_SECRET_KEY object to free. - */ -OQS_API void OQS_SIG_STFL_SECRET_KEY_free(OQS_SIG_STFL_SECRET_KEY *sk); - -/** - * Attach a locking mechanism to a secret key object. - * - * This allows for proper synchronization in a multi-threaded or multi-process environment, - * by ensuring that a secret key is not used concurrently by multiple entities, which could otherwise lead to security issues. - * - * @param[in] sk Pointer to the secret key object whose lock function is to be set. - * @param[in] lock Function pointer to the locking routine provided by the application. - * - * @note It's not required to set the lock and unlock functions in a single-threaded environment. - * - * @note Once the `lock` function is set, users must also set the `mutex` and `unlock` functions. - * - * @note By default, the internal value of `sk->lock` is NULL, which does nothing to lock the private key. - */ -OQS_API void OQS_SIG_STFL_SECRET_KEY_SET_lock(OQS_SIG_STFL_SECRET_KEY *sk, lock_key lock); - -/** - * Attach an unlock mechanism to a secret key object. - * - * This allows for proper synchronization in a multi-threaded or multi-process environment, - * by ensuring that a secret key is not used concurrently by multiple entities, which could otherwise lead to security issues. - * - * @param[in] sk Pointer to the secret key object whose unlock function is to be set. - * @param[in] unlock Function pointer to the unlock routine provided by the application. - * - * @note It's not required to set the lock and unlock functions in a single-threaded environment. - * - * @note Once the `unlock` function is set, users must also set the `mutex` and `lock` functions. - * - * @note By default, the internal value of `sk->unlock` is NULL, which does nothing to unlock the private key. - */ -OQS_API void OQS_SIG_STFL_SECRET_KEY_SET_unlock(OQS_SIG_STFL_SECRET_KEY *sk, unlock_key unlock); - -/** - * Assign a mutex function to handle concurrency control over the secret key. - * - * This is to ensure that only one process can access or modify the key at any given time. - * - * @param[in] sk A pointer to the secret key that the mutex functionality will protect. - * @param[in] mutex A function pointer to the desired concurrency control mechanism. - * - * @note It's not required to set the lock and unlock functions in a single-threaded environment. - * - * @note By default, the internal value of `sk->mutex` is NULL, it must be set to be used in `lock` or `unlock` the private key. - */ -OQS_API void OQS_SIG_STFL_SECRET_KEY_SET_mutex(OQS_SIG_STFL_SECRET_KEY *sk, void *mutex); - -/** - * Lock the secret key to ensure exclusive access in a concurrent environment. - * - * If the `mutex` is not set, this lock operation will fail. - * This lock operation is essential in multi-threaded or multi-process contexts - * to prevent simultaneous Signing operations that could compromise the stateful signature security. - * - * @warning If the `lock` function is set and `mutex` is not set, this lock operation will fail. - * - * @param[in] sk Pointer to the secret key to be locked. - * @return OQS_SUCCESS if the lock is successfully applied; OQS_ERROR otherwise. - * - * @note It's not necessary to use this function in either Keygen or Verifying operations. - * In a concurrent environment, the user is responsible for locking and unlocking the private key, - * to make sure that only one thread can access the private key during a Signing operation. - * - * @note If the `lock` function and `mutex` are both set, proceed to lock the private key. - */ -OQS_STATUS OQS_SIG_STFL_SECRET_KEY_lock(OQS_SIG_STFL_SECRET_KEY *sk); - -/** - * Unlock the secret key, making it accessible to other processes. - * - * This function is crucial in environments where multiple processes need to coordinate access to - * the secret key, as it allows a process to signal that it has finished using the key, so - * others can safely use it. - * - * @warning If the `unlock` function is set and `mutex` is not set, this unlock operation will fail. - * - * @param[in] sk Pointer to the secret key whose lock should be released. - * @return OQS_SUCCESS if the lock was successfully released; otherwise, OQS_ERROR. - * - * @note It's not necessary to use this function in either Keygen or Verifying operations. - * In a concurrent environment, the user is responsible for locking and unlocking the private key, - * to make sure that only one thread can access the private key during a Signing operation. - * - * @note If the `unlock` function and `mutex` are both set, proceed to unlock the private key. - */ -OQS_STATUS OQS_SIG_STFL_SECRET_KEY_unlock(OQS_SIG_STFL_SECRET_KEY *sk); - -/** - * Set the callback and context for securely storing a stateful secret key. - * - * This function is designed to be called after a new stateful secret key - * has been generated. It enables the library to securely store secret key - * and update it every time a Signing operation occurs. - * Without properly setting this callback and context, signature generation - * will not succeed as the updated state of the secret key cannot be preserved. - * - * @param[in] sk Pointer to the stateful secret key to be managed. - * @param[in] store_cb Callback function that handles the secure storage of the key. - * @param[in] context Application-specific context that assists in the storage of secret key data. - * This context is managed by the application, which allocates it, keeps track of it, - * and deallocates it as necessary. - */ -OQS_API void OQS_SIG_STFL_SECRET_KEY_SET_store_cb(OQS_SIG_STFL_SECRET_KEY *sk, secure_store_sk store_cb, void *context); - -/** - * Serialize the stateful secret key data into a byte array. - * - * Converts an OQS_SIG_STFL_SECRET_KEY object into a byte array for storage or transmission. - * - * @param[out] sk_buf_ptr Pointer to the allocated byte array containing the serialized key. - * @param[out] sk_buf_len Length of the serialized key byte array. - * @param[in] sk Pointer to the OQS_SIG_STFL_SECRET_KEY object to be serialized. - * @return OQS_SUCCESS on success, or an OQS error code on failure. - * - * @note The function allocates memory for the byte array, and it is the caller's responsibility to free this memory after use. - */ -OQS_API OQS_STATUS OQS_SIG_STFL_SECRET_KEY_serialize(uint8_t **sk_buf_ptr, size_t *sk_buf_len, const OQS_SIG_STFL_SECRET_KEY *sk); - -/** - * Deserialize a byte array into an OQS_SIG_STFL_SECRET_KEY object. - * - * Transforms a binary representation of a secret key into an OQS_SIG_STFL_SECRET_KEY structure. - * After deserialization, the secret key object can be used for subsequent cryptographic operations. - * - * @param[out] sk A pointer to the secret key object that will be populated from the binary data. - * @param[in] sk_buf The buffer containing the serialized secret key data. - * @param[in] sk_buf_len The length of the binary secret key data in bytes. - * @param[in] context Application-specific data used to maintain context about the secret key. - * @return OQS_SUCCESS if deserialization was successful; otherwise, OQS_ERROR. - * - * @attention The caller is responsible for freeing the `sk_buf` memory when it is no longer needed. - */ -OQS_API OQS_STATUS OQS_SIG_STFL_SECRET_KEY_deserialize(OQS_SIG_STFL_SECRET_KEY *sk, const uint8_t *sk_buf, size_t sk_buf_len, void *context); - -#if defined(__cplusplus) -// extern "C" -} -#endif - -#endif /* OQS_SIG_STATEFUL_H */ diff --git a/prebuilt_liboqs/linux-x86_64/include/oqs/sig_uov.h b/prebuilt_liboqs/linux-x86_64/include/oqs/sig_uov.h deleted file mode 100644 index 47b829f..0000000 --- a/prebuilt_liboqs/linux-x86_64/include/oqs/sig_uov.h +++ /dev/null @@ -1,164 +0,0 @@ -// SPDX-License-Identifier: MIT - -#ifndef OQS_SIG_UOV_H -#define OQS_SIG_UOV_H - -#include - -#if defined(OQS_ENABLE_SIG_uov_ov_Is) -#define OQS_SIG_uov_ov_Is_length_public_key 412160 -#define OQS_SIG_uov_ov_Is_length_secret_key 348704 -#define OQS_SIG_uov_ov_Is_length_signature 96 - -OQS_SIG *OQS_SIG_uov_ov_Is_new(void); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_uov_ov_Ip) -#define OQS_SIG_uov_ov_Ip_length_public_key 278432 -#define OQS_SIG_uov_ov_Ip_length_secret_key 237896 -#define OQS_SIG_uov_ov_Ip_length_signature 128 - -OQS_SIG *OQS_SIG_uov_ov_Ip_new(void); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_uov_ov_III) -#define OQS_SIG_uov_ov_III_length_public_key 1225440 -#define OQS_SIG_uov_ov_III_length_secret_key 1044320 -#define OQS_SIG_uov_ov_III_length_signature 200 - -OQS_SIG *OQS_SIG_uov_ov_III_new(void); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_uov_ov_V) -#define OQS_SIG_uov_ov_V_length_public_key 2869440 -#define OQS_SIG_uov_ov_V_length_secret_key 2436704 -#define OQS_SIG_uov_ov_V_length_signature 260 - -OQS_SIG *OQS_SIG_uov_ov_V_new(void); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_uov_ov_Is_pkc) -#define OQS_SIG_uov_ov_Is_pkc_length_public_key 66576 -#define OQS_SIG_uov_ov_Is_pkc_length_secret_key 348704 -#define OQS_SIG_uov_ov_Is_pkc_length_signature 96 - -OQS_SIG *OQS_SIG_uov_ov_Is_pkc_new(void); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_pkc_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_pkc_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_pkc_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_pkc_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_pkc_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_uov_ov_Ip_pkc) -#define OQS_SIG_uov_ov_Ip_pkc_length_public_key 43576 -#define OQS_SIG_uov_ov_Ip_pkc_length_secret_key 237896 -#define OQS_SIG_uov_ov_Ip_pkc_length_signature 128 - -OQS_SIG *OQS_SIG_uov_ov_Ip_pkc_new(void); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_pkc_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_pkc_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_pkc_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_pkc_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_pkc_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_uov_ov_III_pkc) -#define OQS_SIG_uov_ov_III_pkc_length_public_key 189232 -#define OQS_SIG_uov_ov_III_pkc_length_secret_key 1044320 -#define OQS_SIG_uov_ov_III_pkc_length_signature 200 - -OQS_SIG *OQS_SIG_uov_ov_III_pkc_new(void); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_pkc_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_pkc_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_pkc_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_pkc_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_pkc_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_uov_ov_V_pkc) -#define OQS_SIG_uov_ov_V_pkc_length_public_key 446992 -#define OQS_SIG_uov_ov_V_pkc_length_secret_key 2436704 -#define OQS_SIG_uov_ov_V_pkc_length_signature 260 - -OQS_SIG *OQS_SIG_uov_ov_V_pkc_new(void); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_pkc_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_pkc_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_pkc_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_pkc_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_pkc_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_uov_ov_Is_pkc_skc) -#define OQS_SIG_uov_ov_Is_pkc_skc_length_public_key 66576 -#define OQS_SIG_uov_ov_Is_pkc_skc_length_secret_key 32 -#define OQS_SIG_uov_ov_Is_pkc_skc_length_signature 96 - -OQS_SIG *OQS_SIG_uov_ov_Is_pkc_skc_new(void); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_pkc_skc_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_pkc_skc_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_pkc_skc_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_pkc_skc_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Is_pkc_skc_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_uov_ov_Ip_pkc_skc) -#define OQS_SIG_uov_ov_Ip_pkc_skc_length_public_key 43576 -#define OQS_SIG_uov_ov_Ip_pkc_skc_length_secret_key 32 -#define OQS_SIG_uov_ov_Ip_pkc_skc_length_signature 128 - -OQS_SIG *OQS_SIG_uov_ov_Ip_pkc_skc_new(void); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_pkc_skc_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_pkc_skc_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_pkc_skc_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_pkc_skc_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_Ip_pkc_skc_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_uov_ov_III_pkc_skc) -#define OQS_SIG_uov_ov_III_pkc_skc_length_public_key 189232 -#define OQS_SIG_uov_ov_III_pkc_skc_length_secret_key 32 -#define OQS_SIG_uov_ov_III_pkc_skc_length_signature 200 - -OQS_SIG *OQS_SIG_uov_ov_III_pkc_skc_new(void); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_pkc_skc_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_pkc_skc_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_pkc_skc_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_pkc_skc_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_III_pkc_skc_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#if defined(OQS_ENABLE_SIG_uov_ov_V_pkc_skc) -#define OQS_SIG_uov_ov_V_pkc_skc_length_public_key 446992 -#define OQS_SIG_uov_ov_V_pkc_skc_length_secret_key 32 -#define OQS_SIG_uov_ov_V_pkc_skc_length_signature 260 - -OQS_SIG *OQS_SIG_uov_ov_V_pkc_skc_new(void); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_pkc_skc_keypair(uint8_t *public_key, uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_pkc_skc_sign(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_pkc_skc_verify(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *public_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_pkc_skc_sign_with_ctx_str(uint8_t *signature, size_t *signature_len, const uint8_t *message, size_t message_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *secret_key); -OQS_API OQS_STATUS OQS_SIG_uov_ov_V_pkc_skc_verify_with_ctx_str(const uint8_t *message, size_t message_len, const uint8_t *signature, size_t signature_len, const uint8_t *ctx, size_t ctxlen, const uint8_t *public_key); -#endif - -#endif diff --git a/prebuilt_liboqs/linux-x86_64/lib/liboqs.so b/prebuilt_liboqs/linux-x86_64/lib/liboqs.so deleted file mode 100755 index 490c23b..0000000 Binary files a/prebuilt_liboqs/linux-x86_64/lib/liboqs.so and /dev/null differ diff --git a/prebuilt_liboqs/linux-x86_64/lib/liboqs.so.0.15.0-rc1 b/prebuilt_liboqs/linux-x86_64/lib/liboqs.so.0.15.0-rc1 deleted file mode 100755 index 490c23b..0000000 Binary files a/prebuilt_liboqs/linux-x86_64/lib/liboqs.so.0.15.0-rc1 and /dev/null differ diff --git a/prebuilt_liboqs/linux-x86_64/lib/liboqs.so.9 b/prebuilt_liboqs/linux-x86_64/lib/liboqs.so.9 deleted file mode 100755 index 490c23b..0000000 Binary files a/prebuilt_liboqs/linux-x86_64/lib/liboqs.so.9 and /dev/null differ diff --git a/rust-toolchain.toml b/rust-toolchain.toml new file mode 100644 index 0000000..85f3606 --- /dev/null +++ b/rust-toolchain.toml @@ -0,0 +1,4 @@ +[toolchain] +channel = "stable" +components = ["rustfmt", "clippy"] +profile = "minimal" diff --git a/rustfmt.toml b/rustfmt.toml new file mode 100644 index 0000000..3b286b9 --- /dev/null +++ b/rustfmt.toml @@ -0,0 +1,3 @@ +edition = "2021" +max_width = 100 +newline_style = "Unix" diff --git a/transport-core/src/ctap/constants.rs b/transport-core/src/ctap/constants.rs index d803910..0e5f2f5 100644 --- a/transport-core/src/ctap/constants.rs +++ b/transport-core/src/ctap/constants.rs @@ -2,6 +2,7 @@ pub const CTAP_CMD_MAKE_CREDENTIAL: u8 = 0x01; pub const CTAP_CMD_GET_ASSERTION: u8 = 0x02; pub const CTAP_CMD_GET_INFO: u8 = 0x04; pub const CTAP_CMD_CLIENT_PIN: u8 = 0x06; +pub const CTAP_CMD_RESET: u8 = 0x07; pub const CTAP_CMD_GET_NEXT_ASSERTION: u8 = 0x08; pub const CTAP_CMD_CREDENTIAL_MANAGEMENT: u8 = 0x0A; pub const CTAP_CMD_BIO_ENROLLMENT: u8 = 0x40; diff --git a/transport-core/src/state.rs b/transport-core/src/state.rs index ad8c2dc..8e771ba 100644 --- a/transport-core/src/state.rs +++ b/transport-core/src/state.rs @@ -214,6 +214,38 @@ impl PersistentStore { ensure_metadata(fs, &identity)?; Ok(()) } + + /// Read the persistent PIN state from disk, returning defaults if no + /// `pin-state.cbor` exists yet. + pub fn read_pin_state(&self) -> io::Result { + read_pin_state_from(self.store().ifs) + } + + /// Persist a new PIN state record, overwriting any existing entry. + pub fn write_pin_state(&self, pin_state: &StoredPinState) -> io::Result<()> { + write_pin_state_to(self.store().ifs, pin_state) + } + + /// Wipe every credential and reset PIN state to defaults. This is the + /// authenticator-side equivalent of the CTAP `authenticatorReset` + /// command. Attestation key/cert and device metadata are preserved. + pub fn reset(&mut self) -> io::Result<()> { + let fs = self.store().ifs; + if fs.exists(&path!("credentials.cbor")) { + fs.remove(&path!("credentials.cbor")) + .map_err(map_fs_error)?; + } + write_pin_state_to(fs, &StoredPinState::default())?; + Ok(()) + } +} + +/// Wipe every credential and PIN state file under `base`, without going +/// through `PersistentStore` (used by `feitian-authenticator reset` when +/// the daemon is detached). +pub fn reset_state_dir(base: &Path) -> io::Result<()> { + let mut store = PersistentStore::new(base)?; + store.reset() } #[derive(Clone, Copy)] @@ -230,14 +262,32 @@ struct StoredAttestation { certificate_chain: Vec>, } -#[derive(Serialize, Deserialize)] -struct StoredPinState { - pin_hash: Option<[u8; 16]>, - pin_retries: u8, - consecutive_failures: u8, - pin_auth_blocked: bool, +/// Persistent PIN state, mirrored on disk under `pin-state.cbor` in the +/// authenticator's internal filesystem. Mutating it requires the daemon to +/// be stopped (no IPC channel exists today). +#[derive(Serialize, Deserialize, Debug, Clone)] +pub struct StoredPinState { + pub pin_hash: Option<[u8; 16]>, + pub pin_retries: u8, + pub consecutive_failures: u8, + pub pin_auth_blocked: bool, +} + +impl Default for StoredPinState { + fn default() -> Self { + Self { + pin_hash: None, + pin_retries: DEFAULT_PIN_RETRIES, + consecutive_failures: 0, + pin_auth_blocked: false, + } + } } +/// Default number of PIN attempts allowed before the authenticator is +/// permanently blocked until a Reset. +pub const DEFAULT_PIN_RETRIES: u8 = 8; + #[derive(Serialize, Deserialize)] struct StoredDeviceMetadata { aaguid: [u8; 16], @@ -276,19 +326,41 @@ fn ensure_pin_state(fs: &'static dyn DynFilesystem) -> io::Result<()> { if fs.exists(&path!("pin-state.cbor")) { return Ok(()); } - let pin_state = StoredPinState { - pin_hash: None, - pin_retries: 8, - consecutive_failures: 0, - pin_auth_blocked: false, - }; + write_pin_state_to(fs, &StoredPinState::default()) +} + +fn write_pin_state_to( + fs: &'static dyn DynFilesystem, + pin_state: &StoredPinState, +) -> io::Result<()> { let mut encoded = Vec::new(); - into_writer(&pin_state, &mut encoded) + into_writer(pin_state, &mut encoded) .map_err(|_| io::Error::new(io::ErrorKind::Other, "failed to encode pin state"))?; fs.write(&path!("pin-state.cbor"), &encoded) .map_err(map_fs_error) } +fn read_pin_state_from(fs: &'static dyn DynFilesystem) -> io::Result { + if !fs.exists(&path!("pin-state.cbor")) { + return Ok(StoredPinState::default()); + } + let mut buf: Vec = Vec::new(); + fs.open_file_and_then_unit(&path!("pin-state.cbor"), &mut |file| { + let mut chunk = [0u8; 256]; + loop { + let n = file.read(&mut chunk)?; + if n == 0 { + break; + } + buf.extend_from_slice(&chunk[..n]); + } + Ok(()) + }) + .map_err(map_fs_error)?; + ciborium::de::from_reader(buf.as_slice()) + .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, format!("pin state: {err}"))) +} + fn ensure_metadata( fs: &'static dyn DynFilesystem, identity: &IdentityConfig<'_>, diff --git a/trussed-mldsa/Cargo.toml b/trussed-mldsa/Cargo.toml index 028775b..5f069c3 100644 --- a/trussed-mldsa/Cargo.toml +++ b/trussed-mldsa/Cargo.toml @@ -3,11 +3,12 @@ name = "trussed-mldsa" version = "0.1.0" edition = "2021" -description = "Safe Rust wrapper around liboqs ML-DSA signatures" -authors = ["Your Name "] +description = "Safe Rust wrapper around pure-Rust ML-DSA (FIPS 204) signatures" +authors = ["Feitian Technologies "] license = "Apache-2.0 OR MIT" [dependencies] +fips204 = "0.4" zeroize = { version = "1", features = ["zeroize_derive"] } [features] @@ -15,4 +16,4 @@ zeroize = { version = "1", features = ["zeroize_derive"] } default = ["mldsa44", "mldsa65", "mldsa87"] mldsa44 = [] mldsa65 = [] -mldsa87 = [] \ No newline at end of file +mldsa87 = [] diff --git a/trussed-mldsa/build.rs b/trussed-mldsa/build.rs deleted file mode 100644 index 0ca48e4..0000000 --- a/trussed-mldsa/build.rs +++ /dev/null @@ -1,131 +0,0 @@ -use std::env; -use std::fs; -use std::path::{Path, PathBuf}; -use std::process::Command; - -fn workspace_root() -> PathBuf { - PathBuf::from(env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR")).join("..") -} - -fn target_subdir() -> String { - let arch = env::var("CARGO_CFG_TARGET_ARCH").expect("CARGO_CFG_TARGET_ARCH"); - let os = env::var("CARGO_CFG_TARGET_OS").expect("CARGO_CFG_TARGET_OS"); - match (os.as_str(), arch.as_str()) { - ("linux", "aarch64") => "linux-aarch64".to_string(), - ("linux", "x86_64") => "linux-x86_64".to_string(), - _ => panic!("unsupported prebuilt liboqs target {os}-{arch}"), - } -} - -fn lib_directory(root: &Path) -> PathBuf { - root.join("prebuilt_liboqs") - .join(target_subdir()) - .join("lib") -} - -fn include_directory(root: &Path) -> PathBuf { - root.join("prebuilt_liboqs") - .join(target_subdir()) - .join("include") -} - -fn ensure_symbol(lib: &Path, symbol: &str) { - let mut cmd = Command::new("nm"); - let is_shared = lib - .file_name() - .and_then(|name| name.to_str()) - .map(|name| name.contains(".so")) - .unwrap_or(false); - if is_shared { - cmd.arg("-D"); - } - let output = cmd - .arg(lib) - .output() - .unwrap_or_else(|e| panic!("failed to invoke nm on {}: {e}", lib.display())); - if !output.status.success() { - panic!("nm reported an error while inspecting {}", lib.display()); - } - let stdout = String::from_utf8_lossy(&output.stdout); - if !stdout.contains(symbol) { - panic!("symbol {symbol} not found in {}", lib.display()); - } -} - -enum LibraryKind { - Static, - Dynamic, -} - -const SHARED_CANDIDATES: &[&str] = &[ - "liboqs.so", - "liboqs.so.0.15.0-rc1", - "liboqs.so.9", - "liboqs.so.0.14.1-dev", - "liboqs.so.8", -]; - -fn select_library(lib_dir: &Path) -> (PathBuf, LibraryKind) { - let static_lib = lib_dir.join("liboqs.a"); - if static_lib.exists() { - return (static_lib, LibraryKind::Static); - } - for candidate in SHARED_CANDIDATES.iter().map(|name| lib_dir.join(name)) { - if let Ok(meta) = candidate.metadata() { - if meta.len() > 1024 { - return (candidate, LibraryKind::Dynamic); - } - } - } - panic!( - "neither liboqs.a nor a usable liboqs.so variant found under {}", - lib_dir.display() - ); -} - -fn main() { - let root = workspace_root(); - let lib_dir = lib_directory(&root); - if !lib_dir.exists() { - panic!("liboqs lib directory missing: {}", lib_dir.display()); - } - - let (link_target, kind) = select_library(&lib_dir); - match kind { - LibraryKind::Static => { - println!("cargo:rustc-link-search=native={}", lib_dir.display()); - println!("cargo:rustc-link-lib=static=oqs"); - } - LibraryKind::Dynamic => { - let out_dir = PathBuf::from(env::var("OUT_DIR").expect("OUT_DIR")); - for name in SHARED_CANDIDATES { - let source = lib_dir.join(name); - if let Ok(meta) = source.metadata() { - if meta.len() > 0 { - let target_path = out_dir.join(name); - fs::copy(&source, &target_path) - .unwrap_or_else(|e| panic!("failed to stage {name}: {e}")); - } - } - } - println!("cargo:rustc-link-search=native={}", out_dir.display()); - println!("cargo:rustc-link-search=native={}", lib_dir.display()); - println!("cargo:rustc-link-lib=dylib=oqs"); - println!("cargo:rustc-link-arg=-Wl,-rpath,{}", out_dir.display()); - println!("cargo:rustc-link-arg=-Wl,-rpath,{}", lib_dir.display()); - } - } - - ensure_symbol(&link_target, "OQS_SIG_ml_dsa_44_sign"); - ensure_symbol(&link_target, "OQS_SIG_ml_dsa_65_sign"); - ensure_symbol(&link_target, "OQS_SIG_ml_dsa_87_sign"); - - let include_dir = include_directory(&root); - let config = include_dir.join("oqs/oqsconfig.h"); - println!("cargo:rerun-if-changed={}", config.display()); - let contents = fs::read_to_string(&config) - .unwrap_or_else(|e| panic!("failed to read {}: {e}", config.display())); - if let Some(line) = contents.lines().find(|l| l.contains("OQS_VERSION_TEXT")) { - println!("cargo:warning=detected liboqs version {line}"); - } -} diff --git a/trussed-mldsa/src/lib.rs b/trussed-mldsa/src/lib.rs index 1d7f4df..b97b2e5 100644 --- a/trussed-mldsa/src/lib.rs +++ b/trussed-mldsa/src/lib.rs @@ -1,70 +1,15 @@ -//! Safe Rust wrapper around the liboqs ML-DSA signature implementations. +//! Safe Rust wrapper around pure-Rust ML-DSA implementations from `fips204`. //! -//! The wrapper exposes the ML-DSA-44/65/87 variants with minimal -//! overhead while ensuring that secret keys are wiped from memory on -//! drop. The FFI bindings panic when liboqs reports an error, which is -//! desirable for development builds where failing to produce a -//! signature should abort the test suite immediately. +//! This crate exposes a small, stable surface (`keypair`, `sign`, `verify`) +//! for the three ML-DSA parameter sets defined in FIPS 204 (ML-DSA-44/65/87). +//! The implementation is provided by the `fips204` crate, which has no C +//! dependencies, contains no `unsafe` code, and operates in constant-time. +//! +//! Secret keys are zeroized on drop. +use fips204::traits::{SerDes, Signer, Verifier}; use zeroize::Zeroize; -#[cfg(feature = "mldsa44")] -extern "C" { - fn OQS_SIG_ml_dsa_44_keypair(public_key: *mut u8, secret_key: *mut u8) -> i32; - fn OQS_SIG_ml_dsa_44_sign( - signature: *mut u8, - signature_len: *mut usize, - message: *const u8, - message_len: usize, - secret_key: *const u8, - ) -> i32; - fn OQS_SIG_ml_dsa_44_verify( - message: *const u8, - message_len: usize, - signature: *const u8, - signature_len: usize, - public_key: *const u8, - ) -> i32; -} - -#[cfg(feature = "mldsa65")] -extern "C" { - fn OQS_SIG_ml_dsa_65_keypair(public_key: *mut u8, secret_key: *mut u8) -> i32; - fn OQS_SIG_ml_dsa_65_sign( - signature: *mut u8, - signature_len: *mut usize, - message: *const u8, - message_len: usize, - secret_key: *const u8, - ) -> i32; - fn OQS_SIG_ml_dsa_65_verify( - message: *const u8, - message_len: usize, - signature: *const u8, - signature_len: usize, - public_key: *const u8, - ) -> i32; -} - -#[cfg(feature = "mldsa87")] -extern "C" { - fn OQS_SIG_ml_dsa_87_keypair(public_key: *mut u8, secret_key: *mut u8) -> i32; - fn OQS_SIG_ml_dsa_87_sign( - signature: *mut u8, - signature_len: *mut usize, - message: *const u8, - message_len: usize, - secret_key: *const u8, - ) -> i32; - fn OQS_SIG_ml_dsa_87_verify( - message: *const u8, - message_len: usize, - signature: *const u8, - signature_len: usize, - public_key: *const u8, - ) -> i32; -} - /// ML-DSA parameter sets supported by this wrapper. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum ParamSet { @@ -73,11 +18,12 @@ pub enum ParamSet { MLDSA87, } -/// Public key wrapper. +/// Public key wrapper. The inner bytes are the canonical FIPS 204 encoding. #[derive(Debug, Clone)] pub struct PublicKey(pub Vec); -/// Secret key wrapper. The key material is zeroised on drop. +/// Secret key wrapper. The inner bytes are the canonical FIPS 204 encoding; +/// they are zeroized on drop. #[derive(Debug)] pub struct SecretKey(pub Vec); @@ -87,174 +33,230 @@ impl Drop for SecretKey { } } -/// Return the buffer lengths required by the parameter set. -fn lengths(ps: ParamSet) -> (usize, usize, usize) { +/// Returned by FIPS 204 calls that fail at runtime (invalid lengths, +/// keygen failure, signing failure). +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum MlDsaError { + InvalidParameterSet, + InvalidKeyLength, + InvalidSignatureLength, + KeyGenFailed, + SigningFailed, +} + +/// Return the (public-key, secret-key, signature) byte lengths for a +/// parameter set. Useful for storage / buffer sizing. +pub fn lengths(ps: ParamSet) -> (usize, usize, usize) { match ps { - ParamSet::MLDSA44 => (1312, 2560, 2420), - ParamSet::MLDSA65 => (1952, 4032, 3309), - ParamSet::MLDSA87 => (2592, 4896, 4627), + #[cfg(feature = "mldsa44")] + ParamSet::MLDSA44 => ( + fips204::ml_dsa_44::PK_LEN, + fips204::ml_dsa_44::SK_LEN, + fips204::ml_dsa_44::SIG_LEN, + ), + #[cfg(feature = "mldsa65")] + ParamSet::MLDSA65 => ( + fips204::ml_dsa_65::PK_LEN, + fips204::ml_dsa_65::SK_LEN, + fips204::ml_dsa_65::SIG_LEN, + ), + #[cfg(feature = "mldsa87")] + ParamSet::MLDSA87 => ( + fips204::ml_dsa_87::PK_LEN, + fips204::ml_dsa_87::SK_LEN, + fips204::ml_dsa_87::SIG_LEN, + ), + #[cfg(not(feature = "mldsa44"))] + ParamSet::MLDSA44 => panic!("feature mldsa44 is not enabled"), + #[cfg(not(feature = "mldsa65"))] + ParamSet::MLDSA65 => panic!("feature mldsa65 is not enabled"), + #[cfg(not(feature = "mldsa87"))] + ParamSet::MLDSA87 => panic!("feature mldsa87 is not enabled"), } } /// Generate an ML-DSA keypair. +/// +/// Panics if the parameter-set feature is not enabled. Returns an error if +/// the underlying FIPS 204 keygen call fails (extremely rare; surfaces RNG +/// problems). +pub fn try_keypair(ps: ParamSet) -> Result<(PublicKey, SecretKey), MlDsaError> { + match ps { + #[cfg(feature = "mldsa44")] + ParamSet::MLDSA44 => { + let (pk, sk) = + fips204::ml_dsa_44::try_keygen().map_err(|_| MlDsaError::KeyGenFailed)?; + Ok(( + PublicKey(pk.into_bytes().to_vec()), + SecretKey(sk.into_bytes().to_vec()), + )) + } + #[cfg(feature = "mldsa65")] + ParamSet::MLDSA65 => { + let (pk, sk) = + fips204::ml_dsa_65::try_keygen().map_err(|_| MlDsaError::KeyGenFailed)?; + Ok(( + PublicKey(pk.into_bytes().to_vec()), + SecretKey(sk.into_bytes().to_vec()), + )) + } + #[cfg(feature = "mldsa87")] + ParamSet::MLDSA87 => { + let (pk, sk) = + fips204::ml_dsa_87::try_keygen().map_err(|_| MlDsaError::KeyGenFailed)?; + Ok(( + PublicKey(pk.into_bytes().to_vec()), + SecretKey(sk.into_bytes().to_vec()), + )) + } + #[cfg(not(feature = "mldsa44"))] + ParamSet::MLDSA44 => Err(MlDsaError::InvalidParameterSet), + #[cfg(not(feature = "mldsa65"))] + ParamSet::MLDSA65 => Err(MlDsaError::InvalidParameterSet), + #[cfg(not(feature = "mldsa87"))] + ParamSet::MLDSA87 => Err(MlDsaError::InvalidParameterSet), + } +} + +/// Generate an ML-DSA keypair, panicking on failure. Kept for API +/// compatibility with the previous liboqs-based wrapper. pub fn keypair(ps: ParamSet) -> (PublicKey, SecretKey) { - let (pk_len, sk_len, _sig_len) = lengths(ps); - let mut pk = vec![0u8; pk_len]; - let mut sk = vec![0u8; sk_len]; - unsafe { - let rc = match ps { - ParamSet::MLDSA44 => { - #[cfg(feature = "mldsa44")] - { - OQS_SIG_ml_dsa_44_keypair(pk.as_mut_ptr(), sk.as_mut_ptr()) - } - #[cfg(not(feature = "mldsa44"))] - { - panic!("feature mldsa44 is not enabled"); - } - } - ParamSet::MLDSA65 => { - #[cfg(feature = "mldsa65")] - { - OQS_SIG_ml_dsa_65_keypair(pk.as_mut_ptr(), sk.as_mut_ptr()) - } - #[cfg(not(feature = "mldsa65"))] - { - panic!("feature mldsa65 is not enabled"); - } - } - ParamSet::MLDSA87 => { - #[cfg(feature = "mldsa87")] - { - OQS_SIG_ml_dsa_87_keypair(pk.as_mut_ptr(), sk.as_mut_ptr()) - } - #[cfg(not(feature = "mldsa87"))] - { - panic!("feature mldsa87 is not enabled"); - } - } - }; - assert_eq!(rc, 0, "liboqs keypair call failed"); + try_keypair(ps).expect("ML-DSA keypair generation failed") +} + +/// Try to sign `message` with the supplied secret key. Returns the raw +/// FIPS 204 signature bytes. The context value is always empty per the +/// CTAP2 / WebAuthn profile that uses this wrapper. +pub fn try_sign(ps: ParamSet, sk: &SecretKey, message: &[u8]) -> Result, MlDsaError> { + let (_pk_len, sk_len, _sig_len) = lengths(ps); + if sk.0.len() != sk_len { + return Err(MlDsaError::InvalidKeyLength); + } + match ps { + #[cfg(feature = "mldsa44")] + ParamSet::MLDSA44 => { + let bytes: [u8; fips204::ml_dsa_44::SK_LEN] = + sk.0.as_slice() + .try_into() + .map_err(|_| MlDsaError::InvalidKeyLength)?; + let sk = fips204::ml_dsa_44::PrivateKey::try_from_bytes(bytes) + .map_err(|_| MlDsaError::InvalidKeyLength)?; + let sig = sk + .try_sign(message, &[]) + .map_err(|_| MlDsaError::SigningFailed)?; + Ok(sig.to_vec()) + } + #[cfg(feature = "mldsa65")] + ParamSet::MLDSA65 => { + let bytes: [u8; fips204::ml_dsa_65::SK_LEN] = + sk.0.as_slice() + .try_into() + .map_err(|_| MlDsaError::InvalidKeyLength)?; + let sk = fips204::ml_dsa_65::PrivateKey::try_from_bytes(bytes) + .map_err(|_| MlDsaError::InvalidKeyLength)?; + let sig = sk + .try_sign(message, &[]) + .map_err(|_| MlDsaError::SigningFailed)?; + Ok(sig.to_vec()) + } + #[cfg(feature = "mldsa87")] + ParamSet::MLDSA87 => { + let bytes: [u8; fips204::ml_dsa_87::SK_LEN] = + sk.0.as_slice() + .try_into() + .map_err(|_| MlDsaError::InvalidKeyLength)?; + let sk = fips204::ml_dsa_87::PrivateKey::try_from_bytes(bytes) + .map_err(|_| MlDsaError::InvalidKeyLength)?; + let sig = sk + .try_sign(message, &[]) + .map_err(|_| MlDsaError::SigningFailed)?; + Ok(sig.to_vec()) + } + #[cfg(not(feature = "mldsa44"))] + ParamSet::MLDSA44 => Err(MlDsaError::InvalidParameterSet), + #[cfg(not(feature = "mldsa65"))] + ParamSet::MLDSA65 => Err(MlDsaError::InvalidParameterSet), + #[cfg(not(feature = "mldsa87"))] + ParamSet::MLDSA87 => Err(MlDsaError::InvalidParameterSet), } - (PublicKey(pk), SecretKey(sk)) } -/// Sign a message with the supplied secret key. +/// Sign a message. Kept for API compatibility with the previous +/// liboqs-based wrapper; returns an empty `Vec` (and logs a warning via +/// `eprintln!`-equivalent) on key-length / signing errors rather than +/// aborting the process, since the daemon must not crash on a malformed +/// stored credential. pub fn sign(ps: ParamSet, sk: &SecretKey, message: &[u8]) -> Vec { - let (_pk_len, _sk_len, sig_len) = lengths(ps); - let mut sig = vec![0u8; sig_len]; - let mut actual_len: usize = sig_len; - unsafe { - let rc = match ps { - ParamSet::MLDSA44 => { - #[cfg(feature = "mldsa44")] - { - OQS_SIG_ml_dsa_44_sign( - sig.as_mut_ptr(), - &mut actual_len, - message.as_ptr(), - message.len(), - sk.0.as_ptr(), - ) - } - #[cfg(not(feature = "mldsa44"))] - { - panic!("feature mldsa44 is not enabled"); - } - } - ParamSet::MLDSA65 => { - #[cfg(feature = "mldsa65")] - { - OQS_SIG_ml_dsa_65_sign( - sig.as_mut_ptr(), - &mut actual_len, - message.as_ptr(), - message.len(), - sk.0.as_ptr(), - ) - } - #[cfg(not(feature = "mldsa65"))] - { - panic!("feature mldsa65 is not enabled"); - } - } - ParamSet::MLDSA87 => { - #[cfg(feature = "mldsa87")] - { - OQS_SIG_ml_dsa_87_sign( - sig.as_mut_ptr(), - &mut actual_len, - message.as_ptr(), - message.len(), - sk.0.as_ptr(), - ) - } - #[cfg(not(feature = "mldsa87"))] - { - panic!("feature mldsa87 is not enabled"); - } - } - }; - assert_eq!(rc, 0, "liboqs sign call failed"); + match try_sign(ps, sk, message) { + Ok(sig) => sig, + Err(err) => { + #[cfg(feature = "log")] + log::warn!("ML-DSA signing failed: {err:?}"); + let _ = err; + Vec::new() + } } - sig.truncate(actual_len); - sig } -/// Verify a signature over the message using the provided public key. +/// Verify a signature. Returns `false` on length mismatch or invalid +/// signature. pub fn verify(ps: ParamSet, pk: &PublicKey, message: &[u8], signature: &[u8]) -> bool { - unsafe { - let rc = match ps { - ParamSet::MLDSA44 => { - #[cfg(feature = "mldsa44")] - { - OQS_SIG_ml_dsa_44_verify( - message.as_ptr(), - message.len(), - signature.as_ptr(), - signature.len(), - pk.0.as_ptr(), - ) - } - #[cfg(not(feature = "mldsa44"))] - { - panic!("feature mldsa44 is not enabled"); - } + let (pk_len, _sk_len, sig_len) = lengths(ps); + if pk.0.len() != pk_len || signature.len() != sig_len { + return false; + } + match ps { + #[cfg(feature = "mldsa44")] + ParamSet::MLDSA44 => { + let pk_bytes: [u8; fips204::ml_dsa_44::PK_LEN] = match pk.0.as_slice().try_into() { + Ok(bytes) => bytes, + Err(_) => return false, + }; + let sig_bytes: [u8; fips204::ml_dsa_44::SIG_LEN] = match signature.try_into() { + Ok(bytes) => bytes, + Err(_) => return false, + }; + match fips204::ml_dsa_44::PublicKey::try_from_bytes(pk_bytes) { + Ok(pk) => pk.verify(message, &sig_bytes, &[]), + Err(_) => false, } - ParamSet::MLDSA65 => { - #[cfg(feature = "mldsa65")] - { - OQS_SIG_ml_dsa_65_verify( - message.as_ptr(), - message.len(), - signature.as_ptr(), - signature.len(), - pk.0.as_ptr(), - ) - } - #[cfg(not(feature = "mldsa65"))] - { - panic!("feature mldsa65 is not enabled"); - } + } + #[cfg(feature = "mldsa65")] + ParamSet::MLDSA65 => { + let pk_bytes: [u8; fips204::ml_dsa_65::PK_LEN] = match pk.0.as_slice().try_into() { + Ok(bytes) => bytes, + Err(_) => return false, + }; + let sig_bytes: [u8; fips204::ml_dsa_65::SIG_LEN] = match signature.try_into() { + Ok(bytes) => bytes, + Err(_) => return false, + }; + match fips204::ml_dsa_65::PublicKey::try_from_bytes(pk_bytes) { + Ok(pk) => pk.verify(message, &sig_bytes, &[]), + Err(_) => false, } - ParamSet::MLDSA87 => { - #[cfg(feature = "mldsa87")] - { - OQS_SIG_ml_dsa_87_verify( - message.as_ptr(), - message.len(), - signature.as_ptr(), - signature.len(), - pk.0.as_ptr(), - ) - } - #[cfg(not(feature = "mldsa87"))] - { - panic!("feature mldsa87 is not enabled"); - } + } + #[cfg(feature = "mldsa87")] + ParamSet::MLDSA87 => { + let pk_bytes: [u8; fips204::ml_dsa_87::PK_LEN] = match pk.0.as_slice().try_into() { + Ok(bytes) => bytes, + Err(_) => return false, + }; + let sig_bytes: [u8; fips204::ml_dsa_87::SIG_LEN] = match signature.try_into() { + Ok(bytes) => bytes, + Err(_) => return false, + }; + match fips204::ml_dsa_87::PublicKey::try_from_bytes(pk_bytes) { + Ok(pk) => pk.verify(message, &sig_bytes, &[]), + Err(_) => false, } - }; - rc == 0 + } + #[cfg(not(feature = "mldsa44"))] + ParamSet::MLDSA44 => false, + #[cfg(not(feature = "mldsa65"))] + ParamSet::MLDSA65 => false, + #[cfg(not(feature = "mldsa87"))] + ParamSet::MLDSA87 => false, } } @@ -264,6 +266,10 @@ mod tests { fn roundtrip(ps: ParamSet) { let (pk, sk) = keypair(ps); + let (pk_len, sk_len, _sig_len) = lengths(ps); + assert_eq!(pk.0.len(), pk_len, "public key length"); + assert_eq!(sk.0.len(), sk_len, "secret key length"); + let message = b"post-quantum authentication"; let signature = sign(ps, &sk, message); assert!( @@ -271,6 +277,22 @@ mod tests { "verification failed for {:?}", ps ); + + let mut tampered = signature.clone(); + tampered[0] ^= 0x01; + assert!( + !verify(ps, &pk, message, &tampered), + "tampered signature must not verify ({:?})", + ps + ); + + let mut other_message = message.to_vec(); + other_message.push(0xFF); + assert!( + !verify(ps, &pk, &other_message, &signature), + "signature must not verify for different message ({:?})", + ps + ); } #[test] @@ -287,4 +309,18 @@ mod tests { fn mldsa87_roundtrip() { roundtrip(ParamSet::MLDSA87); } + + #[test] + fn rejects_wrong_length_signature() { + let (pk, _sk) = keypair(ParamSet::MLDSA44); + assert!(!verify(ParamSet::MLDSA44, &pk, b"hello", &[0u8; 16])); + } + + #[test] + fn rejects_wrong_length_pubkey() { + let (_pk, sk) = keypair(ParamSet::MLDSA44); + let sig = sign(ParamSet::MLDSA44, &sk, b"hello"); + let pk = PublicKey(vec![0u8; 32]); + assert!(!verify(ParamSet::MLDSA44, &pk, b"hello", &sig)); + } } diff --git a/trussed-mlkem/Cargo.toml b/trussed-mlkem/Cargo.toml deleted file mode 100644 index 4a3b254..0000000 --- a/trussed-mlkem/Cargo.toml +++ /dev/null @@ -1,17 +0,0 @@ -[package] -name = "trussed-mlkem" -version = "0.1.0" -edition = "2021" - -description = "Safe Rust wrapper around the liboqs ML-KEM key encapsulation mechanisms" -authors = ["Your Name "] -license = "Apache-2.0 OR MIT" - -[dependencies] -zeroize = { version = "1", features = ["zeroize_derive"] } - -[features] -default = ["mlkem512", "mlkem768", "mlkem1024"] -mlkem512 = [] -mlkem768 = [] -mlkem1024 = [] diff --git a/trussed-mlkem/build.rs b/trussed-mlkem/build.rs deleted file mode 100644 index aaf7b7b..0000000 --- a/trussed-mlkem/build.rs +++ /dev/null @@ -1,130 +0,0 @@ -use std::env; -use std::fs; -use std::path::{Path, PathBuf}; -use std::process::Command; - -fn workspace_root() -> PathBuf { - PathBuf::from(env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR")).join("..") -} - -fn target_subdir() -> String { - let arch = env::var("CARGO_CFG_TARGET_ARCH").expect("CARGO_CFG_TARGET_ARCH"); - let os = env::var("CARGO_CFG_TARGET_OS").expect("CARGO_CFG_TARGET_OS"); - match (os.as_str(), arch.as_str()) { - ("linux", "aarch64") => "linux-aarch64".to_string(), - ("linux", "x86_64") => "linux-x86_64".to_string(), - _ => panic!("unsupported prebuilt liboqs target {os}-{arch}"), - } -} - -fn lib_directory(root: &Path) -> PathBuf { - root.join("prebuilt_liboqs") - .join(target_subdir()) - .join("lib") -} - -fn include_directory(root: &Path) -> PathBuf { - root.join("prebuilt_liboqs") - .join(target_subdir()) - .join("include") -} - -fn ensure_symbol(lib: &Path, symbol: &str) { - let mut cmd = Command::new("nm"); - let is_shared = lib - .file_name() - .and_then(|name| name.to_str()) - .map(|name| name.contains(".so")) - .unwrap_or(false); - if is_shared { - cmd.arg("-D"); - } - let output = cmd - .arg(lib) - .output() - .unwrap_or_else(|e| panic!("failed to invoke nm on {}: {e}", lib.display())); - if !output.status.success() { - panic!("nm reported an error while inspecting {}", lib.display()); - } - let stdout = String::from_utf8_lossy(&output.stdout); - if !stdout.contains(symbol) { - panic!("symbol {symbol} not found in {}", lib.display()); - } -} - -enum LibraryKind { - Static, - Dynamic, -} - -const SHARED_CANDIDATES: &[&str] = &[ - "liboqs.so", - "liboqs.so.0.15.0-rc1", - "liboqs.so.9", - "liboqs.so.0.14.1-dev", - "liboqs.so.8", -]; - -fn select_library(lib_dir: &Path) -> (PathBuf, LibraryKind) { - let static_lib = lib_dir.join("liboqs.a"); - if static_lib.exists() { - return (static_lib, LibraryKind::Static); - } - for candidate in SHARED_CANDIDATES.iter().map(|name| lib_dir.join(name)) { - if let Ok(meta) = candidate.metadata() { - if meta.len() > 1024 { - return (candidate, LibraryKind::Dynamic); - } - } - } - panic!( - "neither liboqs.a nor a usable liboqs.so variant found under {}", - lib_dir.display() - ); -} - -fn main() { - let root = workspace_root(); - let lib_dir = lib_directory(&root); - if !lib_dir.exists() { - panic!("liboqs lib directory missing: {}", lib_dir.display()); - } - let (link_target, kind) = select_library(&lib_dir); - match kind { - LibraryKind::Static => { - println!("cargo:rustc-link-search=native={}", lib_dir.display()); - println!("cargo:rustc-link-lib=static=oqs"); - } - LibraryKind::Dynamic => { - let out_dir = PathBuf::from(env::var("OUT_DIR").expect("OUT_DIR")); - for name in SHARED_CANDIDATES { - let source = lib_dir.join(name); - if let Ok(meta) = source.metadata() { - if meta.len() > 0 { - let target_path = out_dir.join(name); - fs::copy(&source, &target_path) - .unwrap_or_else(|e| panic!("failed to stage {name}: {e}")); - } - } - } - println!("cargo:rustc-link-search=native={}", out_dir.display()); - println!("cargo:rustc-link-search=native={}", lib_dir.display()); - println!("cargo:rustc-link-lib=dylib=oqs"); - println!("cargo:rustc-link-arg=-Wl,-rpath,{}", out_dir.display()); - println!("cargo:rustc-link-arg=-Wl,-rpath,{}", lib_dir.display()); - } - } - - ensure_symbol(&link_target, "OQS_KEM_ml_kem_512_decaps"); - ensure_symbol(&link_target, "OQS_KEM_ml_kem_768_decaps"); - ensure_symbol(&link_target, "OQS_KEM_ml_kem_1024_decaps"); - - let include_dir = include_directory(&root); - let config = include_dir.join("oqs/oqsconfig.h"); - println!("cargo:rerun-if-changed={}", config.display()); - let contents = fs::read_to_string(&config) - .unwrap_or_else(|e| panic!("failed to read {}: {e}", config.display())); - if let Some(line) = contents.lines().find(|l| l.contains("OQS_VERSION_TEXT")) { - println!("cargo:warning=detected liboqs version {line}"); - } -} diff --git a/trussed-mlkem/src/lib.rs b/trussed-mlkem/src/lib.rs deleted file mode 100644 index fd7f549..0000000 --- a/trussed-mlkem/src/lib.rs +++ /dev/null @@ -1,283 +0,0 @@ -//! Safe wrapper around the liboqs ML-KEM implementations. -//! -//! The functions provided here expose the ML-KEM-512/768/1024 key -//! encapsulation mechanisms through a safe Rust API. All secret -//! material is zeroised on drop and the wrappers panic if the -//! underlying FFI call fails, ensuring that test failures surface -//! immediately during development builds. - -use zeroize::Zeroize; - -#[cfg(feature = "mlkem512")] -extern "C" { - fn OQS_KEM_ml_kem_512_keypair(public_key: *mut u8, secret_key: *mut u8) -> i32; - fn OQS_KEM_ml_kem_512_encaps( - ciphertext: *mut u8, - shared_secret: *mut u8, - public_key: *const u8, - ) -> i32; - fn OQS_KEM_ml_kem_512_decaps( - shared_secret: *mut u8, - ciphertext: *const u8, - secret_key: *const u8, - ) -> i32; -} - -#[cfg(feature = "mlkem768")] -extern "C" { - fn OQS_KEM_ml_kem_768_keypair(public_key: *mut u8, secret_key: *mut u8) -> i32; - fn OQS_KEM_ml_kem_768_encaps( - ciphertext: *mut u8, - shared_secret: *mut u8, - public_key: *const u8, - ) -> i32; - fn OQS_KEM_ml_kem_768_decaps( - shared_secret: *mut u8, - ciphertext: *const u8, - secret_key: *const u8, - ) -> i32; -} - -#[cfg(feature = "mlkem1024")] -extern "C" { - fn OQS_KEM_ml_kem_1024_keypair(public_key: *mut u8, secret_key: *mut u8) -> i32; - fn OQS_KEM_ml_kem_1024_encaps( - ciphertext: *mut u8, - shared_secret: *mut u8, - public_key: *const u8, - ) -> i32; - fn OQS_KEM_ml_kem_1024_decaps( - shared_secret: *mut u8, - ciphertext: *const u8, - secret_key: *const u8, - ) -> i32; -} - -/// Available ML-KEM parameter sets. -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub enum ParamSet { - MLKEM512, - MLKEM768, - MLKEM1024, -} - -/// Public key wrapper. -#[derive(Debug, Clone)] -pub struct PublicKey(pub Vec); - -/// Secret key wrapper. The key material is securely wiped on drop. -#[derive(Debug)] -pub struct SecretKey(pub Vec); - -impl Drop for SecretKey { - fn drop(&mut self) { - self.0.zeroize(); - } -} - -/// Ciphertext wrapper produced by encapsulation. -#[derive(Debug, Clone)] -pub struct Ciphertext(pub Vec); - -/// Shared secret wrapper. The bytes are cleared on drop. -#[derive(Debug, Clone)] -pub struct SharedSecret(pub Vec); - -impl Drop for SharedSecret { - fn drop(&mut self) { - self.0.zeroize(); - } -} - -/// Return the lengths of the key and ciphertext buffers for a parameter set. -fn lengths(ps: ParamSet) -> (usize, usize, usize, usize) { - match ps { - ParamSet::MLKEM512 => (800, 1632, 768, 32), - ParamSet::MLKEM768 => (1184, 2400, 1088, 32), - ParamSet::MLKEM1024 => (1568, 3168, 1568, 32), - } -} - -/// Generate an ML-KEM keypair. -pub fn keypair(ps: ParamSet) -> (PublicKey, SecretKey) { - let (pk_len, sk_len, _ct_len, _ss_len) = lengths(ps); - let mut pk = vec![0u8; pk_len]; - let mut sk = vec![0u8; sk_len]; - unsafe { - let rc = match ps { - ParamSet::MLKEM512 => { - #[cfg(feature = "mlkem512")] - { - OQS_KEM_ml_kem_512_keypair(pk.as_mut_ptr(), sk.as_mut_ptr()) - } - #[cfg(not(feature = "mlkem512"))] - { - panic!("feature mlkem512 is not enabled"); - } - } - ParamSet::MLKEM768 => { - #[cfg(feature = "mlkem768")] - { - OQS_KEM_ml_kem_768_keypair(pk.as_mut_ptr(), sk.as_mut_ptr()) - } - #[cfg(not(feature = "mlkem768"))] - { - panic!("feature mlkem768 is not enabled"); - } - } - ParamSet::MLKEM1024 => { - #[cfg(feature = "mlkem1024")] - { - OQS_KEM_ml_kem_1024_keypair(pk.as_mut_ptr(), sk.as_mut_ptr()) - } - #[cfg(not(feature = "mlkem1024"))] - { - panic!("feature mlkem1024 is not enabled"); - } - } - }; - assert_eq!(rc, 0, "liboqs keypair call failed"); - } - (PublicKey(pk), SecretKey(sk)) -} - -/// Encapsulate a shared secret to the recipient's public key. -pub fn encapsulate(ps: ParamSet, pk: &PublicKey) -> (Ciphertext, SharedSecret) { - let (_pk_len, _sk_len, ct_len, ss_len) = lengths(ps); - let mut ct = vec![0u8; ct_len]; - let mut ss = vec![0u8; ss_len]; - unsafe { - let rc = match ps { - ParamSet::MLKEM512 => { - #[cfg(feature = "mlkem512")] - { - OQS_KEM_ml_kem_512_encaps(ct.as_mut_ptr(), ss.as_mut_ptr(), pk.0.as_ptr()) - } - #[cfg(not(feature = "mlkem512"))] - { - panic!("feature mlkem512 is not enabled"); - } - } - ParamSet::MLKEM768 => { - #[cfg(feature = "mlkem768")] - { - OQS_KEM_ml_kem_768_encaps(ct.as_mut_ptr(), ss.as_mut_ptr(), pk.0.as_ptr()) - } - #[cfg(not(feature = "mlkem768"))] - { - panic!("feature mlkem768 is not enabled"); - } - } - ParamSet::MLKEM1024 => { - #[cfg(feature = "mlkem1024")] - { - OQS_KEM_ml_kem_1024_encaps(ct.as_mut_ptr(), ss.as_mut_ptr(), pk.0.as_ptr()) - } - #[cfg(not(feature = "mlkem1024"))] - { - panic!("feature mlkem1024 is not enabled"); - } - } - }; - assert_eq!(rc, 0, "liboqs encaps call failed"); - } - (Ciphertext(ct), SharedSecret(ss)) -} - -/// Errors that can occur during decapsulation. -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub enum DecapsulationError { - /// The ciphertext length does not match the parameter set requirements. - InvalidCiphertextLength, -} - -/// Decapsulate the shared secret from a ciphertext using the secret key. -pub fn decapsulate( - ps: ParamSet, - sk: &SecretKey, - ct: &Ciphertext, -) -> Result { - let (_pk_len, _sk_len, ct_len, ss_len) = lengths(ps); - if ct.0.len() != ct_len { - return Err(DecapsulationError::InvalidCiphertextLength); - } - let mut ss = vec![0u8; ss_len]; - unsafe { - let rc = match ps { - ParamSet::MLKEM512 => { - #[cfg(feature = "mlkem512")] - { - OQS_KEM_ml_kem_512_decaps(ss.as_mut_ptr(), ct.0.as_ptr(), sk.0.as_ptr()) - } - #[cfg(not(feature = "mlkem512"))] - { - panic!("feature mlkem512 is not enabled"); - } - } - ParamSet::MLKEM768 => { - #[cfg(feature = "mlkem768")] - { - OQS_KEM_ml_kem_768_decaps(ss.as_mut_ptr(), ct.0.as_ptr(), sk.0.as_ptr()) - } - #[cfg(not(feature = "mlkem768"))] - { - panic!("feature mlkem768 is not enabled"); - } - } - ParamSet::MLKEM1024 => { - #[cfg(feature = "mlkem1024")] - { - OQS_KEM_ml_kem_1024_decaps(ss.as_mut_ptr(), ct.0.as_ptr(), sk.0.as_ptr()) - } - #[cfg(not(feature = "mlkem1024"))] - { - panic!("feature mlkem1024 is not enabled"); - } - } - }; - assert_eq!(rc, 0, "liboqs decaps call failed"); - } - Ok(SharedSecret(ss)) -} - -#[cfg(test)] -mod tests { - use super::*; - - fn roundtrip(ps: ParamSet) { - let (pk, sk) = keypair(ps); - let (ct, ss_enc) = encapsulate(ps, &pk); - let ss_dec = decapsulate(ps, &sk, &ct).expect("ciphertext should be valid"); - assert_eq!(ss_enc.0, ss_dec.0, "shared secret mismatch for {:?}", ps); - - // Reject ciphertexts with invalid length. - let mut truncated = ct.0.clone(); - truncated.pop(); - assert!(matches!( - decapsulate(ps, &sk, &Ciphertext(truncated)), - Err(DecapsulationError::InvalidCiphertextLength) - )); - - let mut oversized = ct.0.clone(); - oversized.push(0); - assert!(matches!( - decapsulate(ps, &sk, &Ciphertext(oversized)), - Err(DecapsulationError::InvalidCiphertextLength) - )); - } - - #[test] - fn mlkem_512_roundtrip() { - roundtrip(ParamSet::MLKEM512); - } - - #[test] - fn mlkem_768_roundtrip() { - roundtrip(ParamSet::MLKEM768); - } - - #[test] - fn mlkem_1024_roundtrip() { - roundtrip(ParamSet::MLKEM1024); - } -}