Compare commits

...
16 Commits
Author SHA1 Message Date
Si Beaumont ff0f781cf7 extras: Add EC toolbox abstractions and OPRF(P-384, SHA-384) VOPRF API (#292)
## Motivation

We would like to provide support for the P384-SHA384 Verifiable Oblivious Pseudorandom Function (VOPRF) as defined in [RFC 9497: VOPRF Protocol](https://www.rfc-editor.org/rfc/rfc9497.html#name-voprf-protocol).

## Modifications

- Add protocols for some "ECToolbox" abstractions: `Group`, `GroupElement`, `GroupScalar`, `HashToGroup`.
- Add implementations backed by BoringSSL.
- Duplicate some utilities from Crypto into _CryptoExtras: hexadecimal bytes and I2OSP.
- Add VOPRF API, rooted at `enum P384._VOPRF`.

## Results

- New internal abstractions that make it easier to bring up new implementations.
- New API for `OPRF(P-384, SHA-384)` in VOPRF mode.

## Tests

- Test vectors for internal `HashToField` implementation.
- Test vectors for internal VOPRF implementation.
- Tests of the VOPRF public API.
2024-11-22 09:30:35 +00:00
Dimitri Bouniol a3b7196be9 Potentially Inconsistent Coordinate Slicing (#299)
* Replaced potentially unexpected accesses to coordinate slices with consistent ranges no matter if the raw representation is a root or a slice of data

* Updated uses of `.suffix(from:)` with `.dropFirst()` to prevent issues with potential non-0 start indexes
2024-11-21 17:11:58 +00:00
Rick Newton-RogersandGeorge Barnett b6a32eb851 add .spi.yml (#297)
Add .spi.yml for `Crypto` target so that DocC documentation is
generated.

Co-authored-by: George Barnett <gbarnett@apple.com>
2024-11-15 09:52:22 +00:00
Rick Newton-Rogers e14f4bb065 add .editorconfig file (#296) 2024-11-15 09:48:15 +00:00
Kyle 06dc63c6d8 Fix WASI platform build issue (#291) 2024-10-30 13:36:45 +00:00
Paul ToffoloniandCory Benfield 62958ed575 Fix Windows CI (#289)
Co-authored-by: Cory Benfield <lukasa@apple.com>
2024-10-29 14:29:05 +00:00
Franz Busch e9d46e7bf9 [CI] Enable Windows CI (#288) 2024-10-29 13:57:41 +00:00
finagolfin 8fa345c208 Add support for new Android overlay, swiftlang/swift#74758 (#286) 2024-10-21 15:30:06 +00:00
Adam Kopeć 7cb61135cb New API Proposal: Password based KDF (#98)
Motivation:

I've added a proposed implementation of PBKDF2, as per proposal in issue #59 to allow easy creation of SymmetricKey from relatively low entropy data sets, such as user provided passwords.

Importance:

This API change is attempting to simplify the creation of SymmetricKeys from user entered passwords.
It uses an ageing algorithm – PBKDF2, but it is still widely supported and popular. A newer algorithm – scrypt is added as a better, more secure alternative.

Modifications:

I've proposed a new API:  KDF namespace with Scrypt struct and an Insecure namespace with PBKDF2 struct with associated hash function and a single static method which takes a passphrase and salt, the size of the resulting key in bytes and optionally the number of rounds to use in the PBKDF2 algorithm.
In the case of scrypt algorithm there is no associated hash function due to the nature of the algorithm, the single static method takes passphrase and salt, the size of the resulting key in bytes and optionally: the number of rounds, block size and parallelism factor.
I implemented this functions using both CommonCrypto and BoringSSL where available.
The function names and parameters are heavily influenced by current HKDF implementation.

Additionally, I've added test cases to test the proposed API. I've decided to use test vectors described in RFC6070 for PBKDF2 and test vectors described in RFC7914 for scrypt.

Result:

This will add a new API to _CryptoKitExtras.
It follows the naming conventions from CryptoKit's HKDF implementation.
2024-10-18 17:16:05 +00:00
Cory Benfield 4518e5e680 Fix windows build and update BoringSSL to 2587c4974dbe9872451151c8e975f58567a1ce0d (#279)
* Update vendoring script

* Update BoringSSL to 2587c4974dbe9872451151c8e975f58567a1ce0d
2024-10-17 12:26:13 +00:00
Si Beaumont 4324b40570 wrapper: Add modular arithmetic functions to ArbitraryPrecisionInteger (#284) 2024-10-17 12:23:48 +00:00
Si Beaumont f98e46e42a wrapper: Move EC types and random bytes into CryptoBoringWrapper (#277)
* wrapper: Remove _boring suffix from files in CryptoBoringWrapper

* wrapper: Move EC types and random bytes into CryptoBoringWrapper

* tests: Remove unused conditional compilation conditions in wrapper tests
2024-10-17 10:03:07 +01:00
Franz Busch ae321d29be [CI] Adopt GitHub actions (#280) 2024-10-16 18:04:07 +01:00
Si Beaumont 21f7878f2b Refactor and adopt package access to remove symlinked files (#265) 2024-10-08 14:10:48 +01:00
Cory Benfield 735a29ccf7 Update BoringSSL to 76968bb3d53982560bcf08bcd0ba3e1865fe15cd (#271)
Also fixes the build issues on Windows, resolves #262
2024-10-07 10:19:12 +01:00
Gautier Delorme b639b5bd1f Support loading RSAPSS public keys with parameters (#268)
* Support loading RSAPSS public keys with parameters

Parameters are stripped and the key is treated as a regular public key.

* address review + reset algorithm as well

* run update_cmakelists.sh

* attempt to fix the cmake build

* include FetchContent

* early return for non-PSS keys

* simplify code
2024-10-03 18:33:02 +01:00
288 changed files with 8237 additions and 1402 deletions

No files matched your search

+8
View File
@@ -0,0 +1,8 @@
root = true
[*]
indent_style = space
indent_size = 4
end_of_line = lf
insert_final_newline = true
trim_trailing_whitespace = true
+1 -1
View File
@@ -9,7 +9,7 @@ about: If something isn't working as expected
### New Issue Checklist
- [ ] I'm using the latest version of Swift Crypto (`main` branch)
- [ ] I read the [Contribution Guidelines](https://github.com/apple/swift-crypto/blob/master/CONTRIBUTING.md)
- [ ] I read the [Contribution Guidelines](https://github.com/apple/swift-crypto/blob/main/CONTRIBUTING.md)
- [ ] I searched for [existing GitHub issues](https://github.com/apple/swift-crypto/issues)
### Expected behavior
+2 -2
View File
@@ -6,8 +6,8 @@ about: Not sure how something works or how to implement some functionality? Ask
### Question Checklist
- [ ] I'm using the latest version of Swift Crypto (master branch)
- [ ] I read the [Contribution Guidelines](https://github.com/apple/swift-crypto/blob/master/CONTRIBUTING.md)
- [ ] I'm using the latest version of Swift Crypto (main branch)
- [ ] I read the [Contribution Guidelines](https://github.com/apple/swift-crypto/blob/main/CONTRIBUTING.md)
- [ ] I searched for [existing GitHub issues](https://github.com/apple/swift-crypto/issues)
### Question Subject
+2 -2
View File
@@ -8,8 +8,8 @@ about: If a recent release broke a feature (Please make sure you know the last k
### New Regression Checklist
- [ ] I'm using the latest version of Swift Crypto (master branch)
- [ ] I read the [Contribution Guidelines](https://github.com/apple/swift-crypto/blob/master/CONTRIBUTING.md)
- [ ] I'm using the latest version of Swift Crypto (main branch)
- [ ] I read the [Contribution Guidelines](https://github.com/apple/swift-crypto/blob/main/CONTRIBUTING.md)
- [ ] I searched for [existing GitHub issues](https://github.com/apple/swift-crypto/issues)
### Regression Information
+22
View File
@@ -0,0 +1,22 @@
name: Main
on:
push:
branches: [main]
schedule:
- cron: "0 8,20 * * *"
jobs:
unit-tests:
name: Unit tests
uses: apple/swift-nio/.github/workflows/unit_tests.yml@main
with:
linux_5_9_arguments_override: "--explicit-target-dependency-import-check error"
linux_5_10_arguments_override: "--explicit-target-dependency-import-check error"
linux_6_0_arguments_override: "--explicit-target-dependency-import-check error"
linux_nightly_6_0_arguments_override: "--explicit-target-dependency-import-check error"
linux_nightly_main_arguments_override: "--explicit-target-dependency-import-check error"
cxx-interop:
name: Cxx interop
uses: apple/swift-nio/.github/workflows/cxx_interop.yml@main
+41
View File
@@ -0,0 +1,41 @@
name: PR
on:
pull_request:
types: [opened, reopened, synchronize]
jobs:
soundness:
name: Soundness
uses: swiftlang/github-workflows/.github/workflows/soundness.yml@main
with:
license_header_check_project_name: "SwiftCrypto"
format_check_enabled: false
docs_check_enabled: false
cmake-lists:
name: Check cmake lists
uses: apple/swift-nio/.github/workflows/swift_matrix.yml@main
with:
name: "Check cmake lists"
matrix_linux_command: ./scripts/check-cmake-lists.sh
unit-tests:
name: Unit tests
uses: apple/swift-nio/.github/workflows/unit_tests.yml@main
with:
linux_5_9_arguments_override: "--explicit-target-dependency-import-check error"
linux_5_10_arguments_override: "--explicit-target-dependency-import-check error"
linux_6_0_arguments_override: "--explicit-target-dependency-import-check error"
linux_nightly_6_0_arguments_override: "--explicit-target-dependency-import-check error"
linux_nightly_main_arguments_override: "--explicit-target-dependency-import-check error"
windows_6_0_enabled: true
windows_nightly_6_0_enabled: true
windows_nightly_main_enabled: true
windows_6_0_arguments_override: "--explicit-target-dependency-import-check error"
windows_nightly_6_0_arguments_override: "--explicit-target-dependency-import-check error"
windows_nightly_main_arguments_override: "--explicit-target-dependency-import-check error"
cxx-interop:
name: Cxx interop
uses: apple/swift-nio/.github/workflows/cxx_interop.yml@main
+18
View File
@@ -0,0 +1,18 @@
name: PR label
on:
pull_request:
types: [labeled, unlabeled, opened, reopened, synchronize]
jobs:
semver-label-check:
name: Semantic Version label check
runs-on: ubuntu-latest
timeout-minutes: 1
steps:
- name: Checkout repository
uses: actions/checkout@v4
with:
persist-credentials: false
- name: Check for Semantic Version label
uses: apple/swift-nio/.github/actions/pull_request_semver_label_checker@main
+48
View File
@@ -0,0 +1,48 @@
.gitignore
**/.gitignore
.licenseignore
.unacceptablelanguageignore
.gitattributes
.git-blame-ignore-revs
.mailfilter
.mailmap
.spi.yml
.swift-format
.editorconfig
.github/*
*.md
*.txt
*.yml
*.yaml
*.json
Package.swift
**/Package.swift
Package@-*.swift
**/Package@-*.swift
Package.resolved
**/Package.resolved
Makefile
*.modulemap
**/*.modulemap
**/*.docc/*
*.xcprivacy
**/*.xcprivacy
*.symlink
**/*.symlink
Dockerfile
**/Dockerfile
Snippets/*
dev/git.commit.template
dev/update-benchmark-thresholds
*.crt
**/*.crt
*.pem
**/*.pem
*.der
**/*.der
.swiftformat
Sources/CCryptoBoringSSL/*
**/*.swift.gyb
scripts/*.patch
scripts/gyb
scripts/gyb.py
+4
View File
@@ -0,0 +1,4 @@
version: 1
builder:
configs:
- documentation_targets: [Crypto]
+1
View File
@@ -0,0 +1 @@
Sources/CCryptoBoringSSL/*
-5
View File
@@ -1,5 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<array/>
</plist>
+15 -1
View File
@@ -6,7 +6,7 @@
## Licensed under Apache License v2.0
##
## See LICENSE.txt for license information
## See CONTRIBUTORS.md for the list of SwiftCrypto project authors
## See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
##
## SPDX-License-Identifier: Apache-2.0
##
@@ -31,6 +31,10 @@ endif()
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set(CMAKE_Swift_MODULE_DIRECTORY ${CMAKE_BINARY_DIR}/swift)
set(SWIFT_CRYPTO_COMPILE_OPTIONS
-package-name com.apple.swift-crypto
)
option(BUILD_SHARED_LIBS "Build shared libraries by default" YES)
if(BUILD_SHARED_LIBS)
@@ -48,5 +52,15 @@ if(NOT CMAKE_SYSTEM_NAME STREQUAL Darwin)
find_package(Foundation CONFIG)
endif()
include(FetchContent)
find_package(SwiftASN1 CONFIG)
if(NOT SwiftASN1_FOUND)
message("-- Vending swift-asn1")
FetchContent_Declare(ASN1
GIT_REPOSITORY https://github.com/apple/swift-asn1
GIT_TAG 1.1.0)
FetchContent_MakeAvailable(ASN1)
endif()
add_subdirectory(Sources)
add_subdirectory(cmake/modules)
File renamed without changes.
+1 -1
View File
@@ -28,7 +28,7 @@ components that this product depends on.
This product contains test vectors from Google's wycheproof project.
* LICENSE (Apache License 2.0):
* https://github.com/google/wycheproof/blob/master/LICENSE
* https://github.com/C2SP/wycheproof/blob/31387e2cd596587c859c611027b6a44d2e2b65ff/LICENSE
* HOMEPAGE:
* https://github.com/google/wycheproof
+21 -6
View File
@@ -7,7 +7,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
@@ -20,7 +20,7 @@
// Sources/CCryptoBoringSSL directory. The source repository is at
// https://boringssl.googlesource.com/boringssl.
//
// BoringSSL Commit: 6a2ccdcc2ed1d37a43a2183658d2ae61fd5ce208
// BoringSSL Commit: 2587c4974dbe9872451151c8e975f58567a1ce0d
import PackageDescription
@@ -84,7 +84,9 @@ let package = Package(
.library(name: "CCryptoBoringSSL", type: .static, targets: ["CCryptoBoringSSL"]),
MANGLE_END */
],
dependencies: [],
dependencies: [
.package(url: "https://github.com/apple/swift-asn1.git", from: "1.2.0")
],
targets: [
.target(
name: "CCryptoBoringSSL",
@@ -133,7 +135,7 @@ let package = Package(
"Signatures/ECDSA.swift.gyb",
],
resources: privacyManifestResource,
swiftSettings: swiftSettings + [.define("MODULE_IS_CRYPTO")]
swiftSettings: swiftSettings
),
.target(
name: "_CryptoExtras",
@@ -141,7 +143,8 @@ let package = Package(
"CCryptoBoringSSL",
"CCryptoBoringSSLShims",
"CryptoBoringWrapper",
"Crypto"
"Crypto",
.product(name: "SwiftASN1", package: "swift-asn1")
],
exclude: privacyManifestExclude + [
"CMakeLists.txt",
@@ -169,7 +172,19 @@ let package = Package(
],
swiftSettings: swiftSettings
),
.testTarget(name: "_CryptoExtrasTests", dependencies: ["_CryptoExtras"]),
.testTarget(
name: "_CryptoExtrasTests",
dependencies: ["_CryptoExtras"],
resources: [
.copy("ECToolbox/H2CVectors/P256_XMD-SHA-256_SSWU_RO_.json"),
.copy("ECToolbox/H2CVectors/P384_XMD-SHA-384_SSWU_RO_.json"),
.copy("OPRFs/OPRFVectors/OPRFVectors-VOPRFDraft8.json"),
.copy("OPRFs/OPRFVectors/OPRFVectors-VOPRFDraft19.json"),
.copy("OPRFs/OPRFVectors/OPRFVectors-edgecases.json"),
],
swiftSettings: swiftSettings
),
.testTarget(name: "CryptoBoringWrapperTests", dependencies: ["CryptoBoringWrapper"]),
],
cxxLanguageStandard: .cxx11
)
+9 -1
View File
@@ -6,7 +6,7 @@
## Licensed under Apache License v2.0
##
## See LICENSE.txt for license information
## See CONTRIBUTORS.md for the list of SwiftCrypto project authors
## See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
##
## SPDX-License-Identifier: Apache-2.0
##
@@ -165,9 +165,17 @@ add_library(CCryptoBoringSSL STATIC
"crypto/refcount.c"
"crypto/rsa_extra/rsa_asn1.c"
"crypto/rsa_extra/rsa_crypt.c"
"crypto/rsa_extra/rsa_extra.c"
"crypto/rsa_extra/rsa_print.c"
"crypto/sha/sha1.c"
"crypto/sha/sha256.c"
"crypto/sha/sha512.c"
"crypto/siphash/siphash.c"
"crypto/slhdsa/fors.c"
"crypto/slhdsa/merkle.c"
"crypto/slhdsa/slhdsa.c"
"crypto/slhdsa/thash.c"
"crypto/slhdsa/wots.c"
"crypto/spx/spx.c"
"crypto/spx/spx_address.c"
"crypto/spx/spx_fors.c"
@@ -17,6 +17,8 @@
#include <CCryptoBoringSSL_base.h>
#include <stdio.h>
// Provided by libcrypto, called from BCM
#if defined(__cplusplus)
@@ -105,6 +107,10 @@ OPENSSL_EXPORT uint64_t CRYPTO_get_fork_generation(void);
OPENSSL_EXPORT void CRYPTO_fork_detect_force_madv_wipeonfork_for_testing(
int on);
// CRYPTO_get_stderr returns stderr. This function exists to avoid BCM needing
// a data dependency on libc.
FILE *CRYPTO_get_stderr(void);
#if defined(__cplusplus)
} // extern C
@@ -487,7 +487,11 @@ static long conn_callback_ctrl(BIO *bio, int cmd, bio_info_cb fp) {
// convention.
OPENSSL_MSVC_PRAGMA(warning(push))
OPENSSL_MSVC_PRAGMA(warning(disable : 4191))
OPENSSL_CLANG_PRAGMA("clang diagnostic push")
OPENSSL_CLANG_PRAGMA("clang diagnostic ignored \"-Wunknown-warning-option\"")
OPENSSL_CLANG_PRAGMA("clang diagnostic ignored \"-Wcast-function-type\"")
data->info_callback = (int (*)(const struct bio_st *, int, int))fp;
OPENSSL_CLANG_PRAGMA("clang diagnostic pop")
OPENSSL_MSVC_PRAGMA(warning(pop))
break;
default:
@@ -442,6 +442,7 @@ static int aead_tls_get_iv(const EVP_AEAD_CTX *ctx, const uint8_t **out_iv,
const AEAD_TLS_CTX *tls_ctx = (AEAD_TLS_CTX *)&ctx->state;
const size_t iv_len = EVP_CIPHER_CTX_iv_length(&tls_ctx->cipher_ctx);
if (iv_len <= 1) {
OPENSSL_PUT_ERROR(CIPHER, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
return 0;
}
+3
View File
@@ -15,6 +15,7 @@
#include <CCryptoBoringSSL_crypto.h>
#include <assert.h>
#include <stdio.h>
#include "fipsmodule/rand/internal.h"
#include "bcm_support.h"
@@ -186,3 +187,5 @@ int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings) {
}
void OPENSSL_cleanup(void) {}
FILE *CRYPTO_get_stderr(void) { return stderr; }
@@ -42,8 +42,6 @@ struct dsa_st {
CRYPTO_EX_DATA ex_data;
};
#define OPENSSL_DSA_MAX_MODULUS_BITS 10000
// dsa_check_key performs cheap self-checks on |dsa|, and ensures it is within
// DoS bounds. It returns one on success and zero on error.
int dsa_check_key(const DSA *dsa);
@@ -478,6 +478,41 @@ int i2d_ECPrivateKey(const EC_KEY *key, uint8_t **outp) {
return CBB_finish_i2d(&cbb, outp);
}
EC_GROUP *d2i_ECPKParameters(EC_GROUP **out, const uint8_t **inp, long len) {
if (len < 0) {
return NULL;
}
CBS cbs;
CBS_init(&cbs, *inp, (size_t)len);
EC_GROUP *ret = EC_KEY_parse_parameters(&cbs);
if (ret == NULL) {
return NULL;
}
if (out != NULL) {
EC_GROUP_free(*out);
*out = ret;
}
*inp = CBS_data(&cbs);
return ret;
}
int i2d_ECPKParameters(const EC_GROUP *group, uint8_t **outp) {
if (group == NULL) {
OPENSSL_PUT_ERROR(EC, ERR_R_PASSED_NULL_PARAMETER);
return -1;
}
CBB cbb;
if (!CBB_init(&cbb, 0) || //
!EC_KEY_marshal_curve_name(&cbb, group)) {
CBB_cleanup(&cbb);
return -1;
}
return CBB_finish_i2d(&cbb, outp);
}
EC_KEY *d2i_ECParameters(EC_KEY **out_key, const uint8_t **inp, long len) {
if (len < 0) {
return NULL;
@@ -29,6 +29,7 @@
#include <CCryptoBoringSSL_sha.h>
#include "bcm_interface.h"
#include "../bcm_support.h"
#include "../internal.h"
// TODO(crbug.com/362530616): When delocate is removed, build these files as
@@ -136,7 +137,7 @@ static void assert_within(const void *start, const void *symbol,
}
fprintf(
stderr,
CRYPTO_get_stderr(),
"FIPS module doesn't span expected symbol. Expected %p <= %p < %p\n",
start, symbol, end);
BORINGSSL_FIPS_abort();
@@ -194,7 +195,7 @@ int BORINGSSL_integrity_test(void) {
assert_within(start, RSA_sign, end);
assert_within(start, BCM_rand_bytes, end);
assert_within(start, EC_GROUP_cmp, end);
assert_within(start, SHA256_Update, end);
assert_within(start, BCM_sha256_update, end);
assert_within(start, ecdsa_verify_fixed, end);
assert_within(start, EVP_AEAD_CTX_seal, end);
@@ -224,7 +225,7 @@ int BORINGSSL_integrity_test(void) {
HMAC_CTX_init(&hmac_ctx);
if (!HMAC_Init_ex(&hmac_ctx, kHMACKey, sizeof(kHMACKey), kHashFunction,
NULL /* no ENGINE */)) {
fprintf(stderr, "HMAC_Init_ex failed.\n");
fprintf(CRYPTO_get_stderr(), "HMAC_Init_ex failed.\n");
return 0;
}
@@ -244,7 +245,7 @@ int BORINGSSL_integrity_test(void) {
if (!HMAC_Final(&hmac_ctx, result, &result_len) ||
result_len != sizeof(result)) {
fprintf(stderr, "HMAC failed.\n");
fprintf(CRYPTO_get_stderr(), "HMAC failed.\n");
return 0;
}
HMAC_CTX_cleanse(&hmac_ctx); // FIPS 140-3, AS05.10.
@@ -98,7 +98,8 @@ bcm_infallible BCM_sha1_init(SHA_CTX *sha);
// BCM_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|.
bcm_infallible BCM_sha1_transform(SHA_CTX *c, const uint8_t data[BCM_SHA_CBLOCK]);
bcm_infallible BCM_sha1_transform(SHA_CTX *c,
const uint8_t data[BCM_SHA_CBLOCK]);
// BCM_sha1_update adds |len| bytes from |data| to |sha|.
bcm_infallible BCM_sha1_update(SHA_CTX *c, const void *data, size_t len);
@@ -125,6 +126,117 @@ bcm_infallible BCM_fips_186_2_prf(uint8_t *out, size_t out_len,
const uint8_t xkey[BCM_SHA_DIGEST_LENGTH]);
// SHA-224
// SHA224_DIGEST_LENGTH is the length of a SHA-224 digest.
#define BCM_SHA224_DIGEST_LENGTH 28
// BCM_sha224_unit initialises |sha|.
bcm_infallible BCM_sha224_init(SHA256_CTX *sha);
// BCM_sha224_update adds |len| bytes from |data| to |sha|.
bcm_infallible BCM_sha224_update(SHA256_CTX *sha, const void *data, size_t len);
// BCM_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 aborts on programmer error.
bcm_infallible BCM_sha224_final(uint8_t out[BCM_SHA224_DIGEST_LENGTH],
SHA256_CTX *sha);
// SHA-256
// BCM_SHA256_DIGEST_LENGTH is the length of a SHA-256 digest.
#define BCM_SHA256_DIGEST_LENGTH 32
// BCM_sha256_init initialises |sha|.
bcm_infallible BCM_sha256_init(SHA256_CTX *sha);
// BCM_sha256_update adds |len| bytes from |data| to |sha|.
bcm_infallible BCM_sha256_update(SHA256_CTX *sha, const void *data, size_t len);
// BCM_sha256_final adds the final padding to |sha| and writes the resulting
// digest to |out|, which must have at least |BCM_SHA256_DIGEST_LENGTH| bytes of
// space. It aborts on programmer error.
bcm_infallible BCM_sha256_final(uint8_t out[BCM_SHA256_DIGEST_LENGTH],
SHA256_CTX *sha);
// BCM_sha256_transform is a low-level function that performs a single, SHA-256
// block transformation using the state from |sha| and |BCM_SHA256_CBLOCK| bytes
// from |block|.
bcm_infallible BCM_sha256_transform(SHA256_CTX *sha,
const uint8_t block[BCM_SHA256_CBLOCK]);
// BCM_sha256_transform_blocks is a low-level function that takes |num_blocks| *
// |BCM_SHA256_CBLOCK| bytes of data and performs SHA-256 transforms on it to
// update |state|.
bcm_infallible BCM_sha256_transform_blocks(uint32_t state[8],
const uint8_t *data,
size_t num_blocks);
// SHA-384.
// BCM_SHA384_DIGEST_LENGTH is the length of a SHA-384 digest.
#define BCM_SHA384_DIGEST_LENGTH 48
// BCM_sha384_init initialises |sha|.
bcm_infallible BCM_sha384_init(SHA512_CTX *sha);
// BCM_sha384_update adds |len| bytes from |data| to |sha|.
bcm_infallible BCM_sha384_update(SHA512_CTX *sha, const void *data, size_t len);
// BCM_sha384_final adds the final padding to |sha| and writes the resulting
// digest to |out|, which must have at least |BCM_sha384_DIGEST_LENGTH| bytes of
// space. It may abort on programmer error.
bcm_infallible BCM_sha384_final(uint8_t out[BCM_SHA384_DIGEST_LENGTH],
SHA512_CTX *sha);
// SHA-512.
// BCM_SHA512_DIGEST_LENGTH is the length of a SHA-512 digest.
#define BCM_SHA512_DIGEST_LENGTH 64
// BCM_sha512_init initialises |sha|.
bcm_infallible BCM_sha512_init(SHA512_CTX *sha);
// BCM_sha512_update adds |len| bytes from |data| to |sha|.
bcm_infallible BCM_sha512_update(SHA512_CTX *sha, const void *data, size_t len);
// BCM_sha512_final adds the final padding to |sha| and writes the resulting
// digest to |out|, which must have at least |BCM_sha512_DIGEST_LENGTH| bytes of
// space.
bcm_infallible BCM_sha512_final(uint8_t out[BCM_SHA512_DIGEST_LENGTH],
SHA512_CTX *sha);
// BCM_sha512_transform is a low-level function that performs a single, SHA-512
// block transformation using the state from |sha| and |BCM_sha512_CBLOCK| bytes
// from |block|.
bcm_infallible BCM_sha512_transform(SHA512_CTX *sha,
const uint8_t block[BCM_SHA512_CBLOCK]);
// SHA-512-256
//
// See https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf section 5.3.6
#define BCM_SHA512_256_DIGEST_LENGTH 32
// BCM_sha512_256_init initialises |sha|.
bcm_infallible BCM_sha512_256_init(SHA512_CTX *sha);
// BCM_sha512_256_update adds |len| bytes from |data| to |sha|.
bcm_infallible BCM_sha512_256_update(SHA512_CTX *sha, const void *data,
size_t len);
// BCM_sha512_256_final adds the final padding to |sha| and writes the resulting
// digest to |out|, which must have at least |BCM_sha512_256_DIGEST_LENGTH|
// bytes of space. It may abort on programmer error.
bcm_infallible BCM_sha512_256_final(uint8_t out[BCM_SHA512_256_DIGEST_LENGTH],
SHA512_CTX *sha);
#if defined(__cplusplus)
} // extern C
#endif
@@ -262,6 +262,7 @@ const EVP_AEAD *EVP_AEAD_CTX_aead(const EVP_AEAD_CTX *ctx) { return ctx->aead; }
int EVP_AEAD_CTX_get_iv(const EVP_AEAD_CTX *ctx, const uint8_t **out_iv,
size_t *out_len) {
if (ctx->aead->get_iv == NULL) {
OPENSSL_PUT_ERROR(CIPHER, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
return 0;
}
@@ -26,8 +26,6 @@ extern "C" {
#endif
#define OPENSSL_DH_MAX_MODULUS_BITS 10000
struct dh_st {
BIGNUM *p;
BIGNUM *g;
@@ -60,7 +60,6 @@
#include <string.h>
#include <CCryptoBoringSSL_nid.h>
#include <CCryptoBoringSSL_sha.h>
#include "internal.h"
#include "../delocate.h"
@@ -98,20 +97,20 @@ DEFINE_METHOD_FUNCTION(EVP_MD, EVP_sha1) {
static void sha224_init(EVP_MD_CTX *ctx) {
CHECK(SHA224_Init(ctx->md_data));
BCM_sha224_init(ctx->md_data);
}
static void sha224_update(EVP_MD_CTX *ctx, const void *data, size_t count) {
CHECK(SHA224_Update(ctx->md_data, data, count));
BCM_sha224_update(ctx->md_data, data, count);
}
static void sha224_final(EVP_MD_CTX *ctx, uint8_t *md) {
CHECK(SHA224_Final(md, ctx->md_data));
BCM_sha224_final(md, ctx->md_data);
}
DEFINE_METHOD_FUNCTION(EVP_MD, EVP_sha224) {
out->type = NID_sha224;
out->md_size = SHA224_DIGEST_LENGTH;
out->md_size = BCM_SHA224_DIGEST_LENGTH;
out->flags = 0;
out->init = sha224_init;
out->update = sha224_update;
@@ -122,20 +121,20 @@ DEFINE_METHOD_FUNCTION(EVP_MD, EVP_sha224) {
static void sha256_init(EVP_MD_CTX *ctx) {
CHECK(SHA256_Init(ctx->md_data));
BCM_sha256_init(ctx->md_data);
}
static void sha256_update(EVP_MD_CTX *ctx, const void *data, size_t count) {
CHECK(SHA256_Update(ctx->md_data, data, count));
BCM_sha256_update(ctx->md_data, data, count);
}
static void sha256_final(EVP_MD_CTX *ctx, uint8_t *md) {
CHECK(SHA256_Final(md, ctx->md_data));
BCM_sha256_final(md, ctx->md_data);
}
DEFINE_METHOD_FUNCTION(EVP_MD, EVP_sha256) {
out->type = NID_sha256;
out->md_size = SHA256_DIGEST_LENGTH;
out->md_size = BCM_SHA256_DIGEST_LENGTH;
out->flags = 0;
out->init = sha256_init;
out->update = sha256_update;
@@ -146,20 +145,20 @@ DEFINE_METHOD_FUNCTION(EVP_MD, EVP_sha256) {
static void sha384_init(EVP_MD_CTX *ctx) {
CHECK(SHA384_Init(ctx->md_data));
BCM_sha384_init(ctx->md_data);
}
static void sha384_update(EVP_MD_CTX *ctx, const void *data, size_t count) {
CHECK(SHA384_Update(ctx->md_data, data, count));
BCM_sha384_update(ctx->md_data, data, count);
}
static void sha384_final(EVP_MD_CTX *ctx, uint8_t *md) {
CHECK(SHA384_Final(md, ctx->md_data));
BCM_sha384_final(md, ctx->md_data);
}
DEFINE_METHOD_FUNCTION(EVP_MD, EVP_sha384) {
out->type = NID_sha384;
out->md_size = SHA384_DIGEST_LENGTH;
out->md_size = BCM_SHA384_DIGEST_LENGTH;
out->flags = 0;
out->init = sha384_init;
out->update = sha384_update;
@@ -170,20 +169,20 @@ DEFINE_METHOD_FUNCTION(EVP_MD, EVP_sha384) {
static void sha512_init(EVP_MD_CTX *ctx) {
CHECK(SHA512_Init(ctx->md_data));
BCM_sha512_init(ctx->md_data);
}
static void sha512_update(EVP_MD_CTX *ctx, const void *data, size_t count) {
CHECK(SHA512_Update(ctx->md_data, data, count));
BCM_sha512_update(ctx->md_data, data, count);
}
static void sha512_final(EVP_MD_CTX *ctx, uint8_t *md) {
CHECK(SHA512_Final(md, ctx->md_data));
BCM_sha512_final(md, ctx->md_data);
}
DEFINE_METHOD_FUNCTION(EVP_MD, EVP_sha512) {
out->type = NID_sha512;
out->md_size = SHA512_DIGEST_LENGTH;
out->md_size = BCM_SHA512_DIGEST_LENGTH;
out->flags = 0;
out->init = sha512_init;
out->update = sha512_update;
@@ -194,20 +193,20 @@ DEFINE_METHOD_FUNCTION(EVP_MD, EVP_sha512) {
static void sha512_256_init(EVP_MD_CTX *ctx) {
CHECK(SHA512_256_Init(ctx->md_data));
BCM_sha512_256_init(ctx->md_data);
}
static void sha512_256_update(EVP_MD_CTX *ctx, const void *data, size_t count) {
CHECK(SHA512_256_Update(ctx->md_data, data, count));
BCM_sha512_256_update(ctx->md_data, data, count);
}
static void sha512_256_final(EVP_MD_CTX *ctx, uint8_t *md) {
CHECK(SHA512_256_Final(md, ctx->md_data));
BCM_sha512_256_final(md, ctx->md_data);
}
DEFINE_METHOD_FUNCTION(EVP_MD, EVP_sha512_256) {
out->type = NID_sha512_256;
out->md_size = SHA512_256_DIGEST_LENGTH;
out->md_size = BCM_SHA512_256_DIGEST_LENGTH;
out->flags = 0;
out->init = sha512_256_init;
out->update = sha512_256_update;
@@ -75,7 +75,6 @@
#include <CCryptoBoringSSL_err.h>
#include <CCryptoBoringSSL_ex_data.h>
#include <CCryptoBoringSSL_mem.h>
#include <CCryptoBoringSSL_sha.h>
#include <CCryptoBoringSSL_thread.h>
#include "internal.h"
@@ -346,7 +345,7 @@ int EC_KEY_check_fips(const EC_KEY *key) {
}
if (key->priv_key) {
uint8_t digest[SHA256_DIGEST_LENGTH] = {0};
uint8_t digest[BCM_SHA256_DIGEST_LENGTH] = {0};
uint8_t sig[ECDSA_MAX_FIXED_LEN];
size_t sig_len;
if (!ecdsa_sign_fixed(digest, sizeof(digest), sig, &sig_len, sizeof(sig),
@@ -72,7 +72,6 @@
#include <CCryptoBoringSSL_ec_key.h>
#include <CCryptoBoringSSL_err.h>
#include <CCryptoBoringSSL_mem.h>
#include <CCryptoBoringSSL_sha.h>
#include "../../internal.h"
#include "../ec/internal.h"
@@ -105,18 +104,28 @@ int ECDH_compute_key_fips(uint8_t *out, size_t out_len, const EC_POINT *pub_key,
}
FIPS_service_indicator_lock_state();
SHA256_CTX ctx;
SHA512_CTX ctx_512;
switch (out_len) {
case SHA224_DIGEST_LENGTH:
SHA224(buf, buflen, out);
BCM_sha224_init(&ctx);
BCM_sha224_update(&ctx, buf, buflen);
BCM_sha224_final(out, &ctx);
break;
case SHA256_DIGEST_LENGTH:
SHA256(buf, buflen, out);
BCM_sha256_init(&ctx);
BCM_sha256_update(&ctx, buf, buflen);
BCM_sha256_final(out, &ctx);
break;
case SHA384_DIGEST_LENGTH:
SHA384(buf, buflen, out);
BCM_sha384_init(&ctx_512);
BCM_sha384_update(&ctx_512, buf, buflen);
BCM_sha384_final(out, &ctx_512);
break;
case SHA512_DIGEST_LENGTH:
SHA512(buf, buflen, out);
BCM_sha512_init(&ctx_512);
BCM_sha512_update(&ctx_512, buf, buflen);
BCM_sha512_final(out, &ctx_512);
break;
default:
OPENSSL_PUT_ERROR(ECDH, ECDH_R_UNKNOWN_DIGEST_LENGTH);
@@ -58,7 +58,6 @@
#include <CCryptoBoringSSL_bn.h>
#include <CCryptoBoringSSL_err.h>
#include <CCryptoBoringSSL_mem.h>
#include <CCryptoBoringSSL_sha.h>
#include "../../internal.h"
#include "../bn/internal.h"
@@ -268,17 +267,17 @@ int ecdsa_sign_fixed(const uint8_t *digest, size_t digest_len, uint8_t *sig,
// Pass a SHA512 hash of the private key and digest as additional data
// into the RBG. This is a hardening measure against entropy failure.
static_assert(SHA512_DIGEST_LENGTH >= 32,
static_assert(BCM_SHA512_DIGEST_LENGTH >= 32,
"additional_data is too large for SHA-512");
FIPS_service_indicator_lock_state();
SHA512_CTX sha;
uint8_t additional_data[SHA512_DIGEST_LENGTH];
SHA512_Init(&sha);
SHA512_Update(&sha, priv_key->words, order->width * sizeof(BN_ULONG));
SHA512_Update(&sha, digest, digest_len);
SHA512_Final(additional_data, &sha);
uint8_t additional_data[BCM_SHA512_DIGEST_LENGTH];
BCM_sha512_init(&sha);
BCM_sha512_update(&sha, priv_key->words, order->width * sizeof(BN_ULONG));
BCM_sha512_update(&sha, digest, digest_len);
BCM_sha512_final(additional_data, &sha);
// Cap iterations so callers who supply invalid values as custom groups do not
// infinite loop. This does not impact valid parameters (e.g. those covered by
@@ -275,7 +275,7 @@ static void rand_get_seed(struct rand_thread_state *state,
// rate of failure is small enough not to be a problem in practice.
if (CRYPTO_memcmp(state->last_block, entropy, sizeof(state->last_block)) ==
0) {
fprintf(stderr, "CRNGT failed.\n");
fprintf(CRYPTO_get_stderr(), "CRNGT failed.\n");
BORINGSSL_FIPS_abort();
}
@@ -283,7 +283,7 @@ static void rand_get_seed(struct rand_thread_state *state,
for (size_t i = CRNGT_BLOCK_SIZE; i < entropy_len; i += CRNGT_BLOCK_SIZE) {
if (CRYPTO_memcmp(entropy + i - CRNGT_BLOCK_SIZE, entropy + i,
CRNGT_BLOCK_SIZE) == 0) {
fprintf(stderr, "CRNGT failed.\n");
fprintf(CRYPTO_get_stderr(), "CRNGT failed.\n");
BORINGSSL_FIPS_abort();
}
}
@@ -63,7 +63,6 @@
#include <CCryptoBoringSSL_digest.h>
#include <CCryptoBoringSSL_err.h>
#include <CCryptoBoringSSL_mem.h>
#include <CCryptoBoringSSL_sha.h>
#include "internal.h"
#include "../service_indicator/internal.h"
@@ -68,7 +68,6 @@
#include <CCryptoBoringSSL_md5.h>
#include <CCryptoBoringSSL_mem.h>
#include <CCryptoBoringSSL_nid.h>
#include <CCryptoBoringSSL_sha.h>
#include <CCryptoBoringSSL_thread.h>
#include "../bn/internal.h"
@@ -487,28 +486,28 @@ static const struct pkcs1_sig_prefix kPKCS1SigPrefixes[] = {
},
{
NID_sha224,
SHA224_DIGEST_LENGTH,
BCM_SHA224_DIGEST_LENGTH,
19,
{0x30, 0x2d, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03,
0x04, 0x02, 0x04, 0x05, 0x00, 0x04, 0x1c},
},
{
NID_sha256,
SHA256_DIGEST_LENGTH,
BCM_SHA256_DIGEST_LENGTH,
19,
{0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03,
0x04, 0x02, 0x01, 0x05, 0x00, 0x04, 0x20},
},
{
NID_sha384,
SHA384_DIGEST_LENGTH,
BCM_SHA384_DIGEST_LENGTH,
19,
{0x30, 0x41, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03,
0x04, 0x02, 0x02, 0x05, 0x00, 0x04, 0x30},
},
{
NID_sha512,
SHA512_DIGEST_LENGTH,
BCM_SHA512_DIGEST_LENGTH,
19,
{0x30, 0x51, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x65, 0x03,
0x04, 0x02, 0x03, 0x05, 0x00, 0x04, 0x40},
@@ -79,10 +79,8 @@ int rsa_check_public_key(const RSA *rsa) {
return 0;
}
// TODO(davidben): 16384-bit RSA is huge. Can we bring this down to a limit of
// 8192-bit?
unsigned n_bits = BN_num_bits(rsa->n);
if (n_bits > 16 * 1024) {
if (n_bits > OPENSSL_RSA_MAX_MODULUS_BITS) {
OPENSSL_PUT_ERROR(RSA, RSA_R_MODULUS_TOO_LARGE);
return 0;
}
@@ -32,6 +32,7 @@
#include <CCryptoBoringSSL_rsa.h>
#include <CCryptoBoringSSL_sha.h>
#include "../../bcm_support.h"
#include "../../internal.h"
#include "../delocate.h"
#include "../dh/internal.h"
@@ -53,21 +54,22 @@ int BORINGSSL_self_test(void) {
#else
static void hexdump(const uint8_t *in, size_t len) {
static void hexdump(FILE *out, const uint8_t *in, size_t len) {
for (size_t i = 0; i < len; i++) {
fprintf(stderr, "%02x", in[i]);
fprintf(out, "%02x", in[i]);
}
}
static int check_test(const void *expected, const void *actual,
size_t expected_len, const char *name) {
if (OPENSSL_memcmp(actual, expected, expected_len) != 0) {
fprintf(stderr, "%s failed.\nExpected: ", name);
hexdump(expected, expected_len);
fprintf(stderr, "\nCalculated: ");
hexdump(actual, expected_len);
fprintf(stderr, "\n");
fflush(stderr);
FILE *err = CRYPTO_get_stderr();
fprintf(err, "%s failed.\nExpected: ", name);
hexdump(err, expected, expected_len);
fprintf(err, "\nCalculated: ");
hexdump(err, actual, expected_len);
fprintf(err, "\n");
fflush(err);
return 0;
}
return 1;
@@ -294,7 +296,7 @@ static int boringssl_self_test_rsa(void) {
RSA *const rsa_key = self_test_rsa_key();
if (rsa_key == NULL) {
fprintf(stderr, "RSA key construction failed\n");
fprintf(CRYPTO_get_stderr(), "RSA key construction failed\n");
goto err;
}
// Disable blinding for the power-on tests because it's not needed and
@@ -338,7 +340,7 @@ static int boringssl_self_test_rsa(void) {
output, &sig_len, rsa_key) ||
!check_test(kRSASignSignature, output, sizeof(kRSASignSignature),
"RSA-sign KAT")) {
fprintf(stderr, "RSA signing test failed.\n");
fprintf(CRYPTO_get_stderr(), "RSA signing test failed.\n");
goto err;
}
@@ -376,7 +378,7 @@ static int boringssl_self_test_rsa(void) {
if (!rsa_verify_no_self_test(NID_sha256, kRSAVerifyDigest,
sizeof(kRSAVerifyDigest), kRSAVerifySignature,
sizeof(kRSAVerifySignature), rsa_key)) {
fprintf(stderr, "RSA-verify KAT failed.\n");
fprintf(CRYPTO_get_stderr(), "RSA-verify KAT failed.\n");
goto err;
}
@@ -397,7 +399,7 @@ static int boringssl_self_test_ecc(void) {
ec_key = self_test_ecdsa_key();
if (ec_key == NULL) {
fprintf(stderr, "ECDSA KeyGen failed\n");
fprintf(CRYPTO_get_stderr(), "ECDSA KeyGen failed\n");
goto err;
}
@@ -429,7 +431,7 @@ static int boringssl_self_test_ecc(void) {
sizeof(ecdsa_k)) ||
!check_test(kECDSASignSig, ecdsa_sign_output, sizeof(ecdsa_sign_output),
"ECDSA-sign signature")) {
fprintf(stderr, "ECDSA-sign KAT failed.\n");
fprintf(CRYPTO_get_stderr(), "ECDSA-sign KAT failed.\n");
goto err;
}
@@ -450,7 +452,7 @@ static int boringssl_self_test_ecc(void) {
if (!ecdsa_verify_fixed_no_self_test(
kECDSAVerifyDigest, sizeof(kECDSAVerifyDigest), kECDSAVerifySig,
sizeof(kECDSAVerifySig), ec_key)) {
fprintf(stderr, "ECDSA-verify KAT failed.\n");
fprintf(CRYPTO_get_stderr(), "ECDSA-verify KAT failed.\n");
goto err;
}
@@ -496,7 +498,7 @@ static int boringssl_self_test_ecc(void) {
z_comp_result, sizeof(z_comp_result), NULL) ||
!check_test(kP256PointResult, z_comp_result, sizeof(z_comp_result),
"Z Computation Result")) {
fprintf(stderr, "Z-computation KAT failed.\n");
fprintf(CRYPTO_get_stderr(), "Z-computation KAT failed.\n");
goto err;
}
@@ -575,7 +577,7 @@ static int boringssl_self_test_ffdh(void) {
dh_compute_key_padded_no_self_test(dh_out, ffdhe2048_value, dh) !=
sizeof(dh_out) ||
!check_test(kDHOutput, dh_out, sizeof(dh_out), "FFC DH")) {
fprintf(stderr, "FFDH failed.\n");
fprintf(CRYPTO_get_stderr(), "FFDH failed.\n");
goto err;
}
@@ -723,7 +725,7 @@ static int boringssl_self_test_fast(void) {
};
memcpy(aes_iv, kAESIV, sizeof(kAESIV));
if (AES_set_encrypt_key(kAESKey, 8 * sizeof(kAESKey), &aes_key) != 0) {
fprintf(stderr, "AES_set_encrypt_key failed.\n");
fprintf(CRYPTO_get_stderr(), "AES_set_encrypt_key failed.\n");
goto err;
}
AES_cbc_encrypt(kAESCBCEncPlaintext, output, sizeof(kAESCBCEncPlaintext),
@@ -746,7 +748,7 @@ static int boringssl_self_test_fast(void) {
};
memcpy(aes_iv, kAESIV, sizeof(kAESIV));
if (AES_set_decrypt_key(kAESKey, 8 * sizeof(kAESKey), &aes_key) != 0) {
fprintf(stderr, "AES_set_decrypt_key failed.\n");
fprintf(CRYPTO_get_stderr(), "AES_set_decrypt_key failed.\n");
goto err;
}
AES_cbc_encrypt(kAESCBCDecCiphertext, output, sizeof(kAESCBCDecCiphertext),
@@ -761,7 +763,7 @@ static int boringssl_self_test_fast(void) {
OPENSSL_memset(nonce, 0, sizeof(nonce));
if (!EVP_AEAD_CTX_init(&aead_ctx, EVP_aead_aes_128_gcm(), kAESKey,
sizeof(kAESKey), 0, NULL)) {
fprintf(stderr, "EVP_AEAD_CTX_init for AES-128-GCM failed.\n");
fprintf(CRYPTO_get_stderr(), "EVP_AEAD_CTX_init for AES-128-GCM failed.\n");
goto err;
}
@@ -783,7 +785,7 @@ static int boringssl_self_test_fast(void) {
0) ||
!check_test(kAESGCMCiphertext, output, sizeof(kAESGCMCiphertext),
"AES-GCM-encrypt KAT")) {
fprintf(stderr, "EVP_AEAD_CTX_seal for AES-128-GCM failed.\n");
fprintf(CRYPTO_get_stderr(), "EVP_AEAD_CTX_seal for AES-128-GCM failed.\n");
goto err;
}
@@ -806,7 +808,7 @@ static int boringssl_self_test_fast(void) {
NULL, 0) ||
!check_test(kAESGCMDecPlaintext, output, sizeof(kAESGCMDecPlaintext),
"AES-GCM-decrypt KAT")) {
fprintf(stderr,
fprintf(CRYPTO_get_stderr(),
"AES-GCM-decrypt KAT failed because EVP_AEAD_CTX_open failed.\n");
goto err;
}
@@ -875,7 +877,7 @@ static int boringssl_self_test_fast(void) {
sizeof(kDRBGAD)) ||
!check_test(kDRBGReseedOutput, output, sizeof(kDRBGReseedOutput),
"DRBG-reseed KAT")) {
fprintf(stderr, "CTR-DRBG failed.\n");
fprintf(CRYPTO_get_stderr(), "CTR-DRBG failed.\n");
goto err;
}
CTR_DRBG_clear(&drbg);
@@ -914,7 +916,7 @@ static int boringssl_self_test_fast(void) {
kTLSSeed2, sizeof(kTLSSeed2)) ||
!check_test(kTLS10Output, tls10_output, sizeof(kTLS10Output),
"TLS10-KDF KAT")) {
fprintf(stderr, "TLS KDF failed.\n");
fprintf(CRYPTO_get_stderr(), "TLS KDF failed.\n");
goto err;
}
@@ -935,7 +937,7 @@ static int boringssl_self_test_fast(void) {
kTLSSeed2, sizeof(kTLSSeed2)) ||
!check_test(kTLS12Output, tls12_output, sizeof(kTLS12Output),
"TLS12-KDF KAT")) {
fprintf(stderr, "TLS KDF failed.\n");
fprintf(CRYPTO_get_stderr(), "TLS KDF failed.\n");
goto err;
}
@@ -975,7 +977,7 @@ static int boringssl_self_test_fast(void) {
!check_test(kTLS13ExpandLabelOutput, tls13_expand_label_output,
sizeof(kTLS13ExpandLabelOutput),
"CRYPTO_tls13_hkdf_expand_label")) {
fprintf(stderr, "TLS13-KDF failed.\n");
fprintf(CRYPTO_get_stderr(), "TLS13-KDF failed.\n");
goto err;
}
@@ -1005,7 +1007,7 @@ static int boringssl_self_test_fast(void) {
sizeof(kHKDFSecret), kHKDFSalt, sizeof(kHKDFSalt), kHKDFInfo,
sizeof(kHKDFInfo)) ||
!check_test(kHKDFOutput, hkdf_output, sizeof(kHKDFOutput), "HKDF")) {
fprintf(stderr, "HKDF failed.\n");
fprintf(CRYPTO_get_stderr(), "HKDF failed.\n");
goto err;
}
@@ -54,19 +54,18 @@
* copied and put under another distribution licence
* [including the GNU Public Licence.] */
#include <CCryptoBoringSSL_sha.h>
#include <string.h>
#include <CCryptoBoringSSL_mem.h>
#include "../../internal.h"
#include "../bcm_interface.h"
#include "../digest/md32_common.h"
#include "../service_indicator/internal.h"
#include "internal.h"
int SHA224_Init(SHA256_CTX *sha) {
bcm_infallible BCM_sha224_init(SHA256_CTX *sha) {
OPENSSL_memset(sha, 0, sizeof(SHA256_CTX));
sha->h[0] = 0xc1059ed8UL;
sha->h[1] = 0x367cd507UL;
@@ -76,11 +75,11 @@ int SHA224_Init(SHA256_CTX *sha) {
sha->h[5] = 0x68581511UL;
sha->h[6] = 0x64f98fa7UL;
sha->h[7] = 0xbefa4fa4UL;
sha->md_len = SHA224_DIGEST_LENGTH;
return 1;
sha->md_len = BCM_SHA224_DIGEST_LENGTH;
return bcm_infallible_approved;
}
int SHA256_Init(SHA256_CTX *sha) {
bcm_infallible BCM_sha256_init(SHA256_CTX *sha) {
OPENSSL_memset(sha, 0, sizeof(SHA256_CTX));
sha->h[0] = 0x6a09e667UL;
sha->h[1] = 0xbb67ae85UL;
@@ -90,28 +89,8 @@ int SHA256_Init(SHA256_CTX *sha) {
sha->h[5] = 0x9b05688cUL;
sha->h[6] = 0x1f83d9abUL;
sha->h[7] = 0x5be0cd19UL;
sha->md_len = SHA256_DIGEST_LENGTH;
return 1;
}
uint8_t *SHA224(const uint8_t *data, size_t len,
uint8_t out[SHA224_DIGEST_LENGTH]) {
SHA256_CTX ctx;
SHA224_Init(&ctx);
SHA224_Update(&ctx, data, len);
SHA224_Final(out, &ctx);
OPENSSL_cleanse(&ctx, sizeof(ctx));
return out;
}
uint8_t *SHA256(const uint8_t *data, size_t len,
uint8_t out[SHA256_DIGEST_LENGTH]) {
SHA256_CTX ctx;
SHA256_Init(&ctx);
SHA256_Update(&ctx, data, len);
SHA256_Final(out, &ctx);
OPENSSL_cleanse(&ctx, sizeof(ctx));
return out;
sha->md_len = BCM_SHA256_DIGEST_LENGTH;
return bcm_infallible_approved;
}
#if !defined(SHA256_ASM)
@@ -119,31 +98,28 @@ static void sha256_block_data_order(uint32_t state[8], const uint8_t *in,
size_t num);
#endif
void SHA256_Transform(SHA256_CTX *c, const uint8_t data[SHA256_CBLOCK]) {
bcm_infallible BCM_sha256_transform(SHA256_CTX *c,
const uint8_t data[BCM_SHA256_CBLOCK]) {
sha256_block_data_order(c->h, data, 1);
return bcm_infallible_approved;
}
int SHA256_Update(SHA256_CTX *c, const void *data, size_t len) {
crypto_md32_update(&sha256_block_data_order, c->h, c->data, SHA256_CBLOCK,
bcm_infallible BCM_sha256_update(SHA256_CTX *c, const void *data, size_t len) {
crypto_md32_update(&sha256_block_data_order, c->h, c->data, BCM_SHA256_CBLOCK,
&c->num, &c->Nh, &c->Nl, data, len);
return 1;
return bcm_infallible_approved;
}
int SHA224_Update(SHA256_CTX *ctx, const void *data, size_t len) {
return SHA256_Update(ctx, data, len);
bcm_infallible BCM_sha224_update(SHA256_CTX *ctx, const void *data,
size_t len) {
return BCM_sha256_update(ctx, data, len);
}
static int sha256_final_impl(uint8_t *out, size_t md_len, SHA256_CTX *c) {
crypto_md32_final(&sha256_block_data_order, c->h, c->data, SHA256_CBLOCK,
static void sha256_final_impl(uint8_t *out, size_t md_len, SHA256_CTX *c) {
crypto_md32_final(&sha256_block_data_order, c->h, c->data, BCM_SHA256_CBLOCK,
&c->num, c->Nh, c->Nl, /*is_big_endian=*/1);
// TODO(davidben): This overflow check one of the few places a low-level hash
// 'final' function can fail. SHA-512 does not have a corresponding check.
// These functions already misbehave if the caller arbitrarily mutates |c|, so
// can we assume one of |SHA256_Init| or |SHA224_Init| was used?
if (md_len > SHA256_DIGEST_LENGTH) {
return 0;
}
BSSL_CHECK(md_len <= BCM_SHA256_DIGEST_LENGTH);
assert(md_len % 4 == 0);
const size_t out_words = md_len / 4;
@@ -153,23 +129,26 @@ static int sha256_final_impl(uint8_t *out, size_t md_len, SHA256_CTX *c) {
}
FIPS_service_indicator_update_state();
return 1;
}
int SHA256_Final(uint8_t out[SHA256_DIGEST_LENGTH], SHA256_CTX *c) {
// Ideally we would assert |sha->md_len| is |SHA256_DIGEST_LENGTH| to match
// the size hint, but calling code often pairs |SHA224_Init| with
bcm_infallible BCM_sha256_final(uint8_t out[BCM_SHA256_DIGEST_LENGTH],
SHA256_CTX *c) {
// Ideally we would assert |sha->md_len| is |BCM_SHA256_DIGEST_LENGTH| to
// match the size hint, but calling code often pairs |SHA224_Init| with
// |SHA256_Final| and expects |sha->md_len| to carry the size over.
//
// TODO(davidben): Add an assert and fix code to match them up.
return sha256_final_impl(out, c->md_len, c);
sha256_final_impl(out, c->md_len, c);
return bcm_infallible_approved;
}
int SHA224_Final(uint8_t out[SHA224_DIGEST_LENGTH], SHA256_CTX *ctx) {
bcm_infallible BCM_sha224_final(uint8_t out[BCM_SHA224_DIGEST_LENGTH],
SHA256_CTX *ctx) {
// This function must be paired with |SHA224_Init|, which sets |ctx->md_len|
// to |SHA224_DIGEST_LENGTH|.
assert(ctx->md_len == SHA224_DIGEST_LENGTH);
return sha256_final_impl(out, SHA224_DIGEST_LENGTH, ctx);
// to |BCM_SHA224_DIGEST_LENGTH|.
assert(ctx->md_len == BCM_SHA224_DIGEST_LENGTH);
sha256_final_impl(out, BCM_SHA224_DIGEST_LENGTH, ctx);
return bcm_infallible_approved;
}
#if !defined(SHA256_ASM)
@@ -344,9 +323,11 @@ static void sha256_block_data_order(uint32_t state[8], const uint8_t *data,
#endif // !defined(SHA256_ASM)
void SHA256_TransformBlocks(uint32_t state[8], const uint8_t *data,
size_t num_blocks) {
bcm_infallible BCM_sha256_transform_blocks(uint32_t state[8],
const uint8_t *data,
size_t num_blocks) {
sha256_block_data_order(state, data, num_blocks);
return bcm_infallible_approved;
}
#undef Sigma0
@@ -54,13 +54,12 @@
* copied and put under another distribution licence
* [including the GNU Public Licence.] */
#include <CCryptoBoringSSL_sha.h>
#include <string.h>
#include <CCryptoBoringSSL_mem.h>
#include "../../internal.h"
#include "../bcm_interface.h"
#include "../service_indicator/internal.h"
#include "internal.h"
@@ -71,9 +70,9 @@
// this writing, so there is no need for a common collector/padding
// implementation yet.
static int sha512_final_impl(uint8_t *out, size_t md_len, SHA512_CTX *sha);
static void sha512_final_impl(uint8_t *out, size_t md_len, SHA512_CTX *sha);
int SHA384_Init(SHA512_CTX *sha) {
bcm_infallible BCM_sha384_init(SHA512_CTX *sha) {
sha->h[0] = UINT64_C(0xcbbb9d5dc1059ed8);
sha->h[1] = UINT64_C(0x629a292a367cd507);
sha->h[2] = UINT64_C(0x9159015a3070dd17);
@@ -86,12 +85,12 @@ int SHA384_Init(SHA512_CTX *sha) {
sha->Nl = 0;
sha->Nh = 0;
sha->num = 0;
sha->md_len = SHA384_DIGEST_LENGTH;
return 1;
sha->md_len = BCM_SHA384_DIGEST_LENGTH;
return bcm_infallible_approved;
}
int SHA512_Init(SHA512_CTX *sha) {
bcm_infallible BCM_sha512_init(SHA512_CTX *sha) {
sha->h[0] = UINT64_C(0x6a09e667f3bcc908);
sha->h[1] = UINT64_C(0xbb67ae8584caa73b);
sha->h[2] = UINT64_C(0x3c6ef372fe94f82b);
@@ -104,11 +103,11 @@ int SHA512_Init(SHA512_CTX *sha) {
sha->Nl = 0;
sha->Nh = 0;
sha->num = 0;
sha->md_len = SHA512_DIGEST_LENGTH;
return 1;
sha->md_len = BCM_SHA512_DIGEST_LENGTH;
return bcm_infallible_approved;
}
int SHA512_256_Init(SHA512_CTX *sha) {
bcm_infallible BCM_sha512_256_init(SHA512_CTX *sha) {
sha->h[0] = UINT64_C(0x22312194fc2bf72c);
sha->h[1] = UINT64_C(0x9f555fa3c84c64c2);
sha->h[2] = UINT64_C(0x2393b86b6f53b151);
@@ -121,38 +120,8 @@ int SHA512_256_Init(SHA512_CTX *sha) {
sha->Nl = 0;
sha->Nh = 0;
sha->num = 0;
sha->md_len = SHA512_256_DIGEST_LENGTH;
return 1;
}
uint8_t *SHA384(const uint8_t *data, size_t len,
uint8_t out[SHA384_DIGEST_LENGTH]) {
SHA512_CTX ctx;
SHA384_Init(&ctx);
SHA384_Update(&ctx, data, len);
SHA384_Final(out, &ctx);
OPENSSL_cleanse(&ctx, sizeof(ctx));
return out;
}
uint8_t *SHA512(const uint8_t *data, size_t len,
uint8_t out[SHA512_DIGEST_LENGTH]) {
SHA512_CTX ctx;
SHA512_Init(&ctx);
SHA512_Update(&ctx, data, len);
SHA512_Final(out, &ctx);
OPENSSL_cleanse(&ctx, sizeof(ctx));
return out;
}
uint8_t *SHA512_256(const uint8_t *data, size_t len,
uint8_t out[SHA512_256_DIGEST_LENGTH]) {
SHA512_CTX ctx;
SHA512_256_Init(&ctx);
SHA512_256_Update(&ctx, data, len);
SHA512_256_Final(out, &ctx);
OPENSSL_cleanse(&ctx, sizeof(ctx));
return out;
sha->md_len = BCM_SHA512_256_DIGEST_LENGTH;
return bcm_infallible_approved;
}
#if !defined(SHA512_ASM)
@@ -161,39 +130,48 @@ static void sha512_block_data_order(uint64_t state[8], const uint8_t *in,
#endif
int SHA384_Final(uint8_t out[SHA384_DIGEST_LENGTH], SHA512_CTX *sha) {
// This function must be paired with |SHA384_Init|, which sets |sha->md_len|
// to |SHA384_DIGEST_LENGTH|.
assert(sha->md_len == SHA384_DIGEST_LENGTH);
return sha512_final_impl(out, SHA384_DIGEST_LENGTH, sha);
bcm_infallible BCM_sha384_final(uint8_t out[BCM_SHA384_DIGEST_LENGTH],
SHA512_CTX *sha) {
// This function must be paired with |BCM_sha384_init|, which sets
// |sha->md_len| to |BCM_SHA384_DIGEST_LENGTH|.
assert(sha->md_len == BCM_SHA384_DIGEST_LENGTH);
sha512_final_impl(out, BCM_SHA384_DIGEST_LENGTH, sha);
return bcm_infallible_approved;
}
int SHA384_Update(SHA512_CTX *sha, const void *data, size_t len) {
return SHA512_Update(sha, data, len);
bcm_infallible BCM_sha384_update(SHA512_CTX *sha, const void *data,
size_t len) {
return BCM_sha512_update(sha, data, len);
}
int SHA512_256_Update(SHA512_CTX *sha, const void *data, size_t len) {
return SHA512_Update(sha, data, len);
bcm_infallible BCM_sha512_256_update(SHA512_CTX *sha, const void *data,
size_t len) {
return BCM_sha512_update(sha, data, len);
}
int SHA512_256_Final(uint8_t out[SHA512_256_DIGEST_LENGTH], SHA512_CTX *sha) {
// This function must be paired with |SHA512_256_Init|, which sets
// |sha->md_len| to |SHA512_256_DIGEST_LENGTH|.
assert(sha->md_len == SHA512_256_DIGEST_LENGTH);
return sha512_final_impl(out, SHA512_256_DIGEST_LENGTH, sha);
bcm_infallible BCM_sha512_256_final(uint8_t out[BCM_SHA512_256_DIGEST_LENGTH],
SHA512_CTX *sha) {
// This function must be paired with |BCM_sha512_256_init|, which sets
// |sha->md_len| to |BCM_SHA512_256_DIGEST_LENGTH|.
assert(sha->md_len == BCM_SHA512_256_DIGEST_LENGTH);
sha512_final_impl(out, BCM_SHA512_256_DIGEST_LENGTH, sha);
return bcm_infallible_approved;
}
void SHA512_Transform(SHA512_CTX *c, const uint8_t block[SHA512_CBLOCK]) {
bcm_infallible BCM_sha512_transform(SHA512_CTX *c,
const uint8_t block[SHA512_CBLOCK]) {
sha512_block_data_order(c->h, block, 1);
return bcm_infallible_approved;
}
int SHA512_Update(SHA512_CTX *c, const void *in_data, size_t len) {
bcm_infallible BCM_sha512_update(SHA512_CTX *c, const void *in_data,
size_t len) {
uint64_t l;
uint8_t *p = c->p;
const uint8_t *data = in_data;
if (len == 0) {
return 1;
return bcm_infallible_approved;
}
l = (c->Nl + (((uint64_t)len) << 3)) & UINT64_C(0xffffffffffffffff);
@@ -232,19 +210,21 @@ int SHA512_Update(SHA512_CTX *c, const void *in_data, size_t len) {
c->num = (int)len;
}
return 1;
return bcm_infallible_approved;
}
int SHA512_Final(uint8_t out[SHA512_DIGEST_LENGTH], SHA512_CTX *sha) {
// Ideally we would assert |sha->md_len| is |SHA512_DIGEST_LENGTH| to match
// the size hint, but calling code often pairs |SHA384_Init| with
// |SHA512_Final| and expects |sha->md_len| to carry the size over.
bcm_infallible BCM_sha512_final(uint8_t out[BCM_SHA512_DIGEST_LENGTH],
SHA512_CTX *sha) {
// Ideally we would assert |sha->md_len| is |BCM_SHA512_DIGEST_LENGTH| to
// match the size hint, but calling code often pairs |BCM_sha384_init| with
// |BCM_sha512_final| and expects |sha->md_len| to carry the size over.
//
// TODO(davidben): Add an assert and fix code to match them up.
return sha512_final_impl(out, sha->md_len, sha);
sha512_final_impl(out, sha->md_len, sha);
return bcm_infallible_approved;
}
static int sha512_final_impl(uint8_t *out, size_t md_len, SHA512_CTX *sha) {
static void sha512_final_impl(uint8_t *out, size_t md_len, SHA512_CTX *sha) {
uint8_t *p = sha->p;
size_t n = sha->num;
@@ -262,12 +242,6 @@ static int sha512_final_impl(uint8_t *out, size_t md_len, SHA512_CTX *sha) {
sha512_block_data_order(sha->h, p, 1);
if (out == NULL) {
// TODO(davidben): This NULL check is absent in other low-level hash 'final'
// functions and is one of the few places one can fail.
return 0;
}
assert(md_len % 8 == 0);
const size_t out_words = md_len / 8;
for (size_t i = 0; i < out_words; i++) {
@@ -276,7 +250,6 @@ static int sha512_final_impl(uint8_t *out, size_t md_len, SHA512_CTX *sha) {
}
FIPS_service_indicator_update_state();
return 1;
}
#if !defined(SHA512_ASM)
@@ -423,7 +396,6 @@ static void sha512_block_data_order_nohw(uint64_t state[8], const uint8_t *in,
int i;
while (num--) {
a = state[0];
b = state[1];
c = state[2];
@@ -1093,6 +1093,17 @@ static inline void *OPENSSL_memset(void *dst, int c, size_t n) {
// endianness. They use |memcpy|, and so avoid alignment or strict aliasing
// requirements on the input and output pointers.
static inline uint16_t CRYPTO_load_u16_be(const void *in) {
uint16_t v;
OPENSSL_memcpy(&v, in, sizeof(v));
return CRYPTO_bswap2(v);
}
static inline void CRYPTO_store_u16_be(void *out, uint16_t v) {
v = CRYPTO_bswap2(v);
OPENSSL_memcpy(out, &v, sizeof(v));
}
static inline uint32_t CRYPTO_load_u32_le(const void *in) {
uint32_t v;
OPENSSL_memcpy(&v, in, sizeof(v));
@@ -31,11 +31,11 @@
typedef __m128i xmmi;
static const alignas(16) uint32_t poly1305_x64_sse2_message_mask[4] = {
alignas(16) static const uint32_t poly1305_x64_sse2_message_mask[4] = {
(1 << 26) - 1, 0, (1 << 26) - 1, 0};
static const alignas(16) uint32_t poly1305_x64_sse2_5[4] = {5, 0, 5, 0};
static const alignas(16) uint32_t poly1305_x64_sse2_1shl128[4] = {
(1 << 24), 0, (1 << 24), 0};
alignas(16) static const uint32_t poly1305_x64_sse2_5[4] = {5, 0, 5, 0};
alignas(16) static const uint32_t poly1305_x64_sse2_1shl128[4] = {(1 << 24), 0,
(1 << 24), 0};
static inline uint128_t add128(uint128_t a, uint128_t b) { return a + b; }
@@ -136,7 +136,8 @@ void CRYPTO_poly1305_init(poly1305_state *state, const uint8_t key[32]) {
static void poly1305_first_block(poly1305_state_internal *st,
const uint8_t *m) {
const xmmi MMASK = _mm_load_si128((const xmmi *)poly1305_x64_sse2_message_mask);
const xmmi MMASK =
_mm_load_si128((const xmmi *)poly1305_x64_sse2_message_mask);
const xmmi FIVE = _mm_load_si128((const xmmi *)poly1305_x64_sse2_5);
const xmmi HIBIT = _mm_load_si128((const xmmi *)poly1305_x64_sse2_1shl128);
xmmi T5, T6;
@@ -181,7 +182,7 @@ static void poly1305_first_block(poly1305_state_internal *st,
r20 = r20 & 0xfffffffffff;
r21 += c;
p->R20.v = _mm_shuffle_epi32(_mm_cvtsi32_si128((uint32_t)(r20)&0x3ffffff),
p->R20.v = _mm_shuffle_epi32(_mm_cvtsi32_si128((uint32_t)(r20) & 0x3ffffff),
_MM_SHUFFLE(1, 0, 1, 0));
p->R21.v = _mm_shuffle_epi32(
_mm_cvtsi32_si128((uint32_t)((r20 >> 26) | (r21 << 18)) & 0x3ffffff),
@@ -229,7 +230,8 @@ static void poly1305_first_block(poly1305_state_internal *st,
static void poly1305_blocks(poly1305_state_internal *st, const uint8_t *m,
size_t bytes) {
const xmmi MMASK = _mm_load_si128((const xmmi *)poly1305_x64_sse2_message_mask);
const xmmi MMASK =
_mm_load_si128((const xmmi *)poly1305_x64_sse2_message_mask);
const xmmi FIVE = _mm_load_si128((const xmmi *)poly1305_x64_sse2_5);
const xmmi HIBIT = _mm_load_si128((const xmmi *)poly1305_x64_sse2_1shl128);
@@ -419,7 +421,8 @@ static void poly1305_blocks(poly1305_state_internal *st, const uint8_t *m,
static size_t poly1305_combine(poly1305_state_internal *st, const uint8_t *m,
size_t bytes) {
const xmmi MMASK = _mm_load_si128((const xmmi *)poly1305_x64_sse2_message_mask);
const xmmi MMASK =
_mm_load_si128((const xmmi *)poly1305_x64_sse2_message_mask);
const xmmi HIBIT = _mm_load_si128((const xmmi *)poly1305_x64_sse2_1shl128);
const xmmi FIVE = _mm_load_si128((const xmmi *)poly1305_x64_sse2_5);
@@ -547,7 +550,7 @@ static size_t poly1305_combine(poly1305_state_internal *st, const uint8_t *m,
r1 = ((uint64_t)p->R21.d[3] << 32) | (uint64_t)p->R21.d[1];
r2 = ((uint64_t)p->R22.d[3] << 32) | (uint64_t)p->R22.d[1];
p->R20.d[2] = (uint32_t)(r0)&0x3ffffff;
p->R20.d[2] = (uint32_t)(r0) & 0x3ffffff;
p->R21.d[2] = (uint32_t)((r0 >> 26) | (r1 << 18)) & 0x3ffffff;
p->R22.d[2] = (uint32_t)((r1 >> 8)) & 0x3ffffff;
p->R23.d[2] = (uint32_t)((r1 >> 34) | (r2 << 10)) & 0x3ffffff;
@@ -838,7 +841,7 @@ poly1305_donna_finish:
c = (h1 >> 44);
h1 &= 0xfffffffffff;
t1 = (t1 >> 24);
h2 += (t1)+c;
h2 += (t1) + c;
CRYPTO_store_u64_le(mac + 0, ((h0) | (h1 << 44)));
CRYPTO_store_u64_le(mac + 8, ((h1 >> 20) | (h2 << 24)));
@@ -0,0 +1,17 @@
/* Copyright (c) 2024, Google Inc.
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
#include <CCryptoBoringSSL_rsa.h>
void RSA_blinding_off(RSA *rsa) {}
@@ -0,0 +1,87 @@
/* Copyright (c) 2024, Google Inc.
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
#include <CCryptoBoringSSL_sha.h>
#include <CCryptoBoringSSL_mem.h>
#include "../fipsmodule/bcm_interface.h"
int SHA224_Init(SHA256_CTX *sha) {
BCM_sha224_init(sha);
return 1;
}
int SHA224_Update(SHA256_CTX *sha, const void *data, size_t len) {
BCM_sha224_update(sha, data, len);
return 1;
}
int SHA224_Final(uint8_t out[SHA224_DIGEST_LENGTH], SHA256_CTX *sha) {
BCM_sha224_final(out, sha);
return 1;
}
uint8_t *SHA224(const uint8_t *data, size_t len,
uint8_t out[SHA224_DIGEST_LENGTH]) {
SHA256_CTX ctx;
BCM_sha224_init(&ctx);
BCM_sha224_update(&ctx, data, len);
BCM_sha224_final(out, &ctx);
OPENSSL_cleanse(&ctx, sizeof(ctx));
return out;
}
int SHA256_Init(SHA256_CTX *sha) {
BCM_sha256_init(sha);
return 1;
}
int SHA256_Update(SHA256_CTX *sha, const void *data, size_t len) {
BCM_sha256_update(sha, data, len);
return 1;
}
int SHA256_Final(uint8_t out[SHA256_DIGEST_LENGTH], SHA256_CTX *sha) {
// TODO(bbe): This overflow check one of the few places a low-level hash
// 'final' function can fail. SHA-512 does not have a corresponding check.
// The BCM function is infallible and will abort if this is done incorrectly.
// we should verify nothing crashes with this removed and eliminate the 0
// return.
if (sha->md_len > SHA256_DIGEST_LENGTH) {
return 0;
}
BCM_sha256_final(out, sha);
return 1;
}
uint8_t *SHA256(const uint8_t *data, size_t len,
uint8_t out[SHA256_DIGEST_LENGTH]) {
SHA256_CTX ctx;
BCM_sha256_init(&ctx);
BCM_sha256_update(&ctx, data, len);
BCM_sha256_final(out, &ctx);
OPENSSL_cleanse(&ctx, sizeof(ctx));
return out;
}
void SHA256_Transform(SHA256_CTX *sha, const uint8_t block[SHA256_CBLOCK]) {
BCM_sha256_transform(sha, block);
}
void SHA256_TransformBlocks(uint32_t state[8], const uint8_t *data,
size_t num_blocks) {
BCM_sha256_transform_blocks(state, data, num_blocks);
}
@@ -0,0 +1,104 @@
/* Copyright (c) 2024, Google Inc.
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
#include <CCryptoBoringSSL_sha.h>
#include <CCryptoBoringSSL_mem.h>
#include "../fipsmodule/bcm_interface.h"
int SHA384_Init(SHA512_CTX *sha) {
BCM_sha384_init(sha);
return 1;
}
int SHA384_Update(SHA512_CTX *sha, const void *data, size_t len) {
BCM_sha384_update(sha, data, len);
return 1;
}
int SHA384_Final(uint8_t out[SHA384_DIGEST_LENGTH], SHA512_CTX *sha) {
BCM_sha384_final(out, sha);
return 1;
}
uint8_t *SHA384(const uint8_t *data, size_t len,
uint8_t out[SHA384_DIGEST_LENGTH]) {
SHA512_CTX ctx;
BCM_sha384_init(&ctx);
BCM_sha384_update(&ctx, data, len);
BCM_sha384_final(out, &ctx);
OPENSSL_cleanse(&ctx, sizeof(ctx));
return out;
}
int SHA512_256_Init(SHA512_CTX *sha) {
BCM_sha512_256_init(sha);
return 1;
}
int SHA512_256_Update(SHA512_CTX *sha, const void *data, size_t len) {
BCM_sha512_256_update(sha, data, len);
return 1;
}
int SHA512_256_Final(uint8_t out[SHA512_256_DIGEST_LENGTH], SHA512_CTX *sha) {
BCM_sha512_256_final(out, sha);
return 1;
}
uint8_t *SHA512_256(const uint8_t *data, size_t len,
uint8_t out[SHA512_256_DIGEST_LENGTH]) {
SHA512_CTX ctx;
BCM_sha512_256_init(&ctx);
BCM_sha512_256_update(&ctx, data, len);
BCM_sha512_256_final(out, &ctx);
OPENSSL_cleanse(&ctx, sizeof(ctx));
return out;
}
int SHA512_Init(SHA512_CTX *sha) {
BCM_sha512_init(sha);
return 1;
}
int SHA512_Update(SHA512_CTX *sha, const void *data, size_t len) {
BCM_sha512_update(sha, data, len);
return 1;
}
int SHA512_Final(uint8_t out[SHA512_DIGEST_LENGTH], SHA512_CTX *sha) {
// Historically this function retured failure if passed NULL, even
// though other final functions do not.
if (out == NULL) {
return 0;
}
BCM_sha512_final(out, sha);
return 1;
}
uint8_t *SHA512(const uint8_t *data, size_t len,
uint8_t out[SHA512_DIGEST_LENGTH]) {
SHA512_CTX ctx;
BCM_sha512_init(&ctx);
BCM_sha512_update(&ctx, data, len);
BCM_sha512_final(out, &ctx);
OPENSSL_cleanse(&ctx, sizeof(ctx));
return out;
}
void SHA512_Transform(SHA512_CTX *sha, const uint8_t block[SHA512_CBLOCK]) {
BCM_sha512_transform(sha, block);
}
@@ -0,0 +1,123 @@
/* Copyright (c) 2024, Google LLC
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
#ifndef OPENSSL_HEADER_CRYPTO_SLHDSA_ADDRESS_H
#define OPENSSL_HEADER_CRYPTO_SLHDSA_ADDRESS_H
#include <CCryptoBoringSSL_mem.h>
#include "../internal.h"
#if defined(__cplusplus)
extern "C" {
#endif
// Offsets of various fields in the address structure for SLH-DSA-SHA2-128s.
// The byte used to specify the Merkle tree layer.
#define SLHDSA_SHA2_128S_OFFSET_LAYER 0
// The start of the 8 byte field used to specify the tree.
#define SLHDSA_SHA2_128S_OFFSET_TREE 1
// The byte used to specify the hash type (reason).
#define SLHDSA_SHA2_128S_OFFSET_TYPE 9
// The high byte used to specify the key pair (which one-time signature).
#define SLHDSA_SHA2_128S_OFFSET_KP_ADDR2 12
// The low byte used to specific the key pair.
#define SLHDSA_SHA2_128S_OFFSET_KP_ADDR1 13
// The byte used to specify the chain address (which Winternitz chain).
#define SLHDSA_SHA2_128S_OFFSET_CHAIN_ADDR 17
// The byte used to specify the hash address (where in the Winternitz chain).
#define SLHDSA_SHA2_128S_OFFSET_HASH_ADDR 21
// The byte used to specify the height of this node in the FORS or Merkle tree.
#define SLHDSA_SHA2_128S_OFFSET_TREE_HGT 17
// The start of the 4 byte field used to specify the node in the FORS or Merkle
// tree.
#define SLHDSA_SHA2_128S_OFFSET_TREE_INDEX 18
OPENSSL_INLINE void slhdsa_set_chain_addr(uint8_t addr[32], uint32_t chain) {
addr[SLHDSA_SHA2_128S_OFFSET_CHAIN_ADDR] = (uint8_t)chain;
}
OPENSSL_INLINE void slhdsa_set_hash_addr(uint8_t addr[32], uint32_t hash) {
addr[SLHDSA_SHA2_128S_OFFSET_HASH_ADDR] = (uint8_t)hash;
}
OPENSSL_INLINE void slhdsa_set_keypair_addr(uint8_t addr[32],
uint32_t keypair) {
addr[SLHDSA_SHA2_128S_OFFSET_KP_ADDR2] = (uint8_t)(keypair >> 8);
addr[SLHDSA_SHA2_128S_OFFSET_KP_ADDR1] = (uint8_t)keypair;
}
OPENSSL_INLINE void slhdsa_copy_keypair_addr(uint8_t out[32],
const uint8_t in[32]) {
OPENSSL_memcpy(out, in, SLHDSA_SHA2_128S_OFFSET_TREE + 8);
out[SLHDSA_SHA2_128S_OFFSET_KP_ADDR2] = in[SLHDSA_SHA2_128S_OFFSET_KP_ADDR2];
out[SLHDSA_SHA2_128S_OFFSET_KP_ADDR1] = in[SLHDSA_SHA2_128S_OFFSET_KP_ADDR1];
}
OPENSSL_INLINE void slhdsa_set_layer_addr(uint8_t addr[32], uint32_t layer) {
addr[SLHDSA_SHA2_128S_OFFSET_LAYER] = (uint8_t)layer;
}
OPENSSL_INLINE void slhdsa_set_tree_addr(uint8_t addr[32], uint64_t tree) {
CRYPTO_store_u64_be(&addr[SLHDSA_SHA2_128S_OFFSET_TREE], tree);
}
#define SLHDSA_SHA2_128S_ADDR_TYPE_WOTS 0
#define SLHDSA_SHA2_128S_ADDR_TYPE_WOTSPK 1
#define SLHDSA_SHA2_128S_ADDR_TYPE_HASHTREE 2
#define SLHDSA_SHA2_128S_ADDR_TYPE_FORSTREE 3
#define SLHDSA_SHA2_128S_ADDR_TYPE_FORSPK 4
#define SLHDSA_SHA2_128S_ADDR_TYPE_WOTSPRF 5
#define SLHDSA_SHA2_128S_ADDR_TYPE_FORSPRF 6
OPENSSL_INLINE void slhdsa_set_type(uint8_t addr[32], uint32_t type) {
// FIPS 205 relies on this setting parts of the address to 0, so we do it
// here to avoid confusion.
//
// The behavior here is only correct for the SHA-2 instantiations.
OPENSSL_memset(addr + 10, 0, 12);
addr[SLHDSA_SHA2_128S_OFFSET_TYPE] = (uint8_t)type;
}
OPENSSL_INLINE void slhdsa_set_tree_height(uint8_t addr[32],
uint32_t tree_height) {
addr[SLHDSA_SHA2_128S_OFFSET_TREE_HGT] = (uint8_t)tree_height;
}
OPENSSL_INLINE void slhdsa_set_tree_index(uint8_t addr[32],
uint32_t tree_index) {
CRYPTO_store_u32_be(&addr[SLHDSA_SHA2_128S_OFFSET_TREE_INDEX], tree_index);
}
OPENSSL_INLINE uint32_t slhdsa_get_tree_index(uint8_t addr[32]) {
return CRYPTO_load_u32_be(addr + SLHDSA_SHA2_128S_OFFSET_TREE_INDEX);
}
#if defined(__cplusplus)
} // extern C
#endif
#endif // OPENSSL_HEADER_CRYPTO_SLHDSA_ADDRESS_H
@@ -0,0 +1,169 @@
/* Copyright (c) 2024, Google LLC
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
#include <CCryptoBoringSSL_base.h>
#include <assert.h>
#include <string.h>
#include "../internal.h"
#include "./address.h"
#include "./fors.h"
#include "./params.h"
#include "./thash.h"
// Compute the base 2^12 representation of `message` (algorithm 4, page 16).
static void fors_base_b(
uint16_t indices[SLHDSA_SHA2_128S_FORS_TREES],
const uint8_t message[SLHDSA_SHA2_128S_FORS_MSG_BYTES]) {
static_assert(SLHDSA_SHA2_128S_FORS_HEIGHT == 12, "");
static_assert((SLHDSA_SHA2_128S_FORS_TREES & 1) == 0, "");
const uint8_t *msg = message;
for (size_t i = 0; i < SLHDSA_SHA2_128S_FORS_TREES; i += 2) {
uint32_t val = ((uint32_t)msg[0] << 16) | ((uint32_t)msg[1] << 8) | msg[2];
indices[i] = (val >> 12) & 0xFFF;
indices[i + 1] = val & 0xFFF;
msg += 3;
}
}
// Implements Algorithm 14: fors_skGen function (page 29)
void slhdsa_fors_sk_gen(uint8_t fors_sk[SLHDSA_SHA2_128S_N], uint32_t idx,
const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]) {
uint8_t sk_addr[32];
OPENSSL_memcpy(sk_addr, addr, sizeof(sk_addr));
slhdsa_set_type(sk_addr, SLHDSA_SHA2_128S_ADDR_TYPE_FORSPRF);
slhdsa_copy_keypair_addr(sk_addr, addr);
slhdsa_set_tree_index(sk_addr, idx);
slhdsa_thash_prf(fors_sk, pk_seed, sk_seed, sk_addr);
}
// Implements Algorithm 15: fors_node function (page 30)
void slhdsa_fors_treehash(uint8_t root_node[SLHDSA_SHA2_128S_N],
const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
uint32_t i /*target node index*/,
uint32_t z /*target node height*/,
const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]) {
BSSL_CHECK(z <= SLHDSA_SHA2_128S_FORS_HEIGHT);
BSSL_CHECK(i < (uint32_t)(SLHDSA_SHA2_128S_FORS_TREES *
(1 << (SLHDSA_SHA2_128S_FORS_HEIGHT - z))));
if (z == 0) {
uint8_t sk[SLHDSA_SHA2_128S_N];
slhdsa_set_tree_height(addr, 0);
slhdsa_set_tree_index(addr, i);
slhdsa_fors_sk_gen(sk, i, sk_seed, pk_seed, addr);
slhdsa_thash_f(root_node, sk, pk_seed, addr);
} else {
// Stores left node and right node.
uint8_t nodes[2 * SLHDSA_SHA2_128S_N];
slhdsa_fors_treehash(nodes, sk_seed, 2 * i, z - 1, pk_seed, addr);
slhdsa_fors_treehash(nodes + SLHDSA_SHA2_128S_N, sk_seed, 2 * i + 1, z - 1,
pk_seed, addr);
slhdsa_set_tree_height(addr, z);
slhdsa_set_tree_index(addr, i);
slhdsa_thash_h(root_node, nodes, pk_seed, addr);
}
}
// Implements Algorithm 16: fors_sign function (page 31)
void slhdsa_fors_sign(uint8_t fors_sig[SLHDSA_SHA2_128S_FORS_BYTES],
const uint8_t message[SLHDSA_SHA2_128S_FORS_MSG_BYTES],
const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]) {
uint16_t indices[SLHDSA_SHA2_128S_FORS_TREES];
// Derive FORS indices compatible with the NIST changes.
fors_base_b(indices, message);
for (size_t i = 0; i < SLHDSA_SHA2_128S_FORS_TREES; ++i) {
slhdsa_set_tree_height(addr, 0);
// Write the FORS secret key element to the correct position.
slhdsa_fors_sk_gen(
fors_sig + i * SLHDSA_SHA2_128S_N * (SLHDSA_SHA2_128S_FORS_HEIGHT + 1),
i * (1 << SLHDSA_SHA2_128S_FORS_HEIGHT) + indices[i], sk_seed, pk_seed,
addr);
for (size_t j = 0; j < SLHDSA_SHA2_128S_FORS_HEIGHT; ++j) {
size_t s = (indices[i] / (1 << j)) ^ 1;
// Write the FORS auth path element to the correct position.
slhdsa_fors_treehash(
fors_sig + SLHDSA_SHA2_128S_N *
(i * (SLHDSA_SHA2_128S_FORS_HEIGHT + 1) + j + 1),
sk_seed, i * (1ULL << (SLHDSA_SHA2_128S_FORS_HEIGHT - j)) + s, j,
pk_seed, addr);
}
}
}
// Implements Algorithm 17: fors_pkFromSig function (page 32)
void slhdsa_fors_pk_from_sig(
uint8_t fors_pk[SLHDSA_SHA2_128S_N],
const uint8_t fors_sig[SLHDSA_SHA2_128S_FORS_BYTES],
const uint8_t message[SLHDSA_SHA2_128S_FORS_MSG_BYTES],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N], uint8_t addr[32]) {
uint16_t indices[SLHDSA_SHA2_128S_FORS_TREES];
uint8_t tmp[2 * SLHDSA_SHA2_128S_N];
uint8_t roots[SLHDSA_SHA2_128S_FORS_TREES * SLHDSA_SHA2_128S_N];
// Derive FORS indices compatible with the NIST changes.
fors_base_b(indices, message);
for (size_t i = 0; i < SLHDSA_SHA2_128S_FORS_TREES; ++i) {
// Pointer to current sk and authentication path
const uint8_t *sk =
fors_sig + i * SLHDSA_SHA2_128S_N * (SLHDSA_SHA2_128S_FORS_HEIGHT + 1);
const uint8_t *auth =
fors_sig + i * SLHDSA_SHA2_128S_N * (SLHDSA_SHA2_128S_FORS_HEIGHT + 1) +
SLHDSA_SHA2_128S_N;
uint8_t nodes[2 * SLHDSA_SHA2_128S_N];
slhdsa_set_tree_height(addr, 0);
slhdsa_set_tree_index(
addr, (i * (1 << SLHDSA_SHA2_128S_FORS_HEIGHT)) + indices[i]);
slhdsa_thash_f(nodes, sk, pk_seed, addr);
for (size_t j = 0; j < SLHDSA_SHA2_128S_FORS_HEIGHT; ++j) {
slhdsa_set_tree_height(addr, j + 1);
// Even node
if (((indices[i] / (1 << j)) % 2) == 0) {
slhdsa_set_tree_index(addr, slhdsa_get_tree_index(addr) / 2);
OPENSSL_memcpy(tmp, nodes, SLHDSA_SHA2_128S_N);
OPENSSL_memcpy(tmp + SLHDSA_SHA2_128S_N, auth + j * SLHDSA_SHA2_128S_N,
SLHDSA_SHA2_128S_N);
slhdsa_thash_h(nodes + SLHDSA_SHA2_128S_N, tmp, pk_seed, addr);
} else {
slhdsa_set_tree_index(addr, (slhdsa_get_tree_index(addr) - 1) / 2);
OPENSSL_memcpy(tmp, auth + j * SLHDSA_SHA2_128S_N, SLHDSA_SHA2_128S_N);
OPENSSL_memcpy(tmp + SLHDSA_SHA2_128S_N, nodes, SLHDSA_SHA2_128S_N);
slhdsa_thash_h(nodes + SLHDSA_SHA2_128S_N, tmp, pk_seed, addr);
}
OPENSSL_memcpy(nodes, nodes + SLHDSA_SHA2_128S_N, SLHDSA_SHA2_128S_N);
}
OPENSSL_memcpy(roots + i * SLHDSA_SHA2_128S_N, nodes, SLHDSA_SHA2_128S_N);
}
uint8_t forspk_addr[32];
OPENSSL_memcpy(forspk_addr, addr, sizeof(forspk_addr));
slhdsa_set_type(forspk_addr, SLHDSA_SHA2_128S_ADDR_TYPE_FORSPK);
slhdsa_copy_keypair_addr(forspk_addr, addr);
slhdsa_thash_tk(fors_pk, roots, pk_seed, forspk_addr);
}
@@ -0,0 +1,58 @@
/* Copyright (c) 2024, Google LLC
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
#ifndef OPENSSL_HEADER_CRYPTO_SLHDSA_FORS_H
#define OPENSSL_HEADER_CRYPTO_SLHDSA_FORS_H
#include "./params.h"
#if defined(__cplusplus)
extern "C" {
#endif
// Implements Algorithm 14: fors_skGen function (page 29)
void slhdsa_fors_sk_gen(uint8_t fors_sk[SLHDSA_SHA2_128S_N], uint32_t idx,
const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]);
// Implements Algorithm 15: fors_node function (page 30)
void slhdsa_fors_treehash(uint8_t root_node[SLHDSA_SHA2_128S_N],
const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
uint32_t i /*target node index*/,
uint32_t z /*target node height*/,
const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]);
// Implements Algorithm 16: fors_sign function (page 31)
void slhdsa_fors_sign(uint8_t fors_sig[SLHDSA_SHA2_128S_FORS_BYTES],
const uint8_t message[SLHDSA_SHA2_128S_FORS_MSG_BYTES],
const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]);
// Implements Algorithm 17: fors_pkFromSig function (page 32)
void slhdsa_fors_pk_from_sig(
uint8_t fors_pk[SLHDSA_SHA2_128S_N],
const uint8_t fors_sig[SLHDSA_SHA2_128S_FORS_BYTES],
const uint8_t message[SLHDSA_SHA2_128S_FORS_MSG_BYTES],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N], uint8_t addr[32]);
#if defined(__cplusplus)
} // extern C
#endif
#endif // OPENSSL_HEADER_CRYPTO_SLHDSA_FORS_H
@@ -0,0 +1,63 @@
/* Copyright (c) 2024, Google LLC
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
#ifndef OPENSSL_HEADER_CRYPTO_SLHDSA_INTERNAL_H
#define OPENSSL_HEADER_CRYPTO_SLHDSA_INTERNAL_H
#include <CCryptoBoringSSL_slhdsa.h>
#include "params.h"
#if defined(__cplusplus)
extern "C" {
#endif
// SLHDSA_SHA2_128S_generate_key_from_seed generates an SLH-DSA-SHA2-128s key
// pair from a 48-byte seed and writes the result to |out_public_key| and
// |out_secret_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_secret_key[SLHDSA_SHA2_128S_PRIVATE_KEY_BYTES],
const uint8_t seed[3 * SLHDSA_SHA2_128S_N]);
// SLHDSA_SHA2_128S_sign_internal acts like |SLHDSA_SHA2_128S_sign| but
// accepts an explicit entropy input, which can be PK.seed (bytes 32..48 of
// the private key) to generate deterministic signatures. It also takes the
// input message in three parts so that the "internal" version of the signing
// function, from section 9.2, can be implemented. The |header| argument may be
// NULL to omit it.
OPENSSL_EXPORT void SLHDSA_SHA2_128S_sign_internal(
uint8_t out_signature[SLHDSA_SHA2_128S_SIGNATURE_BYTES],
const uint8_t secret_key[SLHDSA_SHA2_128S_PRIVATE_KEY_BYTES],
const uint8_t header[SLHDSA_M_PRIME_HEADER_LEN], const uint8_t *context,
size_t context_len, const uint8_t *msg, size_t msg_len,
const uint8_t entropy[SLHDSA_SHA2_128S_N]);
// SLHDSA_SHA2_128S_verify_internal acts like |SLHDSA_SHA2_128S_verify| but
// takes the input message in three parts so that the "internal" version of the
// verification function, from section 9.3, can be implemented. The |header|
// argument may be NULL to omit it.
OPENSSL_EXPORT int SLHDSA_SHA2_128S_verify_internal(
const uint8_t *signature, size_t signature_len,
const uint8_t public_key[SLHDSA_SHA2_128S_PUBLIC_KEY_BYTES],
const uint8_t header[SLHDSA_M_PRIME_HEADER_LEN], const uint8_t *context,
size_t context_len, const uint8_t *msg, size_t msg_len);
#if defined(__cplusplus)
} // extern C
#endif
#endif // OPENSSL_HEADER_CRYPTO_SLHDSA_INTERNAL_H
@@ -0,0 +1,161 @@
/* Copyright (c) 2024, Google LLC
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
#include <CCryptoBoringSSL_base.h>
#include <string.h>
#include "../internal.h"
#include "./address.h"
#include "./merkle.h"
#include "./params.h"
#include "./thash.h"
#include "./wots.h"
// Implements Algorithm 9: xmss_node function (page 23)
void slhdsa_treehash(uint8_t out_pk[SLHDSA_SHA2_128S_N],
const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
uint32_t i /*target node index*/,
uint32_t z /*target node height*/,
const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]) {
BSSL_CHECK(z <= SLHDSA_SHA2_128S_TREE_HEIGHT);
BSSL_CHECK(i < (uint32_t)(1 << (SLHDSA_SHA2_128S_TREE_HEIGHT - z)));
if (z == 0) {
slhdsa_set_type(addr, SLHDSA_SHA2_128S_ADDR_TYPE_WOTS);
slhdsa_set_keypair_addr(addr, i);
slhdsa_wots_pk_gen(out_pk, sk_seed, pk_seed, addr);
} else {
// Stores left node and right node.
uint8_t nodes[2 * SLHDSA_SHA2_128S_N];
slhdsa_treehash(nodes, sk_seed, 2 * i, z - 1, pk_seed, addr);
slhdsa_treehash(nodes + SLHDSA_SHA2_128S_N, sk_seed, 2 * i + 1, z - 1,
pk_seed, addr);
slhdsa_set_type(addr, SLHDSA_SHA2_128S_ADDR_TYPE_HASHTREE);
slhdsa_set_tree_height(addr, z);
slhdsa_set_tree_index(addr, i);
slhdsa_thash_h(out_pk, nodes, pk_seed, addr);
}
}
// Implements Algorithm 10: xmss_sign function (page 24)
void slhdsa_xmss_sign(uint8_t sig[SLHDSA_SHA2_128S_XMSS_BYTES],
const uint8_t msg[SLHDSA_SHA2_128S_N], unsigned int idx,
const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]) {
// Build authentication path
for (size_t j = 0; j < SLHDSA_SHA2_128S_TREE_HEIGHT; ++j) {
unsigned int k = (idx >> j) ^ 1;
slhdsa_treehash(sig + SLHDSA_SHA2_128S_WOTS_BYTES + j * SLHDSA_SHA2_128S_N,
sk_seed, k, j, pk_seed, addr);
}
// Compute WOTS+ signature
slhdsa_set_type(addr, SLHDSA_SHA2_128S_ADDR_TYPE_WOTS);
slhdsa_set_keypair_addr(addr, idx);
slhdsa_wots_sign(sig, msg, sk_seed, pk_seed, addr);
}
// Implements Algorithm 11: xmss_pkFromSig function (page 25)
void slhdsa_xmss_pk_from_sig(
uint8_t root[SLHDSA_SHA2_128S_N],
const uint8_t xmss_sig[SLHDSA_SHA2_128S_XMSS_BYTES], unsigned int idx,
const uint8_t msg[SLHDSA_SHA2_128S_N],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N], uint8_t addr[32]) {
// Stores node[0] and node[1] from Algorithm 11
slhdsa_set_type(addr, SLHDSA_SHA2_128S_ADDR_TYPE_WOTS);
slhdsa_set_keypair_addr(addr, idx);
uint8_t node[2 * SLHDSA_SHA2_128S_N];
slhdsa_wots_pk_from_sig(node, xmss_sig, msg, pk_seed, addr);
slhdsa_set_type(addr, SLHDSA_SHA2_128S_ADDR_TYPE_HASHTREE);
slhdsa_set_tree_index(addr, idx);
uint8_t tmp[2 * SLHDSA_SHA2_128S_N];
const uint8_t *const auth = xmss_sig + SLHDSA_SHA2_128S_WOTS_BYTES;
for (size_t k = 0; k < SLHDSA_SHA2_128S_TREE_HEIGHT; ++k) {
slhdsa_set_tree_height(addr, k + 1);
if (((idx >> k) & 1) == 0) {
slhdsa_set_tree_index(addr, slhdsa_get_tree_index(addr) >> 1);
OPENSSL_memcpy(tmp, node, SLHDSA_SHA2_128S_N);
OPENSSL_memcpy(tmp + SLHDSA_SHA2_128S_N, auth + k * SLHDSA_SHA2_128S_N,
SLHDSA_SHA2_128S_N);
slhdsa_thash_h(node + SLHDSA_SHA2_128S_N, tmp, pk_seed, addr);
} else {
slhdsa_set_tree_index(addr, (slhdsa_get_tree_index(addr) - 1) >> 1);
OPENSSL_memcpy(tmp, auth + k * SLHDSA_SHA2_128S_N, SLHDSA_SHA2_128S_N);
OPENSSL_memcpy(tmp + SLHDSA_SHA2_128S_N, node, SLHDSA_SHA2_128S_N);
slhdsa_thash_h(node + SLHDSA_SHA2_128S_N, tmp, pk_seed, addr);
}
OPENSSL_memcpy(node, node + SLHDSA_SHA2_128S_N, SLHDSA_SHA2_128S_N);
}
OPENSSL_memcpy(root, node, SLHDSA_SHA2_128S_N);
}
// Implements Algorithm 12: ht_sign function (page 27)
void slhdsa_ht_sign(
uint8_t sig[SLHDSA_SHA2_128S_XMSS_BYTES * SLHDSA_SHA2_128S_D],
const uint8_t message[SLHDSA_SHA2_128S_N], uint64_t idx_tree,
uint32_t idx_leaf, const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N]) {
uint8_t addr[32] = {0};
slhdsa_set_tree_addr(addr, idx_tree);
// Layer 0
slhdsa_xmss_sign(sig, message, idx_leaf, sk_seed, pk_seed, addr);
uint8_t root[SLHDSA_SHA2_128S_N];
slhdsa_xmss_pk_from_sig(root, sig, idx_leaf, message, pk_seed, addr);
sig += SLHDSA_SHA2_128S_XMSS_BYTES;
// All other layers
for (size_t j = 1; j < SLHDSA_SHA2_128S_D; ++j) {
idx_leaf = idx_tree % (1 << SLHDSA_SHA2_128S_TREE_HEIGHT);
idx_tree = idx_tree >> SLHDSA_SHA2_128S_TREE_HEIGHT;
slhdsa_set_layer_addr(addr, j);
slhdsa_set_tree_addr(addr, idx_tree);
slhdsa_xmss_sign(sig, root, idx_leaf, sk_seed, pk_seed, addr);
if (j < (SLHDSA_SHA2_128S_D - 1)) {
slhdsa_xmss_pk_from_sig(root, sig, idx_leaf, root, pk_seed, addr);
}
sig += SLHDSA_SHA2_128S_XMSS_BYTES;
}
}
// Implements Algorithm 13: ht_verify function (page 28)
int slhdsa_ht_verify(
const uint8_t sig[SLHDSA_SHA2_128S_D * SLHDSA_SHA2_128S_XMSS_BYTES],
const uint8_t message[SLHDSA_SHA2_128S_N], uint64_t idx_tree,
uint32_t idx_leaf, const uint8_t pk_root[SLHDSA_SHA2_128S_N],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N]) {
uint8_t addr[32] = {0};
slhdsa_set_tree_addr(addr, idx_tree);
uint8_t node[SLHDSA_SHA2_128S_N];
slhdsa_xmss_pk_from_sig(node, sig, idx_leaf, message, pk_seed, addr);
for (size_t j = 1; j < SLHDSA_SHA2_128S_D; ++j) {
idx_leaf = idx_tree % (1 << SLHDSA_SHA2_128S_TREE_HEIGHT);
idx_tree = idx_tree >> SLHDSA_SHA2_128S_TREE_HEIGHT;
slhdsa_set_layer_addr(addr, j);
slhdsa_set_tree_addr(addr, idx_tree);
slhdsa_xmss_pk_from_sig(node, sig + j * SLHDSA_SHA2_128S_XMSS_BYTES,
idx_leaf, node, pk_seed, addr);
}
return memcmp(node, pk_root, SLHDSA_SHA2_128S_N) == 0;
}
@@ -0,0 +1,70 @@
/* Copyright (c) 2024, Google LLC
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
#ifndef OPENSSL_HEADER_CRYPTO_SLHDSA_MERKLE_H
#define OPENSSL_HEADER_CRYPTO_SLHDSA_MERKLE_H
#include <CCryptoBoringSSL_base.h>
#include <sys/types.h>
#include "./params.h"
#if defined(__cplusplus)
extern "C" {
#endif
// Implements Algorithm 9: xmss_node function (page 23)
void slhdsa_treehash(uint8_t out_pk[SLHDSA_SHA2_128S_N],
const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
uint32_t i /*target node index*/,
uint32_t z /*target node height*/,
const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]);
// Implements Algorithm 10: xmss_sign function (page 24)
void slhdsa_xmss_sign(uint8_t sig[SLHDSA_SHA2_128S_XMSS_BYTES],
const uint8_t msg[SLHDSA_SHA2_128S_N], unsigned int idx,
const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]);
// Implements Algorithm 11: xmss_pkFromSig function (page 25)
void slhdsa_xmss_pk_from_sig(
uint8_t root[SLHDSA_SHA2_128S_N],
const uint8_t xmss_sig[SLHDSA_SHA2_128S_XMSS_BYTES], unsigned int idx,
const uint8_t msg[SLHDSA_SHA2_128S_N],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N], uint8_t addr[32]);
// Implements Algorithm 12: ht_sign function (page 27)
void slhdsa_ht_sign(
uint8_t sig[SLHDSA_SHA2_128S_D * SLHDSA_SHA2_128S_XMSS_BYTES],
const uint8_t message[SLHDSA_SHA2_128S_N], uint64_t idx_tree,
uint32_t idx_leaf, const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N]);
// Implements Algorithm 13: ht_verify function (page 28)
int slhdsa_ht_verify(
const uint8_t sig[SLHDSA_SHA2_128S_D * SLHDSA_SHA2_128S_XMSS_BYTES],
const uint8_t message[SLHDSA_SHA2_128S_N], uint64_t idx_tree,
uint32_t idx_leaf, const uint8_t pk_root[SLHDSA_SHA2_128S_N],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N]);
#if defined(__cplusplus)
} // extern C
#endif
#endif // OPENSSL_HEADER_CRYPTO_SLHDSA_MERKLE_H
@@ -0,0 +1,83 @@
/* Copyright (c) 2024, Google LLC
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
#ifndef OPENSSL_HEADER_CRYPTO_SLHDSA_PARAMS_H
#define OPENSSL_HEADER_CRYPTO_SLHDSA_PARAMS_H
#include <CCryptoBoringSSL_base.h>
#if defined(__cplusplus)
extern "C" {
#endif
// Output length of the hash function.
#define SLHDSA_SHA2_128S_N 16
// Total height of the tree structure.
#define SLHDSA_SHA2_128S_FULL_HEIGHT 63
// Number of subtree layers.
#define SLHDSA_SHA2_128S_D 7
// Height of the trees on each layer
#define SLHDSA_SHA2_128S_TREE_HEIGHT 9
// Height of each individual FORS tree.
#define SLHDSA_SHA2_128S_FORS_HEIGHT 12
// Total number of FORS tree used.
#define SLHDSA_SHA2_128S_FORS_TREES 14
// Size of a FORS signature
#define SLHDSA_SHA2_128S_FORS_BYTES \
((SLHDSA_SHA2_128S_FORS_HEIGHT + 1) * SLHDSA_SHA2_128S_FORS_TREES * \
SLHDSA_SHA2_128S_N)
// The number of bytes at the beginning of M', the augmented message, before the
// context.
#define SLHDSA_M_PRIME_HEADER_LEN 2
// Winternitz parameter and derived values
#define SLHDSA_SHA2_128S_WOTS_W 16
#define SLHDSA_SHA2_128S_WOTS_LOG_W 4
#define SLHDSA_SHA2_128S_WOTS_LEN1 32
#define SLHDSA_SHA2_128S_WOTS_LEN2 3
#define SLHDSA_SHA2_128S_WOTS_LEN 35
#define SLHDSA_SHA2_128S_WOTS_BYTES \
(SLHDSA_SHA2_128S_N * SLHDSA_SHA2_128S_WOTS_LEN)
// XMSS sizes
#define SLHDSA_SHA2_128S_XMSS_BYTES \
(SLHDSA_SHA2_128S_WOTS_BYTES + \
(SLHDSA_SHA2_128S_N * SLHDSA_SHA2_128S_TREE_HEIGHT))
// Size of the message digest (NOTE: This is only correct for the SHA-256 params
// here)
#define SLHDSA_SHA2_128S_DIGEST_SIZE \
(((SLHDSA_SHA2_128S_FORS_TREES * SLHDSA_SHA2_128S_FORS_HEIGHT) / 8) + \
(((SLHDSA_SHA2_128S_FULL_HEIGHT - SLHDSA_SHA2_128S_TREE_HEIGHT) / 8) + 1) + \
(SLHDSA_SHA2_128S_TREE_HEIGHT / 8) + 1)
// Compressed address size when using SHA-256
#define SLHDSA_SHA2_128S_SHA256_ADDR_BYTES 22
// Size of the FORS message hash
#define SLHDSA_SHA2_128S_FORS_MSG_BYTES \
((SLHDSA_SHA2_128S_FORS_HEIGHT * SLHDSA_SHA2_128S_FORS_TREES + 7) / 8)
#define SLHDSA_SHA2_128S_TREE_BITS \
(SLHDSA_SHA2_128S_TREE_HEIGHT * (SLHDSA_SHA2_128S_D - 1))
#define SLHDSA_SHA2_128S_TREE_BYTES ((SLHDSA_SHA2_128S_TREE_BITS + 7) / 8)
#define SLHDSA_SHA2_128S_LEAF_BITS SLHDSA_SHA2_128S_TREE_HEIGHT
#define SLHDSA_SHA2_128S_LEAF_BYTES ((SLHDSA_SHA2_128S_LEAF_BITS + 7) / 8)
#if defined(__cplusplus)
} // extern C
#endif
#endif // OPENSSL_HEADER_CRYPTO_SLHDSA_PARAMS_H
@@ -0,0 +1,206 @@
/* Copyright (c) 2024, Google LLC
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
#include <CCryptoBoringSSL_slhdsa.h>
#include <string.h>
#include <CCryptoBoringSSL_rand.h>
#include "../internal.h"
#include "address.h"
#include "fors.h"
#include "internal.h"
#include "merkle.h"
#include "params.h"
#include "thash.h"
void SLHDSA_SHA2_128S_generate_key_from_seed(
uint8_t out_public_key[SLHDSA_SHA2_128S_PUBLIC_KEY_BYTES],
uint8_t out_secret_key[SLHDSA_SHA2_128S_PRIVATE_KEY_BYTES],
const uint8_t seed[3 * SLHDSA_SHA2_128S_N]) {
// Initialize SK.seed || SK.prf || PK.seed from seed.
OPENSSL_memcpy(out_secret_key, seed, 3 * SLHDSA_SHA2_128S_N);
// Initialize PK.seed from seed.
OPENSSL_memcpy(out_public_key, seed + 2 * SLHDSA_SHA2_128S_N,
SLHDSA_SHA2_128S_N);
uint8_t addr[32] = {0};
slhdsa_set_layer_addr(addr, SLHDSA_SHA2_128S_D - 1);
// Set PK.root
slhdsa_treehash(out_public_key + SLHDSA_SHA2_128S_N, out_secret_key, 0,
SLHDSA_SHA2_128S_TREE_HEIGHT, out_public_key, addr);
OPENSSL_memcpy(out_secret_key + 3 * SLHDSA_SHA2_128S_N,
out_public_key + SLHDSA_SHA2_128S_N, SLHDSA_SHA2_128S_N);
}
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]) {
uint8_t seed[3 * SLHDSA_SHA2_128S_N];
RAND_bytes(seed, 3 * SLHDSA_SHA2_128S_N);
SLHDSA_SHA2_128S_generate_key_from_seed(out_public_key, out_private_key,
seed);
}
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]) {
OPENSSL_memcpy(out_public_key, private_key + 2 * SLHDSA_SHA2_128S_N,
SLHDSA_SHA2_128S_N * 2);
}
// Note that this overreads by a byte. This is fine in the context that it's
// used.
static uint64_t load_tree_index(const uint8_t in[8]) {
static_assert(SLHDSA_SHA2_128S_TREE_BYTES == 7,
"This code needs to be updated");
uint64_t index = CRYPTO_load_u64_be(in);
index >>= 8;
index &= (~(uint64_t)0) >> (64 - SLHDSA_SHA2_128S_TREE_BITS);
return index;
}
// Implements Algorithm 22: slh_sign function (Section 10.2.1, page 39)
void SLHDSA_SHA2_128S_sign_internal(
uint8_t out_signature[SLHDSA_SHA2_128S_SIGNATURE_BYTES],
const uint8_t secret_key[SLHDSA_SHA2_128S_PRIVATE_KEY_BYTES],
const uint8_t header[SLHDSA_M_PRIME_HEADER_LEN], const uint8_t *context,
size_t context_len, const uint8_t *msg, size_t msg_len,
const uint8_t entropy[SLHDSA_SHA2_128S_N]) {
const uint8_t *sk_seed = secret_key;
const uint8_t *sk_prf = secret_key + SLHDSA_SHA2_128S_N;
const uint8_t *pk_seed = secret_key + 2 * SLHDSA_SHA2_128S_N;
const uint8_t *pk_root = secret_key + 3 * SLHDSA_SHA2_128S_N;
// Derive randomizer R and copy it to signature
uint8_t R[SLHDSA_SHA2_128S_N];
slhdsa_thash_prfmsg(R, sk_prf, entropy, header, context, context_len, msg,
msg_len);
OPENSSL_memcpy(out_signature, R, SLHDSA_SHA2_128S_N);
// Compute message digest
uint8_t digest[SLHDSA_SHA2_128S_DIGEST_SIZE];
slhdsa_thash_hmsg(digest, R, pk_seed, pk_root, header, context, context_len,
msg, msg_len);
uint8_t fors_digest[SLHDSA_SHA2_128S_FORS_MSG_BYTES];
OPENSSL_memcpy(fors_digest, digest, SLHDSA_SHA2_128S_FORS_MSG_BYTES);
const uint64_t idx_tree =
load_tree_index(digest + SLHDSA_SHA2_128S_FORS_MSG_BYTES);
uint32_t idx_leaf = CRYPTO_load_u16_be(
digest + SLHDSA_SHA2_128S_FORS_MSG_BYTES + SLHDSA_SHA2_128S_TREE_BYTES);
idx_leaf &= (~(uint32_t)0) >> (32 - SLHDSA_SHA2_128S_LEAF_BITS);
uint8_t addr[32] = {0};
slhdsa_set_tree_addr(addr, idx_tree);
slhdsa_set_type(addr, SLHDSA_SHA2_128S_ADDR_TYPE_FORSTREE);
slhdsa_set_keypair_addr(addr, idx_leaf);
slhdsa_fors_sign(out_signature + SLHDSA_SHA2_128S_N, fors_digest, sk_seed,
pk_seed, addr);
uint8_t pk_fors[SLHDSA_SHA2_128S_N];
slhdsa_fors_pk_from_sig(pk_fors, out_signature + SLHDSA_SHA2_128S_N,
fors_digest, pk_seed, addr);
slhdsa_ht_sign(
out_signature + SLHDSA_SHA2_128S_N + SLHDSA_SHA2_128S_FORS_BYTES, pk_fors,
idx_tree, idx_leaf, sk_seed, pk_seed);
}
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) {
if (context_len > 255) {
return 0;
}
// Construct header for M' as specified in Algorithm 22
uint8_t M_prime_header[2];
M_prime_header[0] = 0; // domain separator for pure signing
M_prime_header[1] = (uint8_t)context_len;
uint8_t entropy[SLHDSA_SHA2_128S_N];
RAND_bytes(entropy, sizeof(entropy));
SLHDSA_SHA2_128S_sign_internal(out_signature, private_key, M_prime_header,
context, context_len, msg, msg_len, entropy);
return 1;
}
// Implements Algorithm 24: slh_verify function (Section 10.3, page 41)
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) {
if (context_len > 255) {
return 0;
}
// Construct header for M' as specified in Algorithm 24
uint8_t M_prime_header[2];
M_prime_header[0] = 0; // domain separator for pure verification
M_prime_header[1] = (uint8_t)context_len;
return SLHDSA_SHA2_128S_verify_internal(signature, signature_len, public_key,
M_prime_header, context, context_len,
msg, msg_len);
}
int SLHDSA_SHA2_128S_verify_internal(
const uint8_t *signature, size_t signature_len,
const uint8_t public_key[SLHDSA_SHA2_128S_PUBLIC_KEY_BYTES],
const uint8_t header[SLHDSA_M_PRIME_HEADER_LEN], const uint8_t *context,
size_t context_len, const uint8_t *msg, size_t msg_len) {
if (signature_len != SLHDSA_SHA2_128S_SIGNATURE_BYTES) {
return 0;
}
const uint8_t *pk_seed = public_key;
const uint8_t *pk_root = public_key + SLHDSA_SHA2_128S_N;
const uint8_t *r = signature;
const uint8_t *sig_fors = signature + SLHDSA_SHA2_128S_N;
const uint8_t *sig_ht = sig_fors + SLHDSA_SHA2_128S_FORS_BYTES;
uint8_t digest[SLHDSA_SHA2_128S_DIGEST_SIZE];
slhdsa_thash_hmsg(digest, r, pk_seed, pk_root, header, context, context_len,
msg, msg_len);
uint8_t fors_digest[SLHDSA_SHA2_128S_FORS_MSG_BYTES];
OPENSSL_memcpy(fors_digest, digest, SLHDSA_SHA2_128S_FORS_MSG_BYTES);
const uint64_t idx_tree =
load_tree_index(digest + SLHDSA_SHA2_128S_FORS_MSG_BYTES);
uint32_t idx_leaf = CRYPTO_load_u16_be(
digest + SLHDSA_SHA2_128S_FORS_MSG_BYTES + SLHDSA_SHA2_128S_TREE_BYTES);
idx_leaf &= (~(uint32_t)0) >> (32 - SLHDSA_SHA2_128S_LEAF_BITS);
uint8_t addr[32] = {0};
slhdsa_set_tree_addr(addr, idx_tree);
slhdsa_set_type(addr, SLHDSA_SHA2_128S_ADDR_TYPE_FORSTREE);
slhdsa_set_keypair_addr(addr, idx_leaf);
uint8_t pk_fors[SLHDSA_SHA2_128S_N];
slhdsa_fors_pk_from_sig(pk_fors, sig_fors, fors_digest, pk_seed, addr);
return slhdsa_ht_verify(sig_ht, pk_fors, idx_tree, idx_leaf, pk_root,
pk_seed);
}
@@ -0,0 +1,173 @@
/* Copyright (c) 2024, Google LLC
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
#include <CCryptoBoringSSL_base.h>
#include <assert.h>
#include <string.h>
#include <CCryptoBoringSSL_sha.h>
#include "../internal.h"
#include "./params.h"
#include "./thash.h"
// Internal thash function used by F, H, and T_l (Section 11.2, pages 44-46)
static void slhdsa_thash(uint8_t output[SLHDSA_SHA2_128S_N],
const uint8_t *input, size_t input_blocks,
const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]) {
SHA256_CTX sha256;
SHA256_Init(&sha256);
// Process pubseed with padding to full block.
static const uint8_t kZeros[64 - SLHDSA_SHA2_128S_N] = {0};
SHA256_Update(&sha256, pk_seed, SLHDSA_SHA2_128S_N);
SHA256_Update(&sha256, kZeros, sizeof(kZeros));
SHA256_Update(&sha256, addr, SLHDSA_SHA2_128S_SHA256_ADDR_BYTES);
SHA256_Update(&sha256, input, input_blocks * SLHDSA_SHA2_128S_N);
uint8_t hash[32];
SHA256_Final(hash, &sha256);
OPENSSL_memcpy(output, hash, SLHDSA_SHA2_128S_N);
}
// Implements PRF_msg function (Section 4.1, page 11 and Section 11.2, pages
// 44-46)
void slhdsa_thash_prfmsg(uint8_t output[SLHDSA_SHA2_128S_N],
const uint8_t sk_prf[SLHDSA_SHA2_128S_N],
const uint8_t entropy[SLHDSA_SHA2_128S_N],
const uint8_t header[SLHDSA_M_PRIME_HEADER_LEN],
const uint8_t *ctx, size_t ctx_len, const uint8_t *msg,
size_t msg_len) {
// Compute HMAC-SHA256(sk_prf, entropy || header || ctx || msg). We inline
// HMAC to avoid an allocation.
uint8_t hmac_key[SHA256_CBLOCK];
static_assert(SLHDSA_SHA2_128S_N <= SHA256_CBLOCK,
"HMAC key is larger than block size");
OPENSSL_memcpy(hmac_key, sk_prf, SLHDSA_SHA2_128S_N);
for (size_t i = 0; i < SLHDSA_SHA2_128S_N; i++) {
hmac_key[i] ^= 0x36;
}
OPENSSL_memset(hmac_key + SLHDSA_SHA2_128S_N, 0x36,
sizeof(hmac_key) - SLHDSA_SHA2_128S_N);
SHA256_CTX sha_ctx;
SHA256_Init(&sha_ctx);
SHA256_Update(&sha_ctx, hmac_key, sizeof(hmac_key));
SHA256_Update(&sha_ctx, entropy, SLHDSA_SHA2_128S_N);
if (header) {
SHA256_Update(&sha_ctx, header, SLHDSA_M_PRIME_HEADER_LEN);
}
SHA256_Update(&sha_ctx, ctx, ctx_len);
SHA256_Update(&sha_ctx, msg, msg_len);
uint8_t hash[SHA256_DIGEST_LENGTH];
SHA256_Final(hash, &sha_ctx);
for (size_t i = 0; i < SLHDSA_SHA2_128S_N; i++) {
hmac_key[i] ^= 0x36 ^ 0x5c;
}
OPENSSL_memset(hmac_key + SLHDSA_SHA2_128S_N, 0x5c,
sizeof(hmac_key) - SLHDSA_SHA2_128S_N);
SHA256_Init(&sha_ctx);
SHA256_Update(&sha_ctx, hmac_key, sizeof(hmac_key));
SHA256_Update(&sha_ctx, hash, sizeof(hash));
SHA256_Final(hash, &sha_ctx);
// Truncate to SLHDSA_SHA2_128S_N bytes
OPENSSL_memcpy(output, hash, SLHDSA_SHA2_128S_N);
}
// Implements H_msg function (Section 4.1, page 11 and Section 11.2, pages
// 44-46)
void slhdsa_thash_hmsg(uint8_t output[SLHDSA_SHA2_128S_DIGEST_SIZE],
const uint8_t r[SLHDSA_SHA2_128S_N],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
const uint8_t pk_root[SLHDSA_SHA2_128S_N],
const uint8_t header[SLHDSA_M_PRIME_HEADER_LEN],
const uint8_t *ctx, size_t ctx_len, const uint8_t *msg,
size_t msg_len) {
// MGF1-SHA-256(R || PK.seed || SHA-256(R || PK.seed || PK.root || header ||
// ctx || M), m) input_buffer stores R || PK_SEED || SHA256(..) || 4-byte
// index
uint8_t input_buffer[2 * SLHDSA_SHA2_128S_N + 32 + 4] = {0};
OPENSSL_memcpy(input_buffer, r, SLHDSA_SHA2_128S_N);
OPENSSL_memcpy(input_buffer + SLHDSA_SHA2_128S_N, pk_seed,
SLHDSA_SHA2_128S_N);
// Inner hash
SHA256_CTX sha_ctx;
SHA256_Init(&sha_ctx);
SHA256_Update(&sha_ctx, r, SLHDSA_SHA2_128S_N);
SHA256_Update(&sha_ctx, pk_seed, SLHDSA_SHA2_128S_N);
SHA256_Update(&sha_ctx, pk_root, SLHDSA_SHA2_128S_N);
if (header) {
SHA256_Update(&sha_ctx, header, SLHDSA_M_PRIME_HEADER_LEN);
}
SHA256_Update(&sha_ctx, ctx, ctx_len);
SHA256_Update(&sha_ctx, msg, msg_len);
// Write directly into the input buffer
SHA256_Final(input_buffer + 2 * SLHDSA_SHA2_128S_N, &sha_ctx);
// MGF1-SHA-256
uint8_t hash[32];
static_assert(SLHDSA_SHA2_128S_DIGEST_SIZE < sizeof(hash),
"More MGF1 iterations required");
SHA256(input_buffer, sizeof(input_buffer), hash);
OPENSSL_memcpy(output, hash, SLHDSA_SHA2_128S_DIGEST_SIZE);
}
// Implements PRF function (Section 4.1, page 11 and Section 11.2, pages 44-46)
void slhdsa_thash_prf(uint8_t output[SLHDSA_SHA2_128S_N],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]) {
slhdsa_thash(output, sk_seed, 1, pk_seed, addr);
}
// Implements T_l function for WOTS+ public key compression (Section 4.1, page
// 11 and Section 11.2, pages 44-46)
void slhdsa_thash_tl(uint8_t output[SLHDSA_SHA2_128S_N],
const uint8_t input[SLHDSA_SHA2_128S_WOTS_BYTES],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]) {
slhdsa_thash(output, input, SLHDSA_SHA2_128S_WOTS_LEN, pk_seed, addr);
}
// Implements H function (Section 4.1, page 11 and Section 11.2, pages 44-46)
void slhdsa_thash_h(uint8_t output[SLHDSA_SHA2_128S_N],
const uint8_t input[2 * SLHDSA_SHA2_128S_N],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]) {
slhdsa_thash(output, input, 2, pk_seed, addr);
}
// Implements F function (Section 4.1, page 11 and Section 11.2, pages 44-46)
void slhdsa_thash_f(uint8_t output[SLHDSA_SHA2_128S_N],
const uint8_t input[SLHDSA_SHA2_128S_N],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]) {
slhdsa_thash(output, input, 1, pk_seed, addr);
}
// Implements T_k function for FORS public key compression (Section 4.1, page 11
// and Section 11.2, pages 44-46)
void slhdsa_thash_tk(
uint8_t output[SLHDSA_SHA2_128S_N],
const uint8_t input[SLHDSA_SHA2_128S_FORS_TREES * SLHDSA_SHA2_128S_N],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N], uint8_t addr[32]) {
slhdsa_thash(output, input, SLHDSA_SHA2_128S_FORS_TREES, pk_seed, addr);
}
@@ -0,0 +1,85 @@
/* Copyright (c) 2024, Google LLC
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
#ifndef OPENSSL_HEADER_CRYPTO_SLHDSA_THASH_H
#define OPENSSL_HEADER_CRYPTO_SLHDSA_THASH_H
#include "./params.h"
#if defined(__cplusplus)
extern "C" {
#endif
// Implements PRF_msg: a pseudo-random function that is used to generate the
// randomizer r for the randomized hashing of the message to be signed.
// (Section 4.1, page 11)
void slhdsa_thash_prfmsg(uint8_t output[SLHDSA_SHA2_128S_N],
const uint8_t sk_prf[SLHDSA_SHA2_128S_N],
const uint8_t opt_rand[SLHDSA_SHA2_128S_N],
const uint8_t header[SLHDSA_M_PRIME_HEADER_LEN],
const uint8_t *ctx, size_t ctx_len, const uint8_t *msg,
size_t msg_len);
// Implements H_msg: a hash function used to generate the digest of the message
// to be signed. (Section 4.1, page 11)
void slhdsa_thash_hmsg(uint8_t output[SLHDSA_SHA2_128S_DIGEST_SIZE],
const uint8_t r[SLHDSA_SHA2_128S_N],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
const uint8_t pk_root[SLHDSA_SHA2_128S_N],
const uint8_t header[SLHDSA_M_PRIME_HEADER_LEN],
const uint8_t *ctx, size_t ctx_len, const uint8_t *msg,
size_t msg_len);
// Implements PRF: a pseudo-random function that is used to generate the secret
// values in WOTS+ and FORS private keys. (Section 4.1, page 11)
void slhdsa_thash_prf(uint8_t output[SLHDSA_SHA2_128S_N],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]);
// Implements T_l: a hash function that maps an l*n-byte message to an n-byte
// message. Used for WOTS+ public key compression. (Section 4.1, page 11)
void slhdsa_thash_tl(uint8_t output[SLHDSA_SHA2_128S_N],
const uint8_t input[SLHDSA_SHA2_128S_WOTS_BYTES],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]);
// Implements H: a hash function that takes a 2*n-byte message as input and
// produces an n-byte output. (Section 4.1, page 11)
void slhdsa_thash_h(uint8_t output[SLHDSA_SHA2_128S_N],
const uint8_t input[2 * SLHDSA_SHA2_128S_N],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]);
// Implements F: a hash function that takes an n-byte message as input and
// produces an n-byte output. (Section 4.1, page 11)
void slhdsa_thash_f(uint8_t output[SLHDSA_SHA2_128S_N],
const uint8_t input[SLHDSA_SHA2_128S_N],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]);
// Implements T_k: a hash function that maps a k*n-byte message to an n-byte
// message. Used for FORS public key compression. (Section 4.1, page 11)
void slhdsa_thash_tk(
uint8_t output[SLHDSA_SHA2_128S_N],
const uint8_t input[SLHDSA_SHA2_128S_FORS_TREES * SLHDSA_SHA2_128S_N],
const uint8_t pk_seed[SLHDSA_SHA2_128S_N], uint8_t addr[32]);
#if defined(__cplusplus)
} // extern C
#endif
#endif // OPENSSL_HEADER_CRYPTO_SLHDSA_THASH_H
@@ -0,0 +1,171 @@
/* Copyright (c) 2024, Google LLC
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
#include <CCryptoBoringSSL_base.h>
#include <assert.h>
#include <stdint.h>
#include <string.h>
#include "../internal.h"
#include "./address.h"
#include "./params.h"
#include "./thash.h"
#include "./wots.h"
// Implements Algorithm 5: chain function, page 18
static void chain(uint8_t output[SLHDSA_SHA2_128S_N],
const uint8_t input[SLHDSA_SHA2_128S_N], uint32_t start,
uint32_t steps, const uint8_t pub_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]) {
assert(start < SLHDSA_SHA2_128S_WOTS_W);
assert(steps < SLHDSA_SHA2_128S_WOTS_W);
OPENSSL_memcpy(output, input, SLHDSA_SHA2_128S_N);
for (size_t i = start; i < (start + steps) && i < SLHDSA_SHA2_128S_WOTS_W;
++i) {
slhdsa_set_hash_addr(addr, i);
slhdsa_thash_f(output, output, pub_seed, addr);
}
}
static void slhdsa_wots_do_chain(uint8_t out[SLHDSA_SHA2_128S_N],
uint8_t sk_addr[32], uint8_t addr[32],
uint8_t value,
const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
const uint8_t pub_seed[SLHDSA_SHA2_128S_N],
uint32_t chain_index) {
uint8_t tmp_sk[SLHDSA_SHA2_128S_N];
slhdsa_set_chain_addr(sk_addr, chain_index);
slhdsa_thash_prf(tmp_sk, pub_seed, sk_seed, sk_addr);
slhdsa_set_chain_addr(addr, chain_index);
chain(out, tmp_sk, 0, value, pub_seed, addr);
}
// Implements Algorithm 6: wots_pkGen function, page 18
void slhdsa_wots_pk_gen(uint8_t pk[SLHDSA_SHA2_128S_N],
const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
const uint8_t pub_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]) {
uint8_t wots_pk_addr[32], sk_addr[32];
OPENSSL_memcpy(wots_pk_addr, addr, sizeof(wots_pk_addr));
OPENSSL_memcpy(sk_addr, addr, sizeof(sk_addr));
slhdsa_set_type(sk_addr, SLHDSA_SHA2_128S_ADDR_TYPE_WOTSPRF);
slhdsa_copy_keypair_addr(sk_addr, addr);
uint8_t tmp[SLHDSA_SHA2_128S_WOTS_BYTES];
for (size_t i = 0; i < SLHDSA_SHA2_128S_WOTS_LEN; ++i) {
slhdsa_wots_do_chain(tmp + i * SLHDSA_SHA2_128S_N, sk_addr, addr,
SLHDSA_SHA2_128S_WOTS_W - 1, sk_seed, pub_seed, i);
}
// Compress pk
slhdsa_set_type(wots_pk_addr, SLHDSA_SHA2_128S_ADDR_TYPE_WOTSPK);
slhdsa_copy_keypair_addr(wots_pk_addr, addr);
slhdsa_thash_tl(pk, tmp, pub_seed, wots_pk_addr);
}
// Implements Algorithm 7: wots_sign function, page 20
void slhdsa_wots_sign(uint8_t sig[SLHDSA_SHA2_128S_WOTS_BYTES],
const uint8_t msg[SLHDSA_SHA2_128S_N],
const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
const uint8_t pub_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]) {
// Compute checksum
static_assert(SLHDSA_SHA2_128S_WOTS_LEN1 == SLHDSA_SHA2_128S_N * 2, "");
uint16_t csum = 0;
for (size_t i = 0; i < SLHDSA_SHA2_128S_N; ++i) {
csum += SLHDSA_SHA2_128S_WOTS_W - 1 - (msg[i] >> 4);
csum += SLHDSA_SHA2_128S_WOTS_W - 1 - (msg[i] & 15);
}
// Compute chains
uint8_t sk_addr[32];
OPENSSL_memcpy(sk_addr, addr, sizeof(sk_addr));
slhdsa_set_type(sk_addr, SLHDSA_SHA2_128S_ADDR_TYPE_WOTSPRF);
slhdsa_copy_keypair_addr(sk_addr, addr);
uint32_t chain_index = 0;
for (size_t i = 0; i < SLHDSA_SHA2_128S_N; ++i) {
slhdsa_wots_do_chain(sig, sk_addr, addr, msg[i] >> 4, sk_seed, pub_seed,
chain_index++);
sig += SLHDSA_SHA2_128S_N;
slhdsa_wots_do_chain(sig, sk_addr, addr, msg[i] & 15, sk_seed, pub_seed,
chain_index++);
sig += SLHDSA_SHA2_128S_N;
}
// Include the SLHDSA_SHA2_128S_WOTS_LEN2 checksum values.
slhdsa_wots_do_chain(sig, sk_addr, addr, (csum >> 8) & 15, sk_seed, pub_seed,
chain_index++);
sig += SLHDSA_SHA2_128S_N;
slhdsa_wots_do_chain(sig, sk_addr, addr, (csum >> 4) & 15, sk_seed, pub_seed,
chain_index++);
sig += SLHDSA_SHA2_128S_N;
slhdsa_wots_do_chain(sig, sk_addr, addr, csum & 15, sk_seed, pub_seed,
chain_index++);
}
static void slhdsa_wots_pk_from_sig_do_chain(
uint8_t out[SLHDSA_SHA2_128S_WOTS_BYTES], uint8_t addr[32],
const uint8_t in[SLHDSA_SHA2_128S_WOTS_BYTES], uint8_t value,
const uint8_t pub_seed[SLHDSA_SHA2_128S_N], uint32_t chain_index) {
slhdsa_set_chain_addr(addr, chain_index);
chain(out + chain_index * SLHDSA_SHA2_128S_N,
in + chain_index * SLHDSA_SHA2_128S_N, value,
SLHDSA_SHA2_128S_WOTS_W - 1 - value, pub_seed, addr);
}
// Implements Algorithm 8: wots_pkFromSig function, page 21
void slhdsa_wots_pk_from_sig(uint8_t pk[SLHDSA_SHA2_128S_N],
const uint8_t sig[SLHDSA_SHA2_128S_WOTS_BYTES],
const uint8_t msg[SLHDSA_SHA2_128S_N],
const uint8_t pub_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]) {
// Compute checksum
static_assert(SLHDSA_SHA2_128S_WOTS_LEN1 == SLHDSA_SHA2_128S_N * 2, "");
uint16_t csum = 0;
for (size_t i = 0; i < SLHDSA_SHA2_128S_N; ++i) {
csum += SLHDSA_SHA2_128S_WOTS_W - 1 - (msg[i] >> 4);
csum += SLHDSA_SHA2_128S_WOTS_W - 1 - (msg[i] & 15);
}
uint8_t tmp[SLHDSA_SHA2_128S_WOTS_BYTES];
uint8_t wots_pk_addr[32];
OPENSSL_memcpy(wots_pk_addr, addr, sizeof(wots_pk_addr));
uint32_t chain_index = 0;
static_assert(SLHDSA_SHA2_128S_WOTS_LEN1 == SLHDSA_SHA2_128S_N * 2, "");
for (size_t i = 0; i < SLHDSA_SHA2_128S_N; ++i) {
slhdsa_wots_pk_from_sig_do_chain(tmp, addr, sig, msg[i] >> 4, pub_seed,
chain_index++);
slhdsa_wots_pk_from_sig_do_chain(tmp, addr, sig, msg[i] & 15, pub_seed,
chain_index++);
}
slhdsa_wots_pk_from_sig_do_chain(tmp, addr, sig, csum >> 8, pub_seed,
chain_index++);
slhdsa_wots_pk_from_sig_do_chain(tmp, addr, sig, (csum >> 4) & 15, pub_seed,
chain_index++);
slhdsa_wots_pk_from_sig_do_chain(tmp, addr, sig, csum & 15, pub_seed,
chain_index++);
// Compress pk
slhdsa_set_type(wots_pk_addr, SLHDSA_SHA2_128S_ADDR_TYPE_WOTSPK);
slhdsa_copy_keypair_addr(wots_pk_addr, addr);
slhdsa_thash_tl(pk, tmp, pub_seed, wots_pk_addr);
}
@@ -0,0 +1,50 @@
/* Copyright (c) 2024, Google LLC
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
#ifndef OPENSSL_HEADER_CRYPTO_SLHDSA_WOTS_H
#define OPENSSL_HEADER_CRYPTO_SLHDSA_WOTS_H
#include "./params.h"
#if defined(__cplusplus)
extern "C" {
#endif
// Implements Algorithm 6: wots_pkGen function, page 18
void slhdsa_wots_pk_gen(uint8_t pk[SLHDSA_SHA2_128S_N],
const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
const uint8_t pub_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]);
// Implements Algorithm 7: wots_sign function, page 20
void slhdsa_wots_sign(uint8_t sig[SLHDSA_SHA2_128S_WOTS_BYTES],
const uint8_t msg[SLHDSA_SHA2_128S_N],
const uint8_t sk_seed[SLHDSA_SHA2_128S_N],
const uint8_t pub_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]);
// Implements Algorithm 8: wots_pkFromSig function, page 21
void slhdsa_wots_pk_from_sig(uint8_t pk[SLHDSA_SHA2_128S_N],
const uint8_t sig[SLHDSA_SHA2_128S_WOTS_BYTES],
const uint8_t msg[SLHDSA_SHA2_128S_N],
const uint8_t pub_seed[SLHDSA_SHA2_128S_N],
uint8_t addr[32]);
#if defined(__cplusplus)
} // extern C
#endif
#endif // OPENSSL_HEADER_CRYPTO_SLHDSA_WOTS_H
+1 -1
View File
@@ -1 +1 @@
This directory is derived from BoringSSL cloned from https://boringssl.googlesource.com/boringssl at revision 6a2ccdcc2ed1d37a43a2183658d2ae61fd5ce208
This directory is derived from BoringSSL cloned from https://boringssl.googlesource.com/boringssl at revision 2587c4974dbe9872451151c8e975f58567a1ce0d
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
@@ -52,14 +52,11 @@
#ifndef OPENSSL_HEADER_BASE_H
#define OPENSSL_HEADER_BASE_H
#if defined(_WIN32) && !(defined(_M_IX86) || defined(__i386__))
#define OPENSSL_NO_ASM
#endif
#if defined(__APPLE__) && defined(__i386__)
#define OPENSSL_NO_ASM
#endif
#define BORINGSSL_PREFIX CCryptoBoringSSL
#if defined(_WIN32) && (defined(__x86_64) || defined(_M_AMD64) || defined(_M_X64) || defined(__x86) || defined(__i386) || defined(__i386__) || defined(_M_IX86))
#define OPENSSL_NO_ASM
#endif
// This file should be the first included by all BoringSSL headers.
@@ -53,6 +53,27 @@ struct sha_state_st {
unsigned num;
};
// SHA256_CBLOCK is the block size of SHA-256.
#define BCM_SHA256_CBLOCK 64
// SHA256_CTX
struct sha256_state_st {
uint32_t h[8];
uint32_t Nl, Nh;
uint8_t data[BCM_SHA256_CBLOCK];
unsigned num, md_len;
};
// BCM_SHA512_CBLOCK is the block size of SHA-512.
#define BCM_SHA512_CBLOCK 128
struct sha512_state_st {
uint64_t h[8];
uint64_t Nl, Nh;
uint8_t p[BCM_SHA512_CBLOCK];
unsigned num, md_len;
};
#if defined(__cplusplus)
} // extern C
@@ -218,6 +218,24 @@
#define BCM_sha1_init BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, BCM_sha1_init)
#define BCM_sha1_transform BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, BCM_sha1_transform)
#define BCM_sha1_update BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, BCM_sha1_update)
#define BCM_sha224_final BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, BCM_sha224_final)
#define BCM_sha224_init BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, BCM_sha224_init)
#define BCM_sha224_update BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, BCM_sha224_update)
#define BCM_sha256_final BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, BCM_sha256_final)
#define BCM_sha256_init BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, BCM_sha256_init)
#define BCM_sha256_transform BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, BCM_sha256_transform)
#define BCM_sha256_transform_blocks BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, BCM_sha256_transform_blocks)
#define BCM_sha256_update BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, BCM_sha256_update)
#define BCM_sha384_final BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, BCM_sha384_final)
#define BCM_sha384_init BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, BCM_sha384_init)
#define BCM_sha384_update BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, BCM_sha384_update)
#define BCM_sha512_256_final BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, BCM_sha512_256_final)
#define BCM_sha512_256_init BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, BCM_sha512_256_init)
#define BCM_sha512_256_update BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, BCM_sha512_256_update)
#define BCM_sha512_final BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, BCM_sha512_final)
#define BCM_sha512_init BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, BCM_sha512_init)
#define BCM_sha512_transform BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, BCM_sha512_transform)
#define BCM_sha512_update BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, BCM_sha512_update)
#define BIO_append_filename BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, BIO_append_filename)
#define BIO_callback_ctrl BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, BIO_callback_ctrl)
#define BIO_clear_flags BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, BIO_clear_flags)
@@ -632,6 +650,7 @@
#define CRYPTO_get_fork_generation BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, CRYPTO_get_fork_generation)
#define CRYPTO_get_lock_name BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, CRYPTO_get_lock_name)
#define CRYPTO_get_locking_callback BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, CRYPTO_get_locking_callback)
#define CRYPTO_get_stderr BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, CRYPTO_get_stderr)
#define CRYPTO_get_thread_local BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, CRYPTO_get_thread_local)
#define CRYPTO_ghash_init BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, CRYPTO_ghash_init)
#define CRYPTO_has_asm BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, CRYPTO_has_asm)
@@ -1673,6 +1692,7 @@
#define RSA_PSS_PARAMS_new BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, RSA_PSS_PARAMS_new)
#define RSA_add_pkcs1_prefix BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, RSA_add_pkcs1_prefix)
#define RSA_bits BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, RSA_bits)
#define RSA_blinding_off BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, RSA_blinding_off)
#define RSA_blinding_on BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, RSA_blinding_on)
#define RSA_check_fips BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, RSA_check_fips)
#define RSA_check_key BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, RSA_check_key)
@@ -1769,6 +1789,13 @@
#define SHA512_Transform BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, SHA512_Transform)
#define SHA512_Update BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, SHA512_Update)
#define SIPHASH_24 BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, SIPHASH_24)
#define SLHDSA_SHA2_128S_generate_key BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, SLHDSA_SHA2_128S_generate_key)
#define SLHDSA_SHA2_128S_generate_key_from_seed BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, SLHDSA_SHA2_128S_generate_key_from_seed)
#define SLHDSA_SHA2_128S_public_from_private BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, SLHDSA_SHA2_128S_public_from_private)
#define SLHDSA_SHA2_128S_sign BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, SLHDSA_SHA2_128S_sign)
#define SLHDSA_SHA2_128S_sign_internal BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, SLHDSA_SHA2_128S_sign_internal)
#define SLHDSA_SHA2_128S_verify BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, SLHDSA_SHA2_128S_verify)
#define SLHDSA_SHA2_128S_verify_internal BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, SLHDSA_SHA2_128S_verify_internal)
#define SPAKE2_CTX_free BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, SPAKE2_CTX_free)
#define SPAKE2_CTX_new BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, SPAKE2_CTX_new)
#define SPAKE2_generate_msg BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, SPAKE2_generate_msg)
@@ -2461,6 +2488,7 @@
#define d2i_DSA_SIG BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, d2i_DSA_SIG)
#define d2i_DSAparams BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, d2i_DSAparams)
#define d2i_ECDSA_SIG BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, d2i_ECDSA_SIG)
#define d2i_ECPKParameters BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, d2i_ECPKParameters)
#define d2i_ECParameters BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, d2i_ECParameters)
#define d2i_ECPrivateKey BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, d2i_ECPrivateKey)
#define d2i_ECPrivateKey_bio BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, d2i_ECPrivateKey_bio)
@@ -2729,6 +2757,7 @@
#define i2d_DSA_SIG BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, i2d_DSA_SIG)
#define i2d_DSAparams BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, i2d_DSAparams)
#define i2d_ECDSA_SIG BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, i2d_ECDSA_SIG)
#define i2d_ECPKParameters BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, i2d_ECPKParameters)
#define i2d_ECParameters BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, i2d_ECParameters)
#define i2d_ECPrivateKey BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, i2d_ECPrivateKey)
#define i2d_ECPrivateKey_bio BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, i2d_ECPrivateKey_bio)
@@ -2894,6 +2923,25 @@
#define sk_pop_free_ex BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, sk_pop_free_ex)
#define sk_push BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, sk_push)
#define sk_value BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, sk_value)
#define slhdsa_fors_pk_from_sig BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, slhdsa_fors_pk_from_sig)
#define slhdsa_fors_sign BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, slhdsa_fors_sign)
#define slhdsa_fors_sk_gen BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, slhdsa_fors_sk_gen)
#define slhdsa_fors_treehash BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, slhdsa_fors_treehash)
#define slhdsa_ht_sign BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, slhdsa_ht_sign)
#define slhdsa_ht_verify BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, slhdsa_ht_verify)
#define slhdsa_thash_f BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, slhdsa_thash_f)
#define slhdsa_thash_h BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, slhdsa_thash_h)
#define slhdsa_thash_hmsg BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, slhdsa_thash_hmsg)
#define slhdsa_thash_prf BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, slhdsa_thash_prf)
#define slhdsa_thash_prfmsg BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, slhdsa_thash_prfmsg)
#define slhdsa_thash_tk BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, slhdsa_thash_tk)
#define slhdsa_thash_tl BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, slhdsa_thash_tl)
#define slhdsa_treehash BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, slhdsa_treehash)
#define slhdsa_wots_pk_from_sig BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, slhdsa_wots_pk_from_sig)
#define slhdsa_wots_pk_gen BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, slhdsa_wots_pk_gen)
#define slhdsa_wots_sign BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, slhdsa_wots_sign)
#define slhdsa_xmss_pk_from_sig BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, slhdsa_xmss_pk_from_sig)
#define slhdsa_xmss_sign BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, slhdsa_xmss_sign)
#define spx_base_b BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, spx_base_b)
#define spx_copy_keypair_addr BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, spx_copy_keypair_addr)
#define spx_fors_pk_from_sig BORINGSSL_ADD_PREFIX(BORINGSSL_PREFIX, spx_fors_pk_from_sig)
@@ -223,6 +223,24 @@
#define _BCM_sha1_init BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, BCM_sha1_init)
#define _BCM_sha1_transform BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, BCM_sha1_transform)
#define _BCM_sha1_update BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, BCM_sha1_update)
#define _BCM_sha224_final BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, BCM_sha224_final)
#define _BCM_sha224_init BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, BCM_sha224_init)
#define _BCM_sha224_update BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, BCM_sha224_update)
#define _BCM_sha256_final BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, BCM_sha256_final)
#define _BCM_sha256_init BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, BCM_sha256_init)
#define _BCM_sha256_transform BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, BCM_sha256_transform)
#define _BCM_sha256_transform_blocks BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, BCM_sha256_transform_blocks)
#define _BCM_sha256_update BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, BCM_sha256_update)
#define _BCM_sha384_final BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, BCM_sha384_final)
#define _BCM_sha384_init BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, BCM_sha384_init)
#define _BCM_sha384_update BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, BCM_sha384_update)
#define _BCM_sha512_256_final BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, BCM_sha512_256_final)
#define _BCM_sha512_256_init BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, BCM_sha512_256_init)
#define _BCM_sha512_256_update BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, BCM_sha512_256_update)
#define _BCM_sha512_final BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, BCM_sha512_final)
#define _BCM_sha512_init BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, BCM_sha512_init)
#define _BCM_sha512_transform BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, BCM_sha512_transform)
#define _BCM_sha512_update BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, BCM_sha512_update)
#define _BIO_append_filename BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, BIO_append_filename)
#define _BIO_callback_ctrl BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, BIO_callback_ctrl)
#define _BIO_clear_flags BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, BIO_clear_flags)
@@ -637,6 +655,7 @@
#define _CRYPTO_get_fork_generation BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, CRYPTO_get_fork_generation)
#define _CRYPTO_get_lock_name BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, CRYPTO_get_lock_name)
#define _CRYPTO_get_locking_callback BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, CRYPTO_get_locking_callback)
#define _CRYPTO_get_stderr BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, CRYPTO_get_stderr)
#define _CRYPTO_get_thread_local BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, CRYPTO_get_thread_local)
#define _CRYPTO_ghash_init BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, CRYPTO_ghash_init)
#define _CRYPTO_has_asm BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, CRYPTO_has_asm)
@@ -1678,6 +1697,7 @@
#define _RSA_PSS_PARAMS_new BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, RSA_PSS_PARAMS_new)
#define _RSA_add_pkcs1_prefix BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, RSA_add_pkcs1_prefix)
#define _RSA_bits BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, RSA_bits)
#define _RSA_blinding_off BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, RSA_blinding_off)
#define _RSA_blinding_on BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, RSA_blinding_on)
#define _RSA_check_fips BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, RSA_check_fips)
#define _RSA_check_key BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, RSA_check_key)
@@ -1774,6 +1794,13 @@
#define _SHA512_Transform BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, SHA512_Transform)
#define _SHA512_Update BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, SHA512_Update)
#define _SIPHASH_24 BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, SIPHASH_24)
#define _SLHDSA_SHA2_128S_generate_key BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, SLHDSA_SHA2_128S_generate_key)
#define _SLHDSA_SHA2_128S_generate_key_from_seed BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, SLHDSA_SHA2_128S_generate_key_from_seed)
#define _SLHDSA_SHA2_128S_public_from_private BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, SLHDSA_SHA2_128S_public_from_private)
#define _SLHDSA_SHA2_128S_sign BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, SLHDSA_SHA2_128S_sign)
#define _SLHDSA_SHA2_128S_sign_internal BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, SLHDSA_SHA2_128S_sign_internal)
#define _SLHDSA_SHA2_128S_verify BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, SLHDSA_SHA2_128S_verify)
#define _SLHDSA_SHA2_128S_verify_internal BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, SLHDSA_SHA2_128S_verify_internal)
#define _SPAKE2_CTX_free BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, SPAKE2_CTX_free)
#define _SPAKE2_CTX_new BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, SPAKE2_CTX_new)
#define _SPAKE2_generate_msg BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, SPAKE2_generate_msg)
@@ -2466,6 +2493,7 @@
#define _d2i_DSA_SIG BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, d2i_DSA_SIG)
#define _d2i_DSAparams BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, d2i_DSAparams)
#define _d2i_ECDSA_SIG BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, d2i_ECDSA_SIG)
#define _d2i_ECPKParameters BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, d2i_ECPKParameters)
#define _d2i_ECParameters BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, d2i_ECParameters)
#define _d2i_ECPrivateKey BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, d2i_ECPrivateKey)
#define _d2i_ECPrivateKey_bio BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, d2i_ECPrivateKey_bio)
@@ -2734,6 +2762,7 @@
#define _i2d_DSA_SIG BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, i2d_DSA_SIG)
#define _i2d_DSAparams BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, i2d_DSAparams)
#define _i2d_ECDSA_SIG BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, i2d_ECDSA_SIG)
#define _i2d_ECPKParameters BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, i2d_ECPKParameters)
#define _i2d_ECParameters BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, i2d_ECParameters)
#define _i2d_ECPrivateKey BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, i2d_ECPrivateKey)
#define _i2d_ECPrivateKey_bio BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, i2d_ECPrivateKey_bio)
@@ -2899,6 +2928,25 @@
#define _sk_pop_free_ex BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, sk_pop_free_ex)
#define _sk_push BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, sk_push)
#define _sk_value BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, sk_value)
#define _slhdsa_fors_pk_from_sig BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, slhdsa_fors_pk_from_sig)
#define _slhdsa_fors_sign BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, slhdsa_fors_sign)
#define _slhdsa_fors_sk_gen BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, slhdsa_fors_sk_gen)
#define _slhdsa_fors_treehash BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, slhdsa_fors_treehash)
#define _slhdsa_ht_sign BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, slhdsa_ht_sign)
#define _slhdsa_ht_verify BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, slhdsa_ht_verify)
#define _slhdsa_thash_f BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, slhdsa_thash_f)
#define _slhdsa_thash_h BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, slhdsa_thash_h)
#define _slhdsa_thash_hmsg BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, slhdsa_thash_hmsg)
#define _slhdsa_thash_prf BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, slhdsa_thash_prf)
#define _slhdsa_thash_prfmsg BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, slhdsa_thash_prfmsg)
#define _slhdsa_thash_tk BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, slhdsa_thash_tk)
#define _slhdsa_thash_tl BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, slhdsa_thash_tl)
#define _slhdsa_treehash BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, slhdsa_treehash)
#define _slhdsa_wots_pk_from_sig BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, slhdsa_wots_pk_from_sig)
#define _slhdsa_wots_pk_gen BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, slhdsa_wots_pk_gen)
#define _slhdsa_wots_sign BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, slhdsa_wots_sign)
#define _slhdsa_xmss_pk_from_sig BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, slhdsa_xmss_pk_from_sig)
#define _slhdsa_xmss_sign BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, slhdsa_xmss_sign)
#define _spx_base_b BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, spx_base_b)
#define _spx_copy_keypair_addr BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, spx_copy_keypair_addr)
#define _spx_fors_pk_from_sig BORINGSSL_ADD_PREFIX_MAC_ASM(BORINGSSL_PREFIX, spx_fors_pk_from_sig)
@@ -145,6 +145,8 @@ OPENSSL_EXPORT int ENGINE_register_all_complete(void);
// OPENSSL_load_builtin_modules does nothing.
OPENSSL_EXPORT void OPENSSL_load_builtin_modules(void);
// OPENSSL_INIT_* are options in OpenSSL to configure the library. In BoringSSL,
// they do nothing.
#define OPENSSL_INIT_NO_LOAD_CRYPTO_STRINGS 0
#define OPENSSL_INIT_LOAD_CRYPTO_STRINGS 0
#define OPENSSL_INIT_ADD_ALL_CIPHERS 0
@@ -154,6 +156,15 @@ OPENSSL_EXPORT void OPENSSL_load_builtin_modules(void);
#define OPENSSL_INIT_LOAD_CONFIG 0
#define OPENSSL_INIT_NO_LOAD_CONFIG 0
#define OPENSSL_INIT_NO_ATEXIT 0
#define OPENSSL_INIT_ATFORK 0
#define OPENSSL_INIT_ENGINE_RDRAND 0
#define OPENSSL_INIT_ENGINE_DYNAMIC 0
#define OPENSSL_INIT_ENGINE_OPENSSL 0
#define OPENSSL_INIT_ENGINE_CRYPTODEV 0
#define OPENSSL_INIT_ENGINE_CAPI 0
#define OPENSSL_INIT_ENGINE_PADLOCK 0
#define OPENSSL_INIT_ENGINE_AFALG 0
#define OPENSSL_INIT_ENGINE_ALL_BUILTIN 0
// OPENSSL_init_crypto returns one.
OPENSSL_EXPORT int OPENSSL_init_crypto(uint64_t opts,
@@ -96,6 +96,10 @@ OPENSSL_EXPORT int DH_up_ref(DH *dh);
// Properties.
// OPENSSL_DH_MAX_MODULUS_BITS is the maximum supported Diffie-Hellman group
// modulus, in bits.
#define OPENSSL_DH_MAX_MODULUS_BITS 10000
// DH_bits returns the size of |dh|'s group modulus, in bits.
OPENSSL_EXPORT unsigned DH_bits(const DH *dh);
@@ -99,6 +99,10 @@ OPENSSL_EXPORT int DSA_up_ref(DSA *dsa);
// Properties.
// OPENSSL_DSA_MAX_MODULUS_BITS is the maximum supported DSA group modulus, in
// bits.
#define OPENSSL_DSA_MAX_MODULUS_BITS 10000
// DSA_bits returns the size of |dsa|'s group modulus, in bits.
OPENSSL_EXPORT unsigned DSA_bits(const DSA *dsa);
@@ -351,8 +351,24 @@ OPENSSL_EXPORT EC_KEY *d2i_ECPrivateKey(EC_KEY **out_key, const uint8_t **inp,
// Use |EC_KEY_marshal_private_key| instead.
OPENSSL_EXPORT int i2d_ECPrivateKey(const EC_KEY *key, uint8_t **outp);
// d2i_ECPKParameters parses a DER-encoded ECParameters structure (RFC 5480)
// from |len| bytes at |*inp|, as described in |d2i_SAMPLE|. For legacy reasons,
// it recognizes the specifiedCurve form, but only for curves that are already
// supported as named curves.
//
// Use |EC_KEY_parse_parameters| or |EC_KEY_parse_curve_name| instead.
OPENSSL_EXPORT EC_GROUP *d2i_ECPKParameters(EC_GROUP **out, const uint8_t **inp,
long len);
// i2d_ECPKParameters marshals |group| as a DER-encoded ECParameters structure
// (RFC 5480), as described in |i2d_SAMPLE|.
//
// Use |EC_KEY_marshal_curve_name| instead.
OPENSSL_EXPORT int i2d_ECPKParameters(const EC_GROUP *group, uint8_t **outp);
// d2i_ECParameters parses a DER-encoded ECParameters structure (RFC 5480) from
// |len| bytes at |*inp|, as described in |d2i_SAMPLE|.
// |len| bytes at |*inp|, as described in |d2i_SAMPLE|. It returns the result as
// an |EC_KEY| with parameters, but no key, configured.
//
// Use |EC_KEY_parse_parameters| or |EC_KEY_parse_curve_name| instead.
OPENSSL_EXPORT EC_KEY *d2i_ECParameters(EC_KEY **out_key, const uint8_t **inp,
@@ -495,7 +495,7 @@ OPENSSL_EXPORT int PKCS5_PBKDF2_HMAC_SHA1(const char *password,
// as described below.
//
// |N|, |r|, and |p| are as described in RFC 7914 section 6. They determine the
// cost of the operation. If |max_mem| is zero, a defult limit of 32MiB will be
// cost of the operation. If |max_mem| is zero, a default limit of 32MiB will be
// used.
//
// The parameters are considered invalid under any of the following conditions:
@@ -111,6 +111,11 @@ OPENSSL_EXPORT int RSA_up_ref(RSA *rsa);
// Properties.
// OPENSSL_RSA_MAX_MODULUS_BITS is the maximum supported RSA modulus, in bits.
//
// TODO(davidben): Reduce this to 8192.
#define OPENSSL_RSA_MAX_MODULUS_BITS 16384
// RSA_bits returns the size of |rsa|, in bits.
OPENSSL_EXPORT unsigned RSA_bits(const RSA *rsa);
@@ -670,11 +675,8 @@ OPENSSL_EXPORT void *RSA_get_ex_data(const RSA *rsa, int idx);
#define RSA_FLAG_OPAQUE 1
// RSA_FLAG_NO_BLINDING disables blinding of private operations, which is a
// dangerous thing to do. It is deprecated and should not be used. It will
// be ignored whenever possible.
//
// This flag must be used if a key without the public exponent |e| is used for
// private key operations; avoid using such keys whenever possible.
// dangerous thing to do. This flag is set internally as part of self-tests but
// is otherwise impossible to set externally.
#define RSA_FLAG_NO_BLINDING 8
// RSA_FLAG_EXT_PKEY is deprecated and ignored.
@@ -712,6 +714,9 @@ OPENSSL_EXPORT int RSA_test_flags(const RSA *rsa, int flags);
// RSA_blinding_on returns one.
OPENSSL_EXPORT int RSA_blinding_on(RSA *rsa, BN_CTX *ctx);
// RSA_blinding_off does nothing.
OPENSSL_EXPORT void RSA_blinding_off(RSA *rsa);
// RSA_generate_key behaves like |RSA_generate_key_ex|, which is what you
// should use instead. It returns NULL on error, or a newly-allocated |RSA| on
// success. This function is provided for compatibility only. The |callback|
@@ -130,7 +130,7 @@ 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 one on success and zero on programmer error.
// returns 1.
OPENSSL_EXPORT int SHA224_Final(uint8_t out[SHA224_DIGEST_LENGTH],
SHA256_CTX *sha);
@@ -181,14 +181,6 @@ 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;
};
// SHA-384.
// SHA384_CBLOCK is the block size of SHA-384.
@@ -248,14 +240,6 @@ OPENSSL_EXPORT uint8_t *SHA512(const uint8_t *data, size_t len,
OPENSSL_EXPORT void SHA512_Transform(SHA512_CTX *sha,
const uint8_t block[SHA512_CBLOCK]);
struct sha512_state_st {
uint64_t h[8];
uint64_t Nl, Nh;
uint8_t p[128];
unsigned num, md_len;
};
// SHA-512-256
//
// See https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf section 5.3.6
@@ -0,0 +1,79 @@
/* Copyright (c) 2024, Google LLC
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
#ifndef OPENSSL_HEADER_SLHDSA_H
#define OPENSSL_HEADER_SLHDSA_H
#include "CCryptoBoringSSL_base.h"
#if defined(__cplusplus)
extern "C" {
#endif
// 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_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_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_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_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);
#if defined(__cplusplus)
} // extern C
#endif
#endif // OPENSSL_HEADER_SLHDSA_H
@@ -234,6 +234,11 @@ constexpr auto MakeSpan(C &c) -> decltype(MakeSpan(c.data(), c.size())) {
return MakeSpan(c.data(), c.size());
}
template <typename T, size_t N>
constexpr Span<T> MakeSpan(T (&array)[N]) {
return Span<T>(array, N);
}
template <typename T>
constexpr Span<const T> MakeConstSpan(T *ptr, size_t size) {
return Span<const T>(ptr, size);
@@ -215,6 +215,24 @@
%xdefine _BCM_sha1_init _ %+ BORINGSSL_PREFIX %+ _BCM_sha1_init
%xdefine _BCM_sha1_transform _ %+ BORINGSSL_PREFIX %+ _BCM_sha1_transform
%xdefine _BCM_sha1_update _ %+ BORINGSSL_PREFIX %+ _BCM_sha1_update
%xdefine _BCM_sha224_final _ %+ BORINGSSL_PREFIX %+ _BCM_sha224_final
%xdefine _BCM_sha224_init _ %+ BORINGSSL_PREFIX %+ _BCM_sha224_init
%xdefine _BCM_sha224_update _ %+ BORINGSSL_PREFIX %+ _BCM_sha224_update
%xdefine _BCM_sha256_final _ %+ BORINGSSL_PREFIX %+ _BCM_sha256_final
%xdefine _BCM_sha256_init _ %+ BORINGSSL_PREFIX %+ _BCM_sha256_init
%xdefine _BCM_sha256_transform _ %+ BORINGSSL_PREFIX %+ _BCM_sha256_transform
%xdefine _BCM_sha256_transform_blocks _ %+ BORINGSSL_PREFIX %+ _BCM_sha256_transform_blocks
%xdefine _BCM_sha256_update _ %+ BORINGSSL_PREFIX %+ _BCM_sha256_update
%xdefine _BCM_sha384_final _ %+ BORINGSSL_PREFIX %+ _BCM_sha384_final
%xdefine _BCM_sha384_init _ %+ BORINGSSL_PREFIX %+ _BCM_sha384_init
%xdefine _BCM_sha384_update _ %+ BORINGSSL_PREFIX %+ _BCM_sha384_update
%xdefine _BCM_sha512_256_final _ %+ BORINGSSL_PREFIX %+ _BCM_sha512_256_final
%xdefine _BCM_sha512_256_init _ %+ BORINGSSL_PREFIX %+ _BCM_sha512_256_init
%xdefine _BCM_sha512_256_update _ %+ BORINGSSL_PREFIX %+ _BCM_sha512_256_update
%xdefine _BCM_sha512_final _ %+ BORINGSSL_PREFIX %+ _BCM_sha512_final
%xdefine _BCM_sha512_init _ %+ BORINGSSL_PREFIX %+ _BCM_sha512_init
%xdefine _BCM_sha512_transform _ %+ BORINGSSL_PREFIX %+ _BCM_sha512_transform
%xdefine _BCM_sha512_update _ %+ BORINGSSL_PREFIX %+ _BCM_sha512_update
%xdefine _BIO_append_filename _ %+ BORINGSSL_PREFIX %+ _BIO_append_filename
%xdefine _BIO_callback_ctrl _ %+ BORINGSSL_PREFIX %+ _BIO_callback_ctrl
%xdefine _BIO_clear_flags _ %+ BORINGSSL_PREFIX %+ _BIO_clear_flags
@@ -629,6 +647,7 @@
%xdefine _CRYPTO_get_fork_generation _ %+ BORINGSSL_PREFIX %+ _CRYPTO_get_fork_generation
%xdefine _CRYPTO_get_lock_name _ %+ BORINGSSL_PREFIX %+ _CRYPTO_get_lock_name
%xdefine _CRYPTO_get_locking_callback _ %+ BORINGSSL_PREFIX %+ _CRYPTO_get_locking_callback
%xdefine _CRYPTO_get_stderr _ %+ BORINGSSL_PREFIX %+ _CRYPTO_get_stderr
%xdefine _CRYPTO_get_thread_local _ %+ BORINGSSL_PREFIX %+ _CRYPTO_get_thread_local
%xdefine _CRYPTO_ghash_init _ %+ BORINGSSL_PREFIX %+ _CRYPTO_ghash_init
%xdefine _CRYPTO_has_asm _ %+ BORINGSSL_PREFIX %+ _CRYPTO_has_asm
@@ -1670,6 +1689,7 @@
%xdefine _RSA_PSS_PARAMS_new _ %+ BORINGSSL_PREFIX %+ _RSA_PSS_PARAMS_new
%xdefine _RSA_add_pkcs1_prefix _ %+ BORINGSSL_PREFIX %+ _RSA_add_pkcs1_prefix
%xdefine _RSA_bits _ %+ BORINGSSL_PREFIX %+ _RSA_bits
%xdefine _RSA_blinding_off _ %+ BORINGSSL_PREFIX %+ _RSA_blinding_off
%xdefine _RSA_blinding_on _ %+ BORINGSSL_PREFIX %+ _RSA_blinding_on
%xdefine _RSA_check_fips _ %+ BORINGSSL_PREFIX %+ _RSA_check_fips
%xdefine _RSA_check_key _ %+ BORINGSSL_PREFIX %+ _RSA_check_key
@@ -1766,6 +1786,13 @@
%xdefine _SHA512_Transform _ %+ BORINGSSL_PREFIX %+ _SHA512_Transform
%xdefine _SHA512_Update _ %+ BORINGSSL_PREFIX %+ _SHA512_Update
%xdefine _SIPHASH_24 _ %+ BORINGSSL_PREFIX %+ _SIPHASH_24
%xdefine _SLHDSA_SHA2_128S_generate_key _ %+ BORINGSSL_PREFIX %+ _SLHDSA_SHA2_128S_generate_key
%xdefine _SLHDSA_SHA2_128S_generate_key_from_seed _ %+ BORINGSSL_PREFIX %+ _SLHDSA_SHA2_128S_generate_key_from_seed
%xdefine _SLHDSA_SHA2_128S_public_from_private _ %+ BORINGSSL_PREFIX %+ _SLHDSA_SHA2_128S_public_from_private
%xdefine _SLHDSA_SHA2_128S_sign _ %+ BORINGSSL_PREFIX %+ _SLHDSA_SHA2_128S_sign
%xdefine _SLHDSA_SHA2_128S_sign_internal _ %+ BORINGSSL_PREFIX %+ _SLHDSA_SHA2_128S_sign_internal
%xdefine _SLHDSA_SHA2_128S_verify _ %+ BORINGSSL_PREFIX %+ _SLHDSA_SHA2_128S_verify
%xdefine _SLHDSA_SHA2_128S_verify_internal _ %+ BORINGSSL_PREFIX %+ _SLHDSA_SHA2_128S_verify_internal
%xdefine _SPAKE2_CTX_free _ %+ BORINGSSL_PREFIX %+ _SPAKE2_CTX_free
%xdefine _SPAKE2_CTX_new _ %+ BORINGSSL_PREFIX %+ _SPAKE2_CTX_new
%xdefine _SPAKE2_generate_msg _ %+ BORINGSSL_PREFIX %+ _SPAKE2_generate_msg
@@ -2458,6 +2485,7 @@
%xdefine _d2i_DSA_SIG _ %+ BORINGSSL_PREFIX %+ _d2i_DSA_SIG
%xdefine _d2i_DSAparams _ %+ BORINGSSL_PREFIX %+ _d2i_DSAparams
%xdefine _d2i_ECDSA_SIG _ %+ BORINGSSL_PREFIX %+ _d2i_ECDSA_SIG
%xdefine _d2i_ECPKParameters _ %+ BORINGSSL_PREFIX %+ _d2i_ECPKParameters
%xdefine _d2i_ECParameters _ %+ BORINGSSL_PREFIX %+ _d2i_ECParameters
%xdefine _d2i_ECPrivateKey _ %+ BORINGSSL_PREFIX %+ _d2i_ECPrivateKey
%xdefine _d2i_ECPrivateKey_bio _ %+ BORINGSSL_PREFIX %+ _d2i_ECPrivateKey_bio
@@ -2726,6 +2754,7 @@
%xdefine _i2d_DSA_SIG _ %+ BORINGSSL_PREFIX %+ _i2d_DSA_SIG
%xdefine _i2d_DSAparams _ %+ BORINGSSL_PREFIX %+ _i2d_DSAparams
%xdefine _i2d_ECDSA_SIG _ %+ BORINGSSL_PREFIX %+ _i2d_ECDSA_SIG
%xdefine _i2d_ECPKParameters _ %+ BORINGSSL_PREFIX %+ _i2d_ECPKParameters
%xdefine _i2d_ECParameters _ %+ BORINGSSL_PREFIX %+ _i2d_ECParameters
%xdefine _i2d_ECPrivateKey _ %+ BORINGSSL_PREFIX %+ _i2d_ECPrivateKey
%xdefine _i2d_ECPrivateKey_bio _ %+ BORINGSSL_PREFIX %+ _i2d_ECPrivateKey_bio
@@ -2891,6 +2920,25 @@
%xdefine _sk_pop_free_ex _ %+ BORINGSSL_PREFIX %+ _sk_pop_free_ex
%xdefine _sk_push _ %+ BORINGSSL_PREFIX %+ _sk_push
%xdefine _sk_value _ %+ BORINGSSL_PREFIX %+ _sk_value
%xdefine _slhdsa_fors_pk_from_sig _ %+ BORINGSSL_PREFIX %+ _slhdsa_fors_pk_from_sig
%xdefine _slhdsa_fors_sign _ %+ BORINGSSL_PREFIX %+ _slhdsa_fors_sign
%xdefine _slhdsa_fors_sk_gen _ %+ BORINGSSL_PREFIX %+ _slhdsa_fors_sk_gen
%xdefine _slhdsa_fors_treehash _ %+ BORINGSSL_PREFIX %+ _slhdsa_fors_treehash
%xdefine _slhdsa_ht_sign _ %+ BORINGSSL_PREFIX %+ _slhdsa_ht_sign
%xdefine _slhdsa_ht_verify _ %+ BORINGSSL_PREFIX %+ _slhdsa_ht_verify
%xdefine _slhdsa_thash_f _ %+ BORINGSSL_PREFIX %+ _slhdsa_thash_f
%xdefine _slhdsa_thash_h _ %+ BORINGSSL_PREFIX %+ _slhdsa_thash_h
%xdefine _slhdsa_thash_hmsg _ %+ BORINGSSL_PREFIX %+ _slhdsa_thash_hmsg
%xdefine _slhdsa_thash_prf _ %+ BORINGSSL_PREFIX %+ _slhdsa_thash_prf
%xdefine _slhdsa_thash_prfmsg _ %+ BORINGSSL_PREFIX %+ _slhdsa_thash_prfmsg
%xdefine _slhdsa_thash_tk _ %+ BORINGSSL_PREFIX %+ _slhdsa_thash_tk
%xdefine _slhdsa_thash_tl _ %+ BORINGSSL_PREFIX %+ _slhdsa_thash_tl
%xdefine _slhdsa_treehash _ %+ BORINGSSL_PREFIX %+ _slhdsa_treehash
%xdefine _slhdsa_wots_pk_from_sig _ %+ BORINGSSL_PREFIX %+ _slhdsa_wots_pk_from_sig
%xdefine _slhdsa_wots_pk_gen _ %+ BORINGSSL_PREFIX %+ _slhdsa_wots_pk_gen
%xdefine _slhdsa_wots_sign _ %+ BORINGSSL_PREFIX %+ _slhdsa_wots_sign
%xdefine _slhdsa_xmss_pk_from_sig _ %+ BORINGSSL_PREFIX %+ _slhdsa_xmss_pk_from_sig
%xdefine _slhdsa_xmss_sign _ %+ BORINGSSL_PREFIX %+ _slhdsa_xmss_sign
%xdefine _spx_base_b _ %+ BORINGSSL_PREFIX %+ _spx_base_b
%xdefine _spx_copy_keypair_addr _ %+ BORINGSSL_PREFIX %+ _spx_copy_keypair_addr
%xdefine _spx_fors_pk_from_sig _ %+ BORINGSSL_PREFIX %+ _spx_fors_pk_from_sig
@@ -3204,6 +3252,24 @@
%xdefine BCM_sha1_init BORINGSSL_PREFIX %+ _BCM_sha1_init
%xdefine BCM_sha1_transform BORINGSSL_PREFIX %+ _BCM_sha1_transform
%xdefine BCM_sha1_update BORINGSSL_PREFIX %+ _BCM_sha1_update
%xdefine BCM_sha224_final BORINGSSL_PREFIX %+ _BCM_sha224_final
%xdefine BCM_sha224_init BORINGSSL_PREFIX %+ _BCM_sha224_init
%xdefine BCM_sha224_update BORINGSSL_PREFIX %+ _BCM_sha224_update
%xdefine BCM_sha256_final BORINGSSL_PREFIX %+ _BCM_sha256_final
%xdefine BCM_sha256_init BORINGSSL_PREFIX %+ _BCM_sha256_init
%xdefine BCM_sha256_transform BORINGSSL_PREFIX %+ _BCM_sha256_transform
%xdefine BCM_sha256_transform_blocks BORINGSSL_PREFIX %+ _BCM_sha256_transform_blocks
%xdefine BCM_sha256_update BORINGSSL_PREFIX %+ _BCM_sha256_update
%xdefine BCM_sha384_final BORINGSSL_PREFIX %+ _BCM_sha384_final
%xdefine BCM_sha384_init BORINGSSL_PREFIX %+ _BCM_sha384_init
%xdefine BCM_sha384_update BORINGSSL_PREFIX %+ _BCM_sha384_update
%xdefine BCM_sha512_256_final BORINGSSL_PREFIX %+ _BCM_sha512_256_final
%xdefine BCM_sha512_256_init BORINGSSL_PREFIX %+ _BCM_sha512_256_init
%xdefine BCM_sha512_256_update BORINGSSL_PREFIX %+ _BCM_sha512_256_update
%xdefine BCM_sha512_final BORINGSSL_PREFIX %+ _BCM_sha512_final
%xdefine BCM_sha512_init BORINGSSL_PREFIX %+ _BCM_sha512_init
%xdefine BCM_sha512_transform BORINGSSL_PREFIX %+ _BCM_sha512_transform
%xdefine BCM_sha512_update BORINGSSL_PREFIX %+ _BCM_sha512_update
%xdefine BIO_append_filename BORINGSSL_PREFIX %+ _BIO_append_filename
%xdefine BIO_callback_ctrl BORINGSSL_PREFIX %+ _BIO_callback_ctrl
%xdefine BIO_clear_flags BORINGSSL_PREFIX %+ _BIO_clear_flags
@@ -3618,6 +3684,7 @@
%xdefine CRYPTO_get_fork_generation BORINGSSL_PREFIX %+ _CRYPTO_get_fork_generation
%xdefine CRYPTO_get_lock_name BORINGSSL_PREFIX %+ _CRYPTO_get_lock_name
%xdefine CRYPTO_get_locking_callback BORINGSSL_PREFIX %+ _CRYPTO_get_locking_callback
%xdefine CRYPTO_get_stderr BORINGSSL_PREFIX %+ _CRYPTO_get_stderr
%xdefine CRYPTO_get_thread_local BORINGSSL_PREFIX %+ _CRYPTO_get_thread_local
%xdefine CRYPTO_ghash_init BORINGSSL_PREFIX %+ _CRYPTO_ghash_init
%xdefine CRYPTO_has_asm BORINGSSL_PREFIX %+ _CRYPTO_has_asm
@@ -4659,6 +4726,7 @@
%xdefine RSA_PSS_PARAMS_new BORINGSSL_PREFIX %+ _RSA_PSS_PARAMS_new
%xdefine RSA_add_pkcs1_prefix BORINGSSL_PREFIX %+ _RSA_add_pkcs1_prefix
%xdefine RSA_bits BORINGSSL_PREFIX %+ _RSA_bits
%xdefine RSA_blinding_off BORINGSSL_PREFIX %+ _RSA_blinding_off
%xdefine RSA_blinding_on BORINGSSL_PREFIX %+ _RSA_blinding_on
%xdefine RSA_check_fips BORINGSSL_PREFIX %+ _RSA_check_fips
%xdefine RSA_check_key BORINGSSL_PREFIX %+ _RSA_check_key
@@ -4755,6 +4823,13 @@
%xdefine SHA512_Transform BORINGSSL_PREFIX %+ _SHA512_Transform
%xdefine SHA512_Update BORINGSSL_PREFIX %+ _SHA512_Update
%xdefine SIPHASH_24 BORINGSSL_PREFIX %+ _SIPHASH_24
%xdefine SLHDSA_SHA2_128S_generate_key BORINGSSL_PREFIX %+ _SLHDSA_SHA2_128S_generate_key
%xdefine SLHDSA_SHA2_128S_generate_key_from_seed BORINGSSL_PREFIX %+ _SLHDSA_SHA2_128S_generate_key_from_seed
%xdefine SLHDSA_SHA2_128S_public_from_private BORINGSSL_PREFIX %+ _SLHDSA_SHA2_128S_public_from_private
%xdefine SLHDSA_SHA2_128S_sign BORINGSSL_PREFIX %+ _SLHDSA_SHA2_128S_sign
%xdefine SLHDSA_SHA2_128S_sign_internal BORINGSSL_PREFIX %+ _SLHDSA_SHA2_128S_sign_internal
%xdefine SLHDSA_SHA2_128S_verify BORINGSSL_PREFIX %+ _SLHDSA_SHA2_128S_verify
%xdefine SLHDSA_SHA2_128S_verify_internal BORINGSSL_PREFIX %+ _SLHDSA_SHA2_128S_verify_internal
%xdefine SPAKE2_CTX_free BORINGSSL_PREFIX %+ _SPAKE2_CTX_free
%xdefine SPAKE2_CTX_new BORINGSSL_PREFIX %+ _SPAKE2_CTX_new
%xdefine SPAKE2_generate_msg BORINGSSL_PREFIX %+ _SPAKE2_generate_msg
@@ -5447,6 +5522,7 @@
%xdefine d2i_DSA_SIG BORINGSSL_PREFIX %+ _d2i_DSA_SIG
%xdefine d2i_DSAparams BORINGSSL_PREFIX %+ _d2i_DSAparams
%xdefine d2i_ECDSA_SIG BORINGSSL_PREFIX %+ _d2i_ECDSA_SIG
%xdefine d2i_ECPKParameters BORINGSSL_PREFIX %+ _d2i_ECPKParameters
%xdefine d2i_ECParameters BORINGSSL_PREFIX %+ _d2i_ECParameters
%xdefine d2i_ECPrivateKey BORINGSSL_PREFIX %+ _d2i_ECPrivateKey
%xdefine d2i_ECPrivateKey_bio BORINGSSL_PREFIX %+ _d2i_ECPrivateKey_bio
@@ -5715,6 +5791,7 @@
%xdefine i2d_DSA_SIG BORINGSSL_PREFIX %+ _i2d_DSA_SIG
%xdefine i2d_DSAparams BORINGSSL_PREFIX %+ _i2d_DSAparams
%xdefine i2d_ECDSA_SIG BORINGSSL_PREFIX %+ _i2d_ECDSA_SIG
%xdefine i2d_ECPKParameters BORINGSSL_PREFIX %+ _i2d_ECPKParameters
%xdefine i2d_ECParameters BORINGSSL_PREFIX %+ _i2d_ECParameters
%xdefine i2d_ECPrivateKey BORINGSSL_PREFIX %+ _i2d_ECPrivateKey
%xdefine i2d_ECPrivateKey_bio BORINGSSL_PREFIX %+ _i2d_ECPrivateKey_bio
@@ -5880,6 +5957,25 @@
%xdefine sk_pop_free_ex BORINGSSL_PREFIX %+ _sk_pop_free_ex
%xdefine sk_push BORINGSSL_PREFIX %+ _sk_push
%xdefine sk_value BORINGSSL_PREFIX %+ _sk_value
%xdefine slhdsa_fors_pk_from_sig BORINGSSL_PREFIX %+ _slhdsa_fors_pk_from_sig
%xdefine slhdsa_fors_sign BORINGSSL_PREFIX %+ _slhdsa_fors_sign
%xdefine slhdsa_fors_sk_gen BORINGSSL_PREFIX %+ _slhdsa_fors_sk_gen
%xdefine slhdsa_fors_treehash BORINGSSL_PREFIX %+ _slhdsa_fors_treehash
%xdefine slhdsa_ht_sign BORINGSSL_PREFIX %+ _slhdsa_ht_sign
%xdefine slhdsa_ht_verify BORINGSSL_PREFIX %+ _slhdsa_ht_verify
%xdefine slhdsa_thash_f BORINGSSL_PREFIX %+ _slhdsa_thash_f
%xdefine slhdsa_thash_h BORINGSSL_PREFIX %+ _slhdsa_thash_h
%xdefine slhdsa_thash_hmsg BORINGSSL_PREFIX %+ _slhdsa_thash_hmsg
%xdefine slhdsa_thash_prf BORINGSSL_PREFIX %+ _slhdsa_thash_prf
%xdefine slhdsa_thash_prfmsg BORINGSSL_PREFIX %+ _slhdsa_thash_prfmsg
%xdefine slhdsa_thash_tk BORINGSSL_PREFIX %+ _slhdsa_thash_tk
%xdefine slhdsa_thash_tl BORINGSSL_PREFIX %+ _slhdsa_thash_tl
%xdefine slhdsa_treehash BORINGSSL_PREFIX %+ _slhdsa_treehash
%xdefine slhdsa_wots_pk_from_sig BORINGSSL_PREFIX %+ _slhdsa_wots_pk_from_sig
%xdefine slhdsa_wots_pk_gen BORINGSSL_PREFIX %+ _slhdsa_wots_pk_gen
%xdefine slhdsa_wots_sign BORINGSSL_PREFIX %+ _slhdsa_wots_sign
%xdefine slhdsa_xmss_pk_from_sig BORINGSSL_PREFIX %+ _slhdsa_xmss_pk_from_sig
%xdefine slhdsa_xmss_sign BORINGSSL_PREFIX %+ _slhdsa_xmss_sign
%xdefine spx_base_b BORINGSSL_PREFIX %+ _spx_base_b
%xdefine spx_copy_keypair_addr BORINGSSL_PREFIX %+ _spx_copy_keypair_addr
%xdefine spx_fors_pk_from_sig BORINGSSL_PREFIX %+ _spx_fors_pk_from_sig
+1 -1
View File
@@ -6,7 +6,7 @@
## Licensed under Apache License v2.0
##
## See LICENSE.txt for license information
## See CONTRIBUTORS.md for the list of SwiftCrypto project authors
## See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
##
## SPDX-License-Identifier: Apache-2.0
##
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
@@ -134,6 +134,20 @@ int CCryptoBoringSSLShims_EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx, void *out,
size_t *out_len, const void *in,
size_t in_len);
int CCryptoBoringSSLShims_EC_hash_to_curve_p256_xmd_sha256_sswu(const EC_GROUP *group, EC_POINT *out,
const void *dst, size_t dst_len,
const void *msg, size_t msg_len);
int CCryptoBoringSSLShims_EC_hash_to_curve_p384_xmd_sha384_sswu(const EC_GROUP *group, EC_POINT *out,
const void *dst, size_t dst_len,
const void *msg, size_t msg_len);
size_t CCryptoBoringSSLShims_EC_POINT_point2oct(const EC_GROUP *group,
const EC_POINT *point,
point_conversion_form_t form,
void *buf, size_t max_out,
BN_CTX *ctx);
#if defined(__cplusplus)
}
#endif // defined(__cplusplus)
+21 -1
View File
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
@@ -168,3 +168,23 @@ int CCryptoBoringSSLShims_EVP_PKEY_decrypt(EVP_PKEY_CTX *ctx, void *out,
size_t in_len) {
return CCryptoBoringSSL_EVP_PKEY_decrypt(ctx, out, out_len, in, in_len);
}
int CCryptoBoringSSLShims_EC_hash_to_curve_p256_xmd_sha256_sswu(const EC_GROUP *group, EC_POINT *out,
const void *dst, size_t dst_len,
const void *msg, size_t msg_len) {
return CCryptoBoringSSL_EC_hash_to_curve_p256_xmd_sha256_sswu(group, out, dst, dst_len, msg, msg_len);
}
int CCryptoBoringSSLShims_EC_hash_to_curve_p384_xmd_sha384_sswu(const EC_GROUP *group, EC_POINT *out,
const void *dst, size_t dst_len,
const void *msg, size_t msg_len) {
return CCryptoBoringSSL_EC_hash_to_curve_p384_xmd_sha384_sswu(group, out, dst, dst_len, msg, msg_len);
}
size_t CCryptoBoringSSLShims_EC_POINT_point2oct(const EC_GROUP *group,
const EC_POINT *point,
point_conversion_form_t form,
void *buf, size_t max_out,
BN_CTX *ctx) {
return CCryptoBoringSSL_EC_POINT_point2oct(group, point, form, buf, max_out, ctx);
}
+1 -1
View File
@@ -6,7 +6,7 @@
## Licensed under Apache License v2.0
##
## See LICENSE.txt for license information
## See CONTRIBUTORS.md for the list of SwiftCrypto project authors
## See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
##
## SPDX-License-Identifier: Apache-2.0
##
+1 -1
View File
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
@@ -15,7 +15,7 @@
@_exported import CryptoKit
#else
@_implementationOnly import CCryptoBoringSSL
@_implementationOnly import CryptoBoringWrapper
import CryptoBoringWrapper
import Foundation
enum OpenSSLAESGCMImpl {
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
@@ -16,7 +16,7 @@
#else
@_implementationOnly import CCryptoBoringSSL
@_implementationOnly import CCryptoBoringSSLShims
@_implementationOnly import CryptoBoringWrapper
import CryptoBoringWrapper
import Foundation
extension BoringSSLAEAD {
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
+1 -1
View File
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
+1 -1
View File
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
+1 -1
View File
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
+1 -1
View File
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
+1 -1
View File
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
+1 -1
View File
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
+1 -1
View File
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
+1 -1
View File
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
+2 -5
View File
@@ -6,7 +6,7 @@
## Licensed under Apache License v2.0
##
## See LICENSE.txt for license information
## See CONTRIBUTORS.md for the list of SwiftCrypto project authors
## See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
##
## SPDX-License-Identifier: Apache-2.0
##
@@ -67,8 +67,6 @@ add_library(Crypto
"Key Wrapping/AESWrap.swift"
"Key Wrapping/BoringSSL/AESWrap_boring.swift"
"Keys/EC/BoringSSL/Ed25519_boring.swift"
"Keys/EC/BoringSSL/EllipticCurvePoint_boring.swift"
"Keys/EC/BoringSSL/EllipticCurve_boring.swift"
"Keys/EC/BoringSSL/NISTCurvesKeys_boring.swift"
"Keys/EC/BoringSSL/X25519Keys_boring.swift"
"Keys/EC/Curve25519.swift"
@@ -89,8 +87,6 @@ add_library(Crypto
"Util/BoringSSL/CryptoKitErrors_boring.swift"
"Util/BoringSSL/RNG_boring.swift"
"Util/BoringSSL/SafeCompare_boring.swift"
"Util/BoringSSL/Shared/ArbitraryPrecisionInteger_boring.swift"
"Util/BoringSSL/Shared/FiniteFieldArithmeticContext_boring.swift"
"Util/BoringSSL/Zeroization_boring.swift"
"Util/PrettyBytes.swift"
"Util/SafeCompare.swift"
@@ -115,6 +111,7 @@ target_link_libraries(Crypto PUBLIC
CCryptoBoringSSL
CCryptoBoringSSLShims
CryptoBoringWrapper)
target_compile_options(Crypto PRIVATE ${SWIFT_CRYPTO_COMPILE_OPTIONS})
set_target_properties(Crypto PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_Swift_MODULE_DIRECTORY})
+1 -1
View File
@@ -6,7 +6,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
Loaded 100 of 288 files, more files were not shown because too many files have changed in this diff. Show more