visaljs 0.0.2 → 0.0.4

package/runtime/third_party/boringssl/include/openssl/safestack.h

@@ -0,0 +1,16 @@
+// Copyright 2014 The BoringSSL Authors
+//
+// 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
+//
+//     https://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.
+
+/* This header is provided in order to make compiling against code that expects
+   OpenSSL easier. */

package/runtime/third_party/boringssl/include/openssl/service_indicator.h

@@ -0,0 +1,19 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+//
+// 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
+//
+//     https://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.
+
+// This empty header is provided in order to make compiling against older code
+// easier. Some bindings libraries depended on every header that was present in
+// an older version of library.
+//
+// TODO(davidben): Remove this header from downstream code and remove the file.

package/runtime/third_party/boringssl/include/openssl/sha.h

@@ -0,0 +1,108 @@
+// Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+//
+// 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
+//
+//     https://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.
+
+#ifndef OPENSSL_HEADER_SHA_H
+#define OPENSSL_HEADER_SHA_H
+
+#include <openssl/base.h>  // IWYU pragma: export
+
+// `sha.h` historically included SHA-1 and SHA-2 hash functions. So, for
+// backward compatibility `sha2.h` is included here. New uses of this header
+// should include sha2.h unless SHA-1 family functions are required.
+#include <openssl/sha2.h>  // IWYU pragma: export
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// The SHA family of hash functions (SHA-1 and SHA-2).
+
+
+// SHA-1.
+
+// SHA_CBLOCK is the block size of SHA-1.
+#define SHA_CBLOCK 64
+
+// SHA_DIGEST_LENGTH is the length of a SHA-1 digest.
+#define SHA_DIGEST_LENGTH 20
+
+// SHA1_Init initialises `sha` and returns one.
+OPENSSL_EXPORT int SHA1_Init(SHA_CTX *sha);
+
+// SHA1_Update adds `len` bytes from `data` to `sha` and returns one.
+OPENSSL_EXPORT int SHA1_Update(SHA_CTX *sha, const void *data, size_t len);
+
+// SHA1_Final adds the final padding to `sha` and writes the resulting digest to
+// `out`, which must have at least `SHA_DIGEST_LENGTH` bytes of space. It
+// returns one.
+OPENSSL_EXPORT int SHA1_Final(uint8_t out[SHA_DIGEST_LENGTH], SHA_CTX *sha);
+
+// SHA1 writes the digest of `len` bytes from `data` to `out` and returns
+// `out`. There must be at least `SHA_DIGEST_LENGTH` bytes of space in
+// `out`.
+OPENSSL_EXPORT uint8_t *SHA1(const uint8_t *data, size_t len,
+                             uint8_t out[SHA_DIGEST_LENGTH]);
+
+// SHA1_Transform is a low-level function that performs a single, SHA-1 block
+// transformation using the state from `sha` and `SHA_CBLOCK` bytes from
+// `block`.
+OPENSSL_EXPORT void SHA1_Transform(SHA_CTX *sha,
+                                   const uint8_t block[SHA_CBLOCK]);
+
+struct sha_state_st {
+#if defined(__cplusplus) || defined(OPENSSL_WINDOWS)
+  uint32_t h[5];
+#else
+  // wpa_supplicant accesses `h0`..`h4` so we must support those names for
+  // compatibility with it until it can be updated. Anonymous unions are only
+  // standard in C11, so disable this workaround in C++.
+  union {
+    uint32_t h[5];
+    struct {
+      uint32_t h0;
+      uint32_t h1;
+      uint32_t h2;
+      uint32_t h3;
+      uint32_t h4;
+    };
+  };
+#endif
+  uint32_t Nl, Nh;
+  uint8_t data[SHA_CBLOCK];
+  unsigned num;
+} /* SHA_CTX */;
+
+// CRYPTO_fips_186_2_prf derives `out_len` bytes from `xkey` using the PRF
+// defined in FIPS 186-2, Appendix 3.1, with change notice 1 applied. The b
+// parameter is 160 and seed, XKEY, is also 160 bits. The optional XSEED user
+// input is all zeros.
+//
+// The PRF generates a sequence of 320-bit numbers. Each number is encoded as a
+// 40-byte string in big-endian and then concatenated to form `out`. If
+// `out_len` is not a multiple of 40, the result is truncated. This matches the
+// construction used in Section 7 of RFC 4186 and Section 7 of RFC 4187.
+//
+// This PRF is based on SHA-1, a weak hash function, and should not be used
+// in new protocols. It is provided for compatibility with some legacy EAP
+// methods.
+OPENSSL_EXPORT void CRYPTO_fips_186_2_prf(
+    uint8_t *out, size_t out_len, const uint8_t xkey[SHA_DIGEST_LENGTH]);
+
+
+#if defined(__cplusplus)
+}  // extern C
+#endif
+
+#endif  // OPENSSL_HEADER_SHA_H

package/runtime/third_party/boringssl/include/openssl/sha2.h

@@ -0,0 +1,201 @@
+// Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
+//
+// 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
+//
+//     https://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.
+
+#ifndef OPENSSL_HEADER_SHA2_H
+#define OPENSSL_HEADER_SHA2_H
+
+#include <openssl/base.h>  // IWYU pragma: export
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// The SHA-2 family of hash functions.
+
+
+// SHA-224.
+
+// SHA224_CBLOCK is the block size of SHA-224.
+#define SHA224_CBLOCK 64
+
+// SHA224_DIGEST_LENGTH is the length of a SHA-224 digest.
+#define SHA224_DIGEST_LENGTH 28
+
+// SHA224_Init initialises `sha` and returns 1.
+OPENSSL_EXPORT int SHA224_Init(SHA256_CTX *sha);
+
+// SHA224_Update adds `len` bytes from `data` to `sha` and returns 1.
+OPENSSL_EXPORT int SHA224_Update(SHA256_CTX *sha, const void *data, size_t len);
+
+// SHA224_Final adds the final padding to `sha` and writes the resulting digest
+// to `out`, which must have at least `SHA224_DIGEST_LENGTH` bytes of space. It
+// returns 1.
+OPENSSL_EXPORT int SHA224_Final(uint8_t out[SHA224_DIGEST_LENGTH],
+                                SHA256_CTX *sha);
+
+// SHA224 writes the digest of `len` bytes from `data` to `out` and returns
+// `out`. There must be at least `SHA224_DIGEST_LENGTH` bytes of space in
+// `out`.
+OPENSSL_EXPORT uint8_t *SHA224(const uint8_t *data, size_t len,
+                               uint8_t out[SHA224_DIGEST_LENGTH]);
+
+
+// SHA-256.
+
+// SHA256_CBLOCK is the block size of SHA-256.
+#define SHA256_CBLOCK 64
+
+// SHA256_DIGEST_LENGTH is the length of a SHA-256 digest.
+#define SHA256_DIGEST_LENGTH 32
+
+// SHA256_Init initialises `sha` and returns 1.
+OPENSSL_EXPORT int SHA256_Init(SHA256_CTX *sha);
+
+// SHA256_Update adds `len` bytes from `data` to `sha` and returns 1.
+OPENSSL_EXPORT int SHA256_Update(SHA256_CTX *sha, const void *data, size_t len);
+
+// SHA256_Final adds the final padding to `sha` and writes the resulting digest
+// to `out`, which must have at least `SHA256_DIGEST_LENGTH` bytes of space. It
+// returns one on success and zero on programmer error.
+OPENSSL_EXPORT int SHA256_Final(uint8_t out[SHA256_DIGEST_LENGTH],
+                                SHA256_CTX *sha);
+
+// SHA256 writes the digest of `len` bytes from `data` to `out` and returns
+// `out`. There must be at least `SHA256_DIGEST_LENGTH` bytes of space in
+// `out`.
+OPENSSL_EXPORT uint8_t *SHA256(const uint8_t *data, size_t len,
+                               uint8_t out[SHA256_DIGEST_LENGTH]);
+
+// SHA256_Transform is a low-level function that performs a single, SHA-256
+// block transformation using the state from `sha` and `SHA256_CBLOCK` bytes
+// from `block`.
+OPENSSL_EXPORT void SHA256_Transform(SHA256_CTX *sha,
+                                     const uint8_t block[SHA256_CBLOCK]);
+
+// SHA256_TransformBlocks is a low-level function that takes `num_blocks` *
+// `SHA256_CBLOCK` bytes of data and performs SHA-256 transforms on it to update
+// `state`. You should not use this function unless you are implementing a
+// derivative of SHA-256.
+OPENSSL_EXPORT void SHA256_TransformBlocks(uint32_t state[8],
+                                           const uint8_t *data,
+                                           size_t num_blocks);
+
+struct sha256_state_st {
+  uint32_t h[8];
+  uint32_t Nl, Nh;
+  uint8_t data[SHA256_CBLOCK];
+  unsigned num, md_len;
+} /* SHA256_CTX */;
+
+
+// SHA-384.
+
+// SHA384_CBLOCK is the block size of SHA-384.
+#define SHA384_CBLOCK 128
+
+// SHA384_DIGEST_LENGTH is the length of a SHA-384 digest.
+#define SHA384_DIGEST_LENGTH 48
+
+// SHA384_Init initialises `sha` and returns 1.
+OPENSSL_EXPORT int SHA384_Init(SHA512_CTX *sha);
+
+// SHA384_Update adds `len` bytes from `data` to `sha` and returns 1.
+OPENSSL_EXPORT int SHA384_Update(SHA512_CTX *sha, const void *data, size_t len);
+
+// SHA384_Final adds the final padding to `sha` and writes the resulting digest
+// to `out`, which must have at least `SHA384_DIGEST_LENGTH` bytes of space. It
+// returns one on success and zero on programmer error.
+OPENSSL_EXPORT int SHA384_Final(uint8_t out[SHA384_DIGEST_LENGTH],
+                                SHA512_CTX *sha);
+
+// SHA384 writes the digest of `len` bytes from `data` to `out` and returns
+// `out`. There must be at least `SHA384_DIGEST_LENGTH` bytes of space in
+// `out`.
+OPENSSL_EXPORT uint8_t *SHA384(const uint8_t *data, size_t len,
+                               uint8_t out[SHA384_DIGEST_LENGTH]);
+
+
+// SHA-512.
+
+// SHA512_CBLOCK is the block size of SHA-512.
+#define SHA512_CBLOCK 128
+
+// SHA512_DIGEST_LENGTH is the length of a SHA-512 digest.
+#define SHA512_DIGEST_LENGTH 64
+
+// SHA512_Init initialises `sha` and returns 1.
+OPENSSL_EXPORT int SHA512_Init(SHA512_CTX *sha);
+
+// SHA512_Update adds `len` bytes from `data` to `sha` and returns 1.
+OPENSSL_EXPORT int SHA512_Update(SHA512_CTX *sha, const void *data, size_t len);
+
+// SHA512_Final adds the final padding to `sha` and writes the resulting digest
+// to `out`, which must have at least `SHA512_DIGEST_LENGTH` bytes of space. It
+// returns one on success and zero on programmer error.
+OPENSSL_EXPORT int SHA512_Final(uint8_t out[SHA512_DIGEST_LENGTH],
+                                SHA512_CTX *sha);
+
+// SHA512 writes the digest of `len` bytes from `data` to `out` and returns
+// `out`. There must be at least `SHA512_DIGEST_LENGTH` bytes of space in
+// `out`.
+OPENSSL_EXPORT uint8_t *SHA512(const uint8_t *data, size_t len,
+                               uint8_t out[SHA512_DIGEST_LENGTH]);
+
+// SHA512_Transform is a low-level function that performs a single, SHA-512
+// block transformation using the state from `sha` and `SHA512_CBLOCK` bytes
+// from `block`.
+OPENSSL_EXPORT void SHA512_Transform(SHA512_CTX *sha,
+                                     const uint8_t block[SHA512_CBLOCK]);
+
+struct sha512_state_st {
+  uint64_t h[8];
+  uint16_t num, md_len;
+  uint32_t bytes_so_far_high;
+  uint64_t bytes_so_far_low;
+  uint8_t p[SHA512_CBLOCK];
+} /* SHA512_CTX */;
+
+
+// SHA-512-256
+//
+// See https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf section 5.3.6
+
+#define SHA512_256_DIGEST_LENGTH 32
+
+// SHA512_256_Init initialises `sha` and returns 1.
+OPENSSL_EXPORT int SHA512_256_Init(SHA512_CTX *sha);
+
+// SHA512_256_Update adds `len` bytes from `data` to `sha` and returns 1.
+OPENSSL_EXPORT int SHA512_256_Update(SHA512_CTX *sha, const void *data,
+                                     size_t len);
+
+// SHA512_256_Final adds the final padding to `sha` and writes the resulting
+// digest to `out`, which must have at least `SHA512_256_DIGEST_LENGTH` bytes of
+// space. It returns one on success and zero on programmer error.
+OPENSSL_EXPORT int SHA512_256_Final(uint8_t out[SHA512_256_DIGEST_LENGTH],
+                                    SHA512_CTX *sha);
+
+// SHA512_256 writes the digest of `len` bytes from `data` to `out` and returns
+// `out`. There must be at least `SHA512_256_DIGEST_LENGTH` bytes of space in
+// `out`.
+OPENSSL_EXPORT uint8_t *SHA512_256(const uint8_t *data, size_t len,
+                                   uint8_t out[SHA512_256_DIGEST_LENGTH]);
+
+
+#if defined(__cplusplus)
+}  // extern C
+#endif
+
+#endif  // OPENSSL_HEADER_SHA2_H

package/runtime/third_party/boringssl/include/openssl/siphash.h

@@ -0,0 +1,37 @@
+// Copyright 2019 The BoringSSL Authors
+//
+// 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
+//
+//     https://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.
+
+#ifndef OPENSSL_HEADER_SIPHASH_H
+#define OPENSSL_HEADER_SIPHASH_H
+
+#include <openssl/base.h>   // IWYU pragma: export
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// SipHash is a fast, secure PRF that is often used for hash tables.
+
+
+// SIPHASH_24 implements SipHash-2-4. See https://131002.net/siphash/siphash.pdf
+OPENSSL_EXPORT uint64_t SIPHASH_24(const uint64_t key[2], const uint8_t *input,
+                                   size_t input_len);
+
+
+#if defined(__cplusplus)
+}  // extern C
+#endif
+
+#endif  // OPENSSL_HEADER_SIPHASH_H

package/runtime/third_party/boringssl/include/openssl/slhdsa.h

@@ -0,0 +1,250 @@
+// Copyright 2024 The BoringSSL Authors
+//
+// 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
+//
+//     https://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.
+
+#ifndef OPENSSL_HEADER_SLHDSA_H
+#define OPENSSL_HEADER_SLHDSA_H
+
+#include <openssl/base.h>  // IWYU pragma: export
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+
+// SLH-DSA.
+
+
+// SLHDSA_SHA2_128S_SEED_BYTES is the number of bytes in an SLH-DSA-SHA2-128s
+// private seed.
+#define SLHDSA_SHA2_128S_SEED_BYTES 48
+
+// SLHDSA_SHA2_128S_PUBLIC_KEY_BYTES is the number of bytes in an
+// SLH-DSA-SHA2-128s public key.
+#define SLHDSA_SHA2_128S_PUBLIC_KEY_BYTES 32
+
+// SLHDSA_SHA2_128S_PRIVATE_KEY_BYTES is the number of bytes in an
+// SLH-DSA-SHA2-128s private key.
+#define SLHDSA_SHA2_128S_PRIVATE_KEY_BYTES 64
+
+// SLHDSA_SHA2_128S_SIGNATURE_BYTES is the number of bytes in an
+// SLH-DSA-SHA2-128s signature.
+#define SLHDSA_SHA2_128S_SIGNATURE_BYTES 7856
+
+// SLHDSA_SHAKE_256F_SEED_BYTES is the number of bytes in an SLH-DSA-SHAKE-256f
+// private seed.
+#define SLHDSA_SHAKE_256F_SEED_BYTES 96
+
+// SLHDSA_SHAKE_256F_PUBLIC_KEY_BYTES is the number of bytes in an
+// SLH-DSA-SHAKE-256f public key.
+#define SLHDSA_SHAKE_256F_PUBLIC_KEY_BYTES 64
+
+// SLHDSA_SHAKE_256F_PRIVATE_KEY_BYTES is the number of bytes in an
+// SLH-DSA-SHAKE-256f private key.
+#define SLHDSA_SHAKE_256F_PRIVATE_KEY_BYTES 128
+
+// SLHDSA_SHAKE_256F_SIGNATURE_BYTES is the number of bytes in an
+// SLH-DSA-SHAKE-256f signature.
+#define SLHDSA_SHAKE_256F_SIGNATURE_BYTES 49856
+
+// SLHDSA_SHA2_128S_generate_key_from_seed generates a SLH-DSA-SHA2-128s key
+// pair from the given `seed` and writes the result to `out_public_key` and
+// `out_private_key`.
+OPENSSL_EXPORT void SLHDSA_SHA2_128S_generate_key_from_seed(
+    uint8_t out_public_key[SLHDSA_SHA2_128S_PUBLIC_KEY_BYTES],
+    uint8_t out_private_key[SLHDSA_SHA2_128S_PRIVATE_KEY_BYTES],
+    const uint8_t seed[SLHDSA_SHA2_128S_SEED_BYTES]);
+
+// SLHDSA_SHAKE_256F_generate_key_from_seed generates a SLH-DSA-SHA2-128s key
+// pair from the given `seed` and writes the result to `out_public_key` and
+// `out_private_key`.
+OPENSSL_EXPORT void SLHDSA_SHAKE_256F_generate_key_from_seed(
+    uint8_t out_public_key[SLHDSA_SHAKE_256F_PUBLIC_KEY_BYTES],
+    uint8_t out_private_key[SLHDSA_SHAKE_256F_PRIVATE_KEY_BYTES],
+    const uint8_t seed[SLHDSA_SHAKE_256F_SEED_BYTES]);
+
+// SLHDSA_SHA2_128S_generate_key generates a SLH-DSA-SHA2-128s key pair and
+// writes the result to `out_public_key` and `out_private_key`.
+OPENSSL_EXPORT void SLHDSA_SHA2_128S_generate_key(
+    uint8_t out_public_key[SLHDSA_SHA2_128S_PUBLIC_KEY_BYTES],
+    uint8_t out_private_key[SLHDSA_SHA2_128S_PRIVATE_KEY_BYTES]);
+
+// SLHDSA_SHAKE_256F_generate_key generates a SLH-DSA-SHAKE-256f key pair and
+// writes the result to `out_public_key` and `out_private_key`.
+OPENSSL_EXPORT void SLHDSA_SHAKE_256F_generate_key(
+    uint8_t out_public_key[SLHDSA_SHAKE_256F_PUBLIC_KEY_BYTES],
+    uint8_t out_private_key[SLHDSA_SHAKE_256F_PRIVATE_KEY_BYTES]);
+
+// SLHDSA_SHA2_128S_public_from_private writes the public key corresponding to
+// `private_key` to `out_public_key`.
+OPENSSL_EXPORT void SLHDSA_SHA2_128S_public_from_private(
+    uint8_t out_public_key[SLHDSA_SHA2_128S_PUBLIC_KEY_BYTES],
+    const uint8_t private_key[SLHDSA_SHA2_128S_PRIVATE_KEY_BYTES]);
+
+// SLHDSA_SHAKE_256F_public_from_private writes the public key corresponding to
+// `private_key` to `out_public_key`.
+OPENSSL_EXPORT void SLHDSA_SHAKE_256F_public_from_private(
+    uint8_t out_public_key[SLHDSA_SHAKE_256F_PUBLIC_KEY_BYTES],
+    const uint8_t private_key[SLHDSA_SHAKE_256F_PRIVATE_KEY_BYTES]);
+
+// SLHDSA_SHA2_128S_sign slowly generates a SLH-DSA-SHA2-128s signature of `msg`
+// using `private_key` and writes it to `out_signature`. The `context` argument
+// is also signed over and can be used to include implicit contextual
+// information that isn't included in `msg`. The same value of `context` must be
+// presented to `SLHDSA_SHA2_128S_verify` in order for the generated signature
+// to be considered valid. `context` and `context_len` may be `NULL` and 0 to
+// use an empty context (this is common). It returns 1 on success and 0 if
+// `context_len` is larger than 255.
+OPENSSL_EXPORT int SLHDSA_SHA2_128S_sign(
+    uint8_t out_signature[SLHDSA_SHA2_128S_SIGNATURE_BYTES],
+    const uint8_t private_key[SLHDSA_SHA2_128S_PRIVATE_KEY_BYTES],
+    const uint8_t *msg, size_t msg_len, const uint8_t *context,
+    size_t context_len);
+
+// SLHDSA_SHAKE_256F_sign slowly generates a SLH-DSA-SHAKE-256f signature of
+// `msg` using `private_key` and writes it to `out_signature`. The `context`
+// argument is also signed over and can be used to include implicit contextual
+// information that isn't included in `msg`. The same value of `context` must be
+// presented to `SLHDSA_SHAKE_256F_verify` in order for the generated signature
+// to be considered valid. `context` and `context_len` may be `NULL` and 0 to
+// use an empty context (this is common). It returns 1 on success and 0 if
+// `context_len` is larger than 255.
+OPENSSL_EXPORT int SLHDSA_SHAKE_256F_sign(
+    uint8_t out_signature[SLHDSA_SHAKE_256F_SIGNATURE_BYTES],
+    const uint8_t private_key[SLHDSA_SHAKE_256F_PRIVATE_KEY_BYTES],
+    const uint8_t *msg, size_t msg_len, const uint8_t *context,
+    size_t context_len);
+
+// SLHDSA_SHA2_128S_verify verifies that `signature` is a valid
+// SLH-DSA-SHA2-128s signature of `msg` by `public_key`. The value of `context`
+// must equal the value that was passed to `SLHDSA_SHA2_128S_sign` when the
+// signature was generated. It returns 1 if the signature is valid and 0
+// otherwise.
+OPENSSL_EXPORT int SLHDSA_SHA2_128S_verify(
+    const uint8_t *signature, size_t signature_len,
+    const uint8_t public_key[SLHDSA_SHA2_128S_PUBLIC_KEY_BYTES],
+    const uint8_t *msg, size_t msg_len, const uint8_t *context,
+    size_t context_len);
+
+// SLHDSA_SHAKE_256F_verify verifies that `signature` is a valid
+// SLH-DSA-SHAKE-256f signature of `msg` by `public_key`. The value of `context`
+// must equal the value that was passed to `SLHDSA_SHAKE_256F_sign` when the
+// signature was generated. It returns 1 if the signature is valid and 0
+// otherwise.
+OPENSSL_EXPORT int SLHDSA_SHAKE_256F_verify(
+    const uint8_t *signature, size_t signature_len,
+    const uint8_t public_key[SLHDSA_SHAKE_256F_PUBLIC_KEY_BYTES],
+    const uint8_t *msg, size_t msg_len, const uint8_t *context,
+    size_t context_len);
+
+
+// Prehashed SLH-DSA-SHA2-128s.
+//
+// These functions sign the hash of a message. They should generally not be
+// used. The general functions are perfectly capable of signing a hash if you
+// wish. These functions should only be used when:
+//
+//   a) Compatibility with an external system that uses prehashed messages is
+//      required. (The general signature of a hash is not compatible with a
+//      "prehash" signature of the same hash.)
+//   b) A single private key is used to sign both prehashed and raw messages,
+//      and there's no other way to prevent ambiguity.
+
+// SLHDSA_SHA2_128S_prehash_sign slowly generates a SLH-DSA-SHA2-128s signature
+// of the prehashed `hashed_msg` using `private_key` and writes it to
+// `out_signature`. The `context` argument is also signed over and can be used
+// to include implicit contextual information that isn't included in
+// `hashed_msg`. The same value of `context` must be presented to
+// `SLHDSA_SHA2_128S_prehash_verify` in order for the generated signature to be
+// considered valid. `context` and `context_len` may be `NULL` and 0 to use an
+// empty context (this is common).
+//
+// The `hash_nid` argument must specify the hash function that was used to
+// generate `hashed_msg`. This function only accepts hash functions listed in
+// FIPS 205.
+//
+// This function returns 1 on success and 0 if `context_len` is larger than 255,
+// if the hash function is not supported, or if `hashed_msg` is the wrong
+// length.
+OPENSSL_EXPORT int SLHDSA_SHA2_128S_prehash_sign(
+    uint8_t out_signature[SLHDSA_SHA2_128S_SIGNATURE_BYTES],
+    const uint8_t private_key[SLHDSA_SHA2_128S_PRIVATE_KEY_BYTES],
+    const uint8_t *hashed_msg, size_t hashed_msg_len, int hash_nid,
+    const uint8_t *context, size_t context_len);
+
+// SLHDSA_SHA2_128S_prehash_verify verifies that `signature` is a valid
+// SLH-DSA-SHA2-128s signature of the prehashed `hashed_msg` by `public_key`,
+// using the hash algorithm identified by `hash_nid`. The value of `context`
+// must equal the value that was passed to `SLHDSA_SHA2_128S_prehash_sign` when
+// the signature was generated.
+//
+// The `hash_nid` argument must specify the hash function that was used to
+// generate `hashed_msg`. This function only accepts hash functions that are
+// listed in FIPS 205.
+//
+// This function returns 1 if the signature is valid and 0 if the signature is
+// invalid, the hash function is not supported, or if `hashed_msg` is the wrong
+// length.
+OPENSSL_EXPORT int SLHDSA_SHA2_128S_prehash_verify(
+    const uint8_t *signature, size_t signature_len,
+    const uint8_t public_key[SLHDSA_SHA2_128S_PUBLIC_KEY_BYTES],
+    const uint8_t *hashed_msg, size_t hashed_msg_len, int hash_nid,
+    const uint8_t *context, size_t context_len);
+
+// SLHDSA_SHA2_128S_prehash_warning_nonstandard_sign slowly generates a
+// SLH-DSA-SHA2-128s signature of the prehashed `hashed_msg` using `private_key`
+// and writes it to `out_signature`. The `context` argument is also signed over
+// and can be used to include implicit contextual information that isn't
+// included in `hashed_msg`. The same value of `context` must be presented to
+// `SLHDSA_SHA2_128S_prehash_warning_nonstandard_verify` in order for the
+// generated signature to be considered valid. `context` and `context_len` may
+// be `NULL` and 0 to use an empty context (this is common).
+//
+// The `hash_nid` argument must specify the hash function that was used to
+// generate `hashed_msg`. This function only accepts non-standard hash functions
+// that are not compliant with FIPS 205.
+//
+// This function returns 1 on success and 0 if `context_len` is larger than 255,
+// if the hash function is not supported, or if `hashed_msg` is the wrong
+// length.
+OPENSSL_EXPORT int SLHDSA_SHA2_128S_prehash_warning_nonstandard_sign(
+    uint8_t out_signature[SLHDSA_SHA2_128S_SIGNATURE_BYTES],
+    const uint8_t private_key[SLHDSA_SHA2_128S_PRIVATE_KEY_BYTES],
+    const uint8_t *hashed_msg, size_t hashed_msg_len, int hash_nid,
+    const uint8_t *context, size_t context_len);
+
+// SLHDSA_SHA2_128S_prehash_warning_nonstandard_verify verifies that `signature`
+// is a valid SLH-DSA-SHA2-128s signature of the prehashed `hashed_msg` by
+// `public_key`, using the hash algorithm identified by `hash_nid`. The value of
+// `context` must equal the value that was passed to
+// `SLHDSA_SHA2_128S_prehash_sign` when the signature was generated.
+//
+// The `hash_nid` argument must specify the hash function that was used to
+// generate `hashed_msg`. This function only accepts non-standard hash functions
+// that are not compliant with FIPS 205.
+//
+// This function returns 1 if the signature is valid and 0 if the signature is
+// invalid, the hash function is not supported, or if `hashed_msg` is the wrong
+// length.
+OPENSSL_EXPORT int SLHDSA_SHA2_128S_prehash_warning_nonstandard_verify(
+    const uint8_t *signature, size_t signature_len,
+    const uint8_t public_key[SLHDSA_SHA2_128S_PUBLIC_KEY_BYTES],
+    const uint8_t *hashed_msg, size_t hashed_msg_len, int hash_nid,
+    const uint8_t *context, size_t context_len);
+
+
+#if defined(__cplusplus)
+}  // extern C
+#endif
+
+#endif  // OPENSSL_HEADER_SLHDSA_H