Compare commits

...
8 Commits
Author SHA1 Message Date
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
Si Beaumont ffca28be3c crypto: Equatable and Hashable conformance for CryptoKitError and CryptoKitASN1Error (#266) 2024-10-02 09:59:06 +01:00
Si Beaumont 35703579f6 Drop support for Swift 5.8 (#259) 2024-09-19 13:55:18 +01:00
George Barnett a24950b8aa Only include privacy manifest on Darwin (#257)
Motivation:

The privacy manifest is only required on Darwin. It's currently included
on all platforms which results in build warnings.

Modifications:

- Only include manifest on Darwin
- Exclude the privacy manifest from the build on other platforms

Result:

- Fewer warnings
- Resolves #256
2024-09-18 17:21:21 +01:00
Paul Toffoloni e8f2ddd49e extras: Add API to create RSA keys with random primes (#250)
This adds a _createFromNumbers API which creates an RSA key generating p and q primes based on n, e and d

Motivation:

There might be cases where private RSA keys have to be generated based on their raw elements (modulus n, exponent e and private exponent d) without p and q. These are random primes which are integral parts of the key but can be generated based on the former numbers, and are not always included when representing RSA keys, for example these parameters are not required in JWKs

Modifications:

This adds a static _createFromNumbers method which creates a new RSA key given its raw modulus, exponent and private exponent, generating the needed p and q primes without having to provide them as parameters. The algorithm to generate primes is based on a hybrid approach of the Miller Rabin primality test and the proof of Fact 1 in Dan Boneh's Twenty Years of Attacks on the RSA Cryptosystem paper. To write this algorithm, some additions had to be made to the ArbitraryPrecisionInteger

Result:

Private RSA keys can now be generated without providing p and q
2024-09-16 13:52:23 +01:00
Paul ToffoloniandCory Benfield 55201a8f83 extras: Add RSA primitives decoding API (#249)
Motivation:

At times we might need to get the raw elements of an RSA key, e.g when debugging.

Modifications:

Add a getKeyPrimitives method to the RSA (public and private) key structures that returns the elements.
To do this we leverage the built in BoringSSL methods (CCryptoBoringSSL_RSA_get0_n etc.) which return the raw elements of the key. In the Security version of the key we convert the key to a BoringSSL one and just call the BoringSSL method.

Once we get ASN.1 support in _CryptoExtras it might make sense switching the implementation of this method to decode the ASN.1 structure and returns the elements from there.

Result:

New APIs to fetch the key primitives.

---------

Co-authored-by: Cory Benfield <lukasa@apple.com>
2024-09-16 04:34:21 -07:00
85 changed files with 3042 additions and 413 deletions

No files matched your search

+14
View File
@@ -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)
+31 -25
View File
@@ -1,4 +1,4 @@
// swift-tools-version:5.8
// swift-tools-version:5.9
//===----------------------------------------------------------------------===//
//
// This source file is part of the SwiftCrypto open source project
@@ -20,7 +20,7 @@
// Sources/CCryptoBoringSSL directory. The source repository is at
// https://boringssl.googlesource.com/boringssl.
//
// BoringSSL Commit: 6a2ccdcc2ed1d37a43a2183658d2ae61fd5ce208
// BoringSSL Commit: 76968bb3d53982560bcf08bcd0ba3e1865fe15cd
import PackageDescription
@@ -57,6 +57,18 @@ if development {
]
}
// This doesn't work when cross-compiling: the privacy manifest will be included in the Bundle and
// Foundation will be linked. This is, however, strictly better than unconditionally adding the
// resource.
#if canImport(Darwin)
let privacyManifestExclude: [String] = []
let privacyManifestResource: [PackageDescription.Resource] = [.copy("PrivacyInfo.xcprivacy")]
#else
// Exclude on other platforms to avoid build warnings.
let privacyManifestExclude: [String] = ["PrivacyInfo.xcprivacy"]
let privacyManifestResource: [PackageDescription.Resource] = []
#endif
let package = Package(
name: "swift-crypto",
platforms: [
@@ -72,11 +84,13 @@ 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",
exclude: [
exclude: privacyManifestExclude + [
"hash.txt",
"include/boringssl_prefix_symbols_nasm.inc",
"CMakeLists.txt",
@@ -88,9 +102,7 @@ let package = Package(
"crypto/bio/socket_helper.c",
"crypto/bio/socket.c"
],
resources: [
.copy("PrivacyInfo.xcprivacy"),
],
resources: privacyManifestResource,
cSettings: [
// These defines come from BoringSSL's build system
.define("_HAS_EXCEPTIONS", to: "0", .when(platforms: [Platform.windows])),
@@ -107,27 +119,23 @@ let package = Package(
.target(
name: "CCryptoBoringSSLShims",
dependencies: ["CCryptoBoringSSL"],
exclude: [
exclude: privacyManifestExclude + [
"CMakeLists.txt"
],
resources: [
.copy("PrivacyInfo.xcprivacy"),
]
resources: privacyManifestResource
),
.target(
name: "Crypto",
dependencies: dependencies,
exclude: [
exclude: privacyManifestExclude + [
"CMakeLists.txt",
"AEADs/Nonces.swift.gyb",
"Digests/Digests.swift.gyb",
"Key Agreement/ECDH.swift.gyb",
"Signatures/ECDSA.swift.gyb",
],
resources: [
.copy("PrivacyInfo.xcprivacy"),
],
swiftSettings: swiftSettings + [.define("MODULE_IS_CRYPTO")]
resources: privacyManifestResource,
swiftSettings: swiftSettings
),
.target(
name: "_CryptoExtras",
@@ -135,14 +143,13 @@ let package = Package(
"CCryptoBoringSSL",
"CCryptoBoringSSLShims",
"CryptoBoringWrapper",
"Crypto"
"Crypto",
.product(name: "SwiftASN1", package: "swift-asn1")
],
exclude: [
exclude: privacyManifestExclude + [
"CMakeLists.txt",
],
resources: [
.copy("PrivacyInfo.xcprivacy"),
],
resources: privacyManifestResource,
swiftSettings: swiftSettings
),
.target(
@@ -151,12 +158,10 @@ let package = Package(
"CCryptoBoringSSL",
"CCryptoBoringSSLShims"
],
exclude: [
exclude: privacyManifestExclude + [
"CMakeLists.txt",
],
resources: [
.copy("PrivacyInfo.xcprivacy"),
]
resources: privacyManifestResource
),
.executableTarget(name: "crypto-shasum", dependencies: ["Crypto"]),
.testTarget(
@@ -168,6 +173,7 @@ let package = Package(
swiftSettings: swiftSettings
),
.testTarget(name: "_CryptoExtrasTests", dependencies: ["_CryptoExtras"]),
.testTarget(name: "CryptoBoringWrapperTests", dependencies: ["CryptoBoringWrapper"]),
],
cxxLanguageStandard: .cxx11
)
+2 -1
View File
@@ -117,7 +117,8 @@ Swift Crypto | Minimum Swift Version
`2.2.0 ..< 2.4.2` | 5.5
`2.4.2 ..< 3.1.0` | 5.6
`3.1.0 ..< 3.3.0` | 5.7
`3.3.0 ...` | 5.8
`3.3.0 ..< 3.8.0` | 5.8
`3.8.0 ...` | 5.9
### Compatibility
+8
View File
@@ -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
@@ -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));
@@ -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 76968bb3d53982560bcf08bcd0ba3e1865fe15cd
@@ -52,12 +52,6 @@
#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
@@ -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,
@@ -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
@@ -15,7 +15,7 @@
@_exported import CryptoKit
#else
@_implementationOnly import CCryptoBoringSSL
@_implementationOnly import CryptoBoringWrapper
import CryptoBoringWrapper
import Foundation
enum OpenSSLAESGCMImpl {
@@ -16,7 +16,7 @@
#else
@_implementationOnly import CCryptoBoringSSL
@_implementationOnly import CCryptoBoringSSLShims
@_implementationOnly import CryptoBoringWrapper
import CryptoBoringWrapper
import Foundation
extension BoringSSLAEAD {
+1 -2
View File
@@ -89,8 +89,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 +113,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})
+3 -1
View File
@@ -33,8 +33,10 @@ public enum CryptoKitError: Error {
case invalidParameter
}
extension CryptoKitError: Equatable, Hashable {}
/// Errors from decoding ASN.1 content.
public enum CryptoKitASN1Error: Error {
public enum CryptoKitASN1Error: Equatable, Error, Hashable {
/// The ASN.1 tag for this field is invalid or unsupported.
case invalidFieldIdentifier
@@ -15,6 +15,7 @@
@_exported import CryptoKit
#else
@_implementationOnly import CCryptoBoringSSL
import CryptoBoringWrapper
/// A wrapper around BoringSSL's EC_POINT with some lifetime management.
@usableFromInline
@@ -15,6 +15,7 @@
@_exported import CryptoKit
#else
@_implementationOnly import CCryptoBoringSSL
import CryptoBoringWrapper
/// A wrapper around BoringSSL's EC_GROUP object that handles reference counting and
/// liveness.
@@ -16,6 +16,7 @@
#else
@_implementationOnly import CCryptoBoringSSL
@_implementationOnly import CCryptoBoringSSLShims
import CryptoBoringWrapper
import Foundation
@usableFromInline
@@ -16,6 +16,7 @@
#else
@_implementationOnly import CCryptoBoringSSL
@_implementationOnly import CCryptoBoringSSLShims
import CryptoBoringWrapper
import Foundation
/// A wrapper around BoringSSL's ECDSA_SIG with some lifetime management.
+5 -1
View File
@@ -14,7 +14,9 @@
add_library(CryptoBoringWrapper STATIC
"AEAD/BoringSSLAEAD.swift"
"CryptoKitErrors_boring.swift")
"CryptoKitErrors_boring.swift"
"Util/ArbitraryPrecisionInteger_boring.swift"
"Util/FiniteFieldArithmeticContext_boring.swift")
target_include_directories(CryptoBoringWrapper PUBLIC
$<TARGET_PROPERTY:CCryptoBoringSSL,INCLUDE_DIRECTORIES>
@@ -25,6 +27,8 @@ target_link_libraries(CryptoBoringWrapper PUBLIC
CCryptoBoringSSL
CCryptoBoringSSLShims)
target_compile_options(CryptoBoringWrapper PRIVATE ${SWIFT_CRYPTO_COMPILE_OPTIONS})
set_target_properties(CryptoBoringWrapper PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_Swift_MODULE_DIRECTORY})
@@ -15,13 +15,27 @@
@_implementationOnly import CCryptoBoringSSL
public enum CryptoBoringWrapperError: Error {
/// The key size is incorrect.
case incorrectKeySize
/// The parameter size is incorrect.
case incorrectParameterSize
/// The authentication tag or signature is incorrect.
case authenticationFailure
/// The underlying corecrypto library is unable to complete the requested
/// action.
case underlyingCoreCryptoError(error: Int32)
/// The framework can't wrap the specified key.
case wrapFailure
/// The framework can't unwrap the specified key.
case unwrapFailure
/// The parameter is invalid.
case invalidParameter
}
extension CryptoBoringWrapperError {
/// A helper function that packs the value of `ERR_get_error` into the internal error field.
@usableFromInline
static func internalBoringSSLError() -> CryptoBoringWrapperError {
package static func internalBoringSSLError() -> CryptoBoringWrapperError {
return .underlyingCoreCryptoError(error: Int32(bitPattern: CCryptoBoringSSL_ERR_get_error()))
}
}
@@ -11,38 +11,35 @@
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
#if MODULE_IS_CRYPTO && CRYPTO_IN_SWIFTPM && !CRYPTO_IN_SWIFTPM_FORCE_BUILD_API
#if CRYPTO_IN_SWIFTPM && !CRYPTO_IN_SWIFTPM_FORCE_BUILD_API
@_exported import CryptoKit
#else
@_implementationOnly import CCryptoBoringSSL
@_implementationOnly import CCryptoBoringSSLShims
import Foundation
#if !MODULE_IS_CRYPTO
import enum Crypto.CryptoKitError
#endif
/// A wrapper around the OpenSSL BIGNUM object that is appropriately lifetime managed,
/// and that provides better Swift types for this object.
@usableFromInline
struct ArbitraryPrecisionInteger {
package struct ArbitraryPrecisionInteger {
private var _backing: BackingStorage
@usableFromInline
init() {
package init() {
self._backing = BackingStorage()
}
init(copying original: UnsafePointer<BIGNUM>) throws {
package init(copying original: UnsafePointer<BIGNUM>) throws {
self._backing = try BackingStorage(copying: original)
}
@usableFromInline
init(_ original: ArbitraryPrecisionInteger) throws {
package init(_ original: ArbitraryPrecisionInteger) throws {
self._backing = try BackingStorage(copying: original._backing)
}
@usableFromInline
init(integerLiteral value: Int64) {
package init(integerLiteral value: Int64) {
self._backing = BackingStorage(value)
}
}
@@ -50,7 +47,7 @@ struct ArbitraryPrecisionInteger {
// MARK: - BackingStorage
extension ArbitraryPrecisionInteger {
final class BackingStorage {
fileprivate final class BackingStorage {
private var _backing: BIGNUM
init() {
@@ -61,7 +58,7 @@ extension ArbitraryPrecisionInteger {
init(copying original: UnsafePointer<BIGNUM>) throws {
self._backing = BIGNUM()
guard CCryptoBoringSSL_BN_copy(&self._backing, original) != nil else {
throw CryptoKitError.internalBoringSSLError()
throw CryptoBoringWrapperError.internalBoringSSLError()
}
}
@@ -70,7 +67,7 @@ extension ArbitraryPrecisionInteger {
try original.withUnsafeMutableBignumPointer { bnPtr in
guard CCryptoBoringSSL_BN_copy(&self._backing, bnPtr) != nil else {
throw CryptoKitError.internalBoringSSLError()
throw CryptoBoringWrapperError.internalBoringSSLError()
}
}
}
@@ -95,7 +92,7 @@ extension ArbitraryPrecisionInteger {
extension ArbitraryPrecisionInteger {
@usableFromInline
init<Bytes: ContiguousBytes>(bytes: Bytes) throws {
package init<Bytes: ContiguousBytes>(bytes: Bytes) throws {
self._backing = try BackingStorage(bytes: bytes)
}
@@ -103,7 +100,7 @@ extension ArbitraryPrecisionInteger {
///
/// - Parameter hexString: Hex byte string (big-endian, no `0x` prefix, may start with `-` for a negative number).
@usableFromInline
init(hexString: String) throws {
package init(hexString: String) throws {
self._backing = try BackingStorage(hexString: hexString)
}
}
@@ -116,7 +113,7 @@ extension ArbitraryPrecisionInteger.BackingStorage {
CCryptoBoringSSLShims_BN_bin2bn(bytesPointer.baseAddress, bytesPointer.count, &self._backing)
}
guard rc != nil else {
throw CryptoKitError.internalBoringSSLError()
throw CryptoBoringWrapperError.internalBoringSSLError()
}
}
@@ -130,7 +127,7 @@ extension ArbitraryPrecisionInteger.BackingStorage {
try withUnsafeMutablePointer(to: &backingPtr) { backingPtrPtr in
/// `BN_hex2bin` returns the number of bytes of `in` processed or zero on error.
guard CCryptoBoringSSL_BN_hex2bn(backingPtrPtr, hexStringPtr) == hexString.count else {
throw CryptoKitError.incorrectParameterSize
throw CryptoBoringWrapperError.incorrectParameterSize
}
}
}
@@ -141,11 +138,11 @@ extension ArbitraryPrecisionInteger.BackingStorage {
// MARK: - Pointer helpers
extension ArbitraryPrecisionInteger {
func withUnsafeBignumPointer<T>(_ body: (UnsafePointer<BIGNUM>) throws -> T) rethrows -> T {
package func withUnsafeBignumPointer<T>(_ body: (UnsafePointer<BIGNUM>) throws -> T) rethrows -> T {
try self._backing.withUnsafeBignumPointer(body)
}
mutating func withUnsafeMutableBignumPointer<T>(_ body: (UnsafeMutablePointer<BIGNUM>) throws -> T) rethrows -> T {
package mutating func withUnsafeMutableBignumPointer<T>(_ body: (UnsafeMutablePointer<BIGNUM>) throws -> T) rethrows -> T {
if !isKnownUniquelyReferenced(&self._backing) {
// Failing to CoW is a fatal error here.
self._backing = try! BackingStorage(copying: self._backing)
@@ -184,7 +181,7 @@ extension ArbitraryPrecisionInteger {
}
@usableFromInline
func squared() -> ArbitraryPrecisionInteger {
package func squared() -> ArbitraryPrecisionInteger {
var result = ArbitraryPrecisionInteger()
let rc = result.withUnsafeMutableBignumPointer { resultPtr in
self.withUnsafeBignumPointer { selfPtr in
@@ -198,7 +195,7 @@ extension ArbitraryPrecisionInteger {
}
@usableFromInline
func positiveSquareRoot() throws -> ArbitraryPrecisionInteger {
package func positiveSquareRoot() throws -> ArbitraryPrecisionInteger {
var result = ArbitraryPrecisionInteger()
let rc = result.withUnsafeMutableBignumPointer { resultPtr in
self.withUnsafeBignumPointer { selfPtr in
@@ -209,13 +206,13 @@ extension ArbitraryPrecisionInteger {
}
guard rc == 1 else {
throw CryptoKitError.internalBoringSSLError()
throw CryptoBoringWrapperError.internalBoringSSLError()
}
return result
}
@usableFromInline
var byteCount: Int {
package var byteCount: Int {
self._backing.withUnsafeBignumPointer {
Int(CCryptoBoringSSL_BN_num_bytes($0))
}
@@ -238,7 +235,7 @@ extension ArbitraryPrecisionInteger {
extension ArbitraryPrecisionInteger: Equatable {
@inlinable
static func == (lhs: ArbitraryPrecisionInteger, rhs: ArbitraryPrecisionInteger) -> Bool {
package static func == (lhs: ArbitraryPrecisionInteger, rhs: ArbitraryPrecisionInteger) -> Bool {
self._compare(lhs: lhs, rhs: rhs) == 0
}
}
@@ -247,22 +244,22 @@ extension ArbitraryPrecisionInteger: Equatable {
extension ArbitraryPrecisionInteger: Comparable {
@inlinable
static func < (lhs: ArbitraryPrecisionInteger, rhs: ArbitraryPrecisionInteger) -> Bool {
package static func < (lhs: ArbitraryPrecisionInteger, rhs: ArbitraryPrecisionInteger) -> Bool {
self._compare(lhs: lhs, rhs: rhs) < 0
}
@inlinable
static func <= (lhs: ArbitraryPrecisionInteger, rhs: ArbitraryPrecisionInteger) -> Bool {
package static func <= (lhs: ArbitraryPrecisionInteger, rhs: ArbitraryPrecisionInteger) -> Bool {
self._compare(lhs: lhs, rhs: rhs) <= 0
}
@inlinable
static func > (lhs: ArbitraryPrecisionInteger, rhs: ArbitraryPrecisionInteger) -> Bool {
package static func > (lhs: ArbitraryPrecisionInteger, rhs: ArbitraryPrecisionInteger) -> Bool {
self._compare(lhs: lhs, rhs: rhs) > 0
}
@inlinable
static func >= (lhs: ArbitraryPrecisionInteger, rhs: ArbitraryPrecisionInteger) -> Bool {
package static func >= (lhs: ArbitraryPrecisionInteger, rhs: ArbitraryPrecisionInteger) -> Bool {
self._compare(lhs: lhs, rhs: rhs) >= 0
}
}
@@ -275,12 +272,12 @@ extension ArbitraryPrecisionInteger: ExpressibleByIntegerLiteral {}
extension ArbitraryPrecisionInteger: AdditiveArithmetic {
@inlinable
static var zero: ArbitraryPrecisionInteger {
package static var zero: ArbitraryPrecisionInteger {
0
}
@usableFromInline
static func + (lhs: ArbitraryPrecisionInteger, rhs: ArbitraryPrecisionInteger) -> ArbitraryPrecisionInteger {
package static func + (lhs: ArbitraryPrecisionInteger, rhs: ArbitraryPrecisionInteger) -> ArbitraryPrecisionInteger {
var result = ArbitraryPrecisionInteger()
let rc = result.withUnsafeMutableBignumPointer { resultPtr in
@@ -296,7 +293,7 @@ extension ArbitraryPrecisionInteger: AdditiveArithmetic {
}
@usableFromInline
static func += (lhs: inout ArbitraryPrecisionInteger, rhs: ArbitraryPrecisionInteger) {
package static func += (lhs: inout ArbitraryPrecisionInteger, rhs: ArbitraryPrecisionInteger) {
let rc = lhs.withUnsafeMutableBignumPointer { lhsPtr in
rhs.withUnsafeBignumPointer { rhsPtr in
CCryptoBoringSSL_BN_add(lhsPtr, lhsPtr, rhsPtr)
@@ -306,7 +303,7 @@ extension ArbitraryPrecisionInteger: AdditiveArithmetic {
}
@usableFromInline
static func - (lhs: ArbitraryPrecisionInteger, rhs: ArbitraryPrecisionInteger) -> ArbitraryPrecisionInteger {
package static func - (lhs: ArbitraryPrecisionInteger, rhs: ArbitraryPrecisionInteger) -> ArbitraryPrecisionInteger {
var result = ArbitraryPrecisionInteger()
let rc = result.withUnsafeMutableBignumPointer { resultPtr in
@@ -322,7 +319,7 @@ extension ArbitraryPrecisionInteger: AdditiveArithmetic {
}
@usableFromInline
static func -= (lhs: inout ArbitraryPrecisionInteger, rhs: ArbitraryPrecisionInteger) {
package static func -= (lhs: inout ArbitraryPrecisionInteger, rhs: ArbitraryPrecisionInteger) {
let rc = lhs.withUnsafeMutableBignumPointer { lhsPtr in
rhs.withUnsafeBignumPointer { rhsPtr in
CCryptoBoringSSL_BN_sub(lhsPtr, lhsPtr, rhsPtr)
@@ -336,10 +333,10 @@ extension ArbitraryPrecisionInteger: AdditiveArithmetic {
extension ArbitraryPrecisionInteger: Numeric {
@usableFromInline
typealias Magnitude = Self
package typealias Magnitude = Self
@usableFromInline
var magnitude: Magnitude {
package var magnitude: Magnitude {
if self._positive {
return self
}
@@ -354,7 +351,7 @@ extension ArbitraryPrecisionInteger: Numeric {
}
@usableFromInline
static func * (lhs: ArbitraryPrecisionInteger, rhs: ArbitraryPrecisionInteger) -> ArbitraryPrecisionInteger {
package static func * (lhs: ArbitraryPrecisionInteger, rhs: ArbitraryPrecisionInteger) -> ArbitraryPrecisionInteger {
var result = ArbitraryPrecisionInteger()
let rc = result.withUnsafeMutableBignumPointer { resultPtr in
@@ -372,7 +369,7 @@ extension ArbitraryPrecisionInteger: Numeric {
}
@usableFromInline
static func *= (lhs: inout ArbitraryPrecisionInteger, rhs: ArbitraryPrecisionInteger) {
package static func *= (lhs: inout ArbitraryPrecisionInteger, rhs: ArbitraryPrecisionInteger) {
let rc = lhs.withUnsafeMutableBignumPointer { lhsPtr in
rhs.withUnsafeBignumPointer { rhsPtr in
ArbitraryPrecisionInteger.withUnsafeBN_CTX { bnCtx in
@@ -384,7 +381,7 @@ extension ArbitraryPrecisionInteger: Numeric {
}
@inlinable
init?<T: BinaryInteger>(exactly integer: T) {
package init?<T: BinaryInteger>(exactly integer: T) {
fatalError("Not currently implemented")
}
}
@@ -393,7 +390,7 @@ extension ArbitraryPrecisionInteger: Numeric {
extension ArbitraryPrecisionInteger: SignedNumeric {
@usableFromInline
mutating func negate() {
package mutating func negate() {
let signBit: CInt = self._positive ? 1 : 0
self.withUnsafeMutableBignumPointer {
@@ -406,7 +403,14 @@ extension ArbitraryPrecisionInteger: SignedNumeric {
extension ArbitraryPrecisionInteger {
@usableFromInline
static func gcd(_ a: ArbitraryPrecisionInteger, _ b: ArbitraryPrecisionInteger) throws -> ArbitraryPrecisionInteger {
package var trailingZeroBitCount: Int32 {
self.withUnsafeBignumPointer {
CCryptoBoringSSL_BN_count_low_zero_bits($0)
}
}
@usableFromInline
package static func gcd(_ a: ArbitraryPrecisionInteger, _ b: ArbitraryPrecisionInteger) throws -> ArbitraryPrecisionInteger {
var result = ArbitraryPrecisionInteger()
guard result.withUnsafeMutableBignumPointer({ resultPtr in
@@ -418,19 +422,19 @@ extension ArbitraryPrecisionInteger {
}
}
}) == 1 else {
throw CryptoKitError.internalBoringSSLError()
throw CryptoBoringWrapperError.internalBoringSSLError()
}
return result
}
@usableFromInline
func isCoprime(with other: ArbitraryPrecisionInteger) throws -> Bool {
package func isCoprime(with other: ArbitraryPrecisionInteger) throws -> Bool {
try Self.gcd(self, other) == 1
}
@usableFromInline
static func random(inclusiveMin: UInt, exclusiveMax: ArbitraryPrecisionInteger) throws -> ArbitraryPrecisionInteger {
package static func random(inclusiveMin: UInt, exclusiveMax: ArbitraryPrecisionInteger) throws -> ArbitraryPrecisionInteger {
var result = ArbitraryPrecisionInteger()
guard result.withUnsafeMutableBignumPointer({ resultPtr in
@@ -438,11 +442,51 @@ extension ArbitraryPrecisionInteger {
CCryptoBoringSSL_BN_rand_range_ex(resultPtr, BN_ULONG(inclusiveMin), exclusiveMaxPtr)
}
}) == 1 else {
throw CryptoKitError.internalBoringSSLError()
throw CryptoBoringWrapperError.internalBoringSSLError()
}
return result
}
@usableFromInline
package static func >> (lhs: ArbitraryPrecisionInteger, rhs: Int32) -> ArbitraryPrecisionInteger {
var result = ArbitraryPrecisionInteger()
let rc = result.withUnsafeMutableBignumPointer { resultPtr in
lhs.withUnsafeBignumPointer { lhsPtr in
CCryptoBoringSSL_BN_rshift(resultPtr, lhsPtr, rhs)
}
}
precondition(rc == 1, "Unable to allocate memory for new ArbitraryPrecisionInteger")
return result
}
@usableFromInline
package static func / (lhs: ArbitraryPrecisionInteger, rhs: ArbitraryPrecisionInteger) -> ArbitraryPrecisionInteger {
var result = ArbitraryPrecisionInteger()
let rc = result.withUnsafeMutableBignumPointer { resultPtr in
lhs.withUnsafeBignumPointer { lhsPtr in
rhs.withUnsafeBignumPointer { rhsPtr in
ArbitraryPrecisionInteger.withUnsafeBN_CTX { bnCtx in
CCryptoBoringSSL_BN_div(resultPtr, nil, lhsPtr, rhsPtr, bnCtx)
}
}
}
}
precondition(rc == 1, "Unable to allocate memory for new ArbitraryPrecisionInteger")
return result
}
@usableFromInline
package var isEven: Bool {
self.withUnsafeBignumPointer {
CCryptoBoringSSL_BN_is_odd($0) == 0
}
}
}
// MARK: - Serializing
@@ -450,11 +494,11 @@ extension ArbitraryPrecisionInteger {
extension Data {
/// Serializes an ArbitraryPrecisionInteger padded out to a certain minimum size.
@usableFromInline
mutating func append(bytesOf integer: ArbitraryPrecisionInteger, paddedToSize paddingSize: Int) throws {
package mutating func append(bytesOf integer: ArbitraryPrecisionInteger, paddedToSize paddingSize: Int) throws {
let byteCount = integer.byteCount
guard paddingSize >= byteCount else {
throw CryptoKitError.incorrectParameterSize
throw CryptoBoringWrapperError.incorrectParameterSize
}
// To extend the data we need to write some zeroes into it.
@@ -474,7 +518,7 @@ extension Data {
}
@usableFromInline
init(bytesOf integer: ArbitraryPrecisionInteger, paddedToSize paddingSize: Int) throws {
package init(bytesOf integer: ArbitraryPrecisionInteger, paddedToSize paddingSize: Int) throws {
self.init(capacity: paddingSize)
try self.append(bytesOf: integer, paddedToSize: paddingSize)
}
@@ -484,7 +528,7 @@ extension Data {
extension ArbitraryPrecisionInteger: CustomDebugStringConvertible {
@usableFromInline
var debugDescription: String {
package var debugDescription: String {
guard let bio = CCryptoBoringSSL_BIO_new(CCryptoBoringSSL_BIO_s_mem()) else {
return "ArbitraryPrecisionInteger: (error generating representation)"
}
@@ -11,14 +11,11 @@
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
#if MODULE_IS_CRYPTO && CRYPTO_IN_SWIFTPM && !CRYPTO_IN_SWIFTPM_FORCE_BUILD_API
#if CRYPTO_IN_SWIFTPM && !CRYPTO_IN_SWIFTPM_FORCE_BUILD_API
@_exported import CryptoKit
#else
@_implementationOnly import CCryptoBoringSSL
import Foundation
#if !MODULE_IS_CRYPTO
import enum Crypto.CryptoKitError
#endif
/// A context for performing mathematical operations on ArbitraryPrecisionIntegers over a finite field.
///
@@ -32,15 +29,15 @@ import enum Crypto.CryptoKitError
/// Annoyingly, because of the way we have implemented ArbitraryPrecisionInteger, we can't actually use these temporary bignums
/// ourselves.
@usableFromInline
class FiniteFieldArithmeticContext {
package class FiniteFieldArithmeticContext {
private var fieldSize: ArbitraryPrecisionInteger
private var bnCtx: OpaquePointer
@usableFromInline
init(fieldSize: ArbitraryPrecisionInteger) throws {
package init(fieldSize: ArbitraryPrecisionInteger) throws {
self.fieldSize = fieldSize
guard let bnCtx = CCryptoBoringSSL_BN_CTX_new() else {
throw CryptoKitError.internalBoringSSLError()
throw CryptoBoringWrapperError.internalBoringSSLError()
}
CCryptoBoringSSL_BN_CTX_start(bnCtx)
self.bnCtx = bnCtx
@@ -56,7 +53,7 @@ class FiniteFieldArithmeticContext {
extension FiniteFieldArithmeticContext {
@usableFromInline
func residue(_ x: ArbitraryPrecisionInteger) throws -> ArbitraryPrecisionInteger {
package func residue(_ x: ArbitraryPrecisionInteger) throws -> ArbitraryPrecisionInteger {
var result = ArbitraryPrecisionInteger()
guard x.withUnsafeBignumPointer({ xPtr in
@@ -66,14 +63,14 @@ extension FiniteFieldArithmeticContext {
}
}
}) == 1 else {
throw CryptoKitError.internalBoringSSLError()
throw CryptoBoringWrapperError.internalBoringSSLError()
}
return result
}
@usableFromInline
func square(_ input: ArbitraryPrecisionInteger) throws -> ArbitraryPrecisionInteger {
package func square(_ input: ArbitraryPrecisionInteger) throws -> ArbitraryPrecisionInteger {
var output = ArbitraryPrecisionInteger()
let rc = input.withUnsafeBignumPointer { inputPointer in
@@ -85,14 +82,14 @@ extension FiniteFieldArithmeticContext {
}
guard rc == 1 else {
throw CryptoKitError.internalBoringSSLError()
throw CryptoBoringWrapperError.internalBoringSSLError()
}
return output
}
@usableFromInline
func multiply(_ x: ArbitraryPrecisionInteger, _ y: ArbitraryPrecisionInteger) throws -> ArbitraryPrecisionInteger {
package func multiply(_ x: ArbitraryPrecisionInteger, _ y: ArbitraryPrecisionInteger) throws -> ArbitraryPrecisionInteger {
var output = ArbitraryPrecisionInteger()
let rc = x.withUnsafeBignumPointer { xPointer in
@@ -106,14 +103,14 @@ extension FiniteFieldArithmeticContext {
}
guard rc == 1 else {
throw CryptoKitError.internalBoringSSLError()
throw CryptoBoringWrapperError.internalBoringSSLError()
}
return output
}
@usableFromInline
func add(_ x: ArbitraryPrecisionInteger, _ y: ArbitraryPrecisionInteger) throws -> ArbitraryPrecisionInteger {
package func add(_ x: ArbitraryPrecisionInteger, _ y: ArbitraryPrecisionInteger) throws -> ArbitraryPrecisionInteger {
var output = ArbitraryPrecisionInteger()
let rc = x.withUnsafeBignumPointer { xPointer in
@@ -127,14 +124,14 @@ extension FiniteFieldArithmeticContext {
}
guard rc == 1 else {
throw CryptoKitError.internalBoringSSLError()
throw CryptoBoringWrapperError.internalBoringSSLError()
}
return output
}
@usableFromInline
func subtract(_ x: ArbitraryPrecisionInteger, from y: ArbitraryPrecisionInteger) throws -> ArbitraryPrecisionInteger {
package func subtract(_ x: ArbitraryPrecisionInteger, from y: ArbitraryPrecisionInteger) throws -> ArbitraryPrecisionInteger {
var output = ArbitraryPrecisionInteger()
let rc = x.withUnsafeBignumPointer { xPointer in
@@ -149,14 +146,14 @@ extension FiniteFieldArithmeticContext {
}
guard rc == 1 else {
throw CryptoKitError.internalBoringSSLError()
throw CryptoBoringWrapperError.internalBoringSSLError()
}
return output
}
@usableFromInline
func positiveSquareRoot(_ x: ArbitraryPrecisionInteger) throws -> ArbitraryPrecisionInteger {
package func positiveSquareRoot(_ x: ArbitraryPrecisionInteger) throws -> ArbitraryPrecisionInteger {
let outputPointer = x.withUnsafeBignumPointer { xPointer in
self.fieldSize.withUnsafeBignumPointer { fieldSizePointer in
// We can't pass a pointer in as BN_mod_sqrt may attempt to free it.
@@ -165,7 +162,7 @@ extension FiniteFieldArithmeticContext {
}
guard let actualOutputPointer = outputPointer else {
throw CryptoKitError.internalBoringSSLError()
throw CryptoBoringWrapperError.internalBoringSSLError()
}
// Ok, we own this pointer now.
@@ -177,7 +174,7 @@ extension FiniteFieldArithmeticContext {
}
@usableFromInline
func inverse(_ x: ArbitraryPrecisionInteger) throws -> ArbitraryPrecisionInteger? {
package func inverse(_ x: ArbitraryPrecisionInteger) throws -> ArbitraryPrecisionInteger? {
var result = ArbitraryPrecisionInteger()
guard result.withUnsafeMutableBignumPointer({ resultPtr in
@@ -192,19 +189,19 @@ extension FiniteFieldArithmeticContext {
}
@usableFromInline
func pow(_ x: ArbitraryPrecisionInteger, _ p: ArbitraryPrecisionInteger) throws -> ArbitraryPrecisionInteger {
package func pow(_ x: ArbitraryPrecisionInteger, _ p: ArbitraryPrecisionInteger) throws -> ArbitraryPrecisionInteger {
try self.pow(x, p) { r, x, p, m, ctx, _ in CCryptoBoringSSL_BN_mod_exp(r, x, p, m, ctx) }
}
@usableFromInline
func pow(secret x: ArbitraryPrecisionInteger, _ p: ArbitraryPrecisionInteger) throws -> ArbitraryPrecisionInteger {
guard x < self.fieldSize else { throw CryptoKitError.incorrectParameterSize }
package func pow(secret x: ArbitraryPrecisionInteger, _ p: ArbitraryPrecisionInteger) throws -> ArbitraryPrecisionInteger {
guard x < self.fieldSize else { throw CryptoBoringWrapperError.incorrectParameterSize }
return try self.pow(x, p, using: CCryptoBoringSSL_BN_mod_exp_mont)
}
@usableFromInline
func pow(secret x: ArbitraryPrecisionInteger, secret p: ArbitraryPrecisionInteger) throws -> ArbitraryPrecisionInteger {
guard x < self.fieldSize else { throw CryptoKitError.incorrectParameterSize }
package func pow(secret x: ArbitraryPrecisionInteger, secret p: ArbitraryPrecisionInteger) throws -> ArbitraryPrecisionInteger {
guard x < self.fieldSize else { throw CryptoBoringWrapperError.incorrectParameterSize }
return try self.pow(x, p, using: CCryptoBoringSSL_BN_mod_exp_mont_consttime)
}
@@ -233,7 +230,7 @@ extension FiniteFieldArithmeticContext {
}
}
}) == 1 else {
throw CryptoKitError.internalBoringSSLError()
throw CryptoBoringWrapperError.internalBoringSSLError()
}
return result
+1 -5
View File
@@ -15,12 +15,8 @@
import Crypto
@_implementationOnly import CCryptoBoringSSL
@_implementationOnly import CCryptoBoringSSLShims
@_implementationOnly import CryptoBoringWrapper
#if canImport(Darwin) || swift(>=5.9.1)
import CryptoBoringWrapper
import Foundation
#else
@preconcurrency import Foundation
#endif
/// Types associated with the AES GCM SIV algorithm
extension AES.GCM {
@@ -15,7 +15,7 @@
import Crypto
@_implementationOnly import CCryptoBoringSSL
@_implementationOnly import CCryptoBoringSSLShims
@_implementationOnly import CryptoBoringWrapper
import CryptoBoringWrapper
import Foundation
extension AES {
@@ -17,7 +17,7 @@
@_implementationOnly import CCryptoBoringSSL
@_implementationOnly import CCryptoBoringSSLShims
import Crypto
@_implementationOnly import CryptoBoringWrapper
import CryptoBoringWrapper
import Foundation
extension BoringSSLAEAD {
+3 -2
View File
@@ -25,8 +25,7 @@ add_library(_CryptoExtras
"Util/Error.swift"
"Util/PEMDocument.swift"
"Util/RandomBytes.swift"
"Util/Shared/ArbitraryPrecisionInteger_boring.swift"
"Util/Shared/FiniteFieldArithmeticContext_boring.swift")
"Util/SubjectPublicKeyInfo.swift")
target_include_directories(_CryptoExtras PRIVATE
$<TARGET_PROPERTY:CCryptoBoringSSL,INCLUDE_DIRECTORIES>
@@ -39,6 +38,8 @@ target_link_libraries(_CryptoExtras PUBLIC
CCryptoBoringSSL
CCryptoBoringSSLShims)
target_compile_options(_CryptoExtras PRIVATE ${SWIFT_CRYPTO_COMPILE_OPTIONS})
target_link_options(_CryptoExtras PRIVATE
"$<$<PLATFORM_ID:Darwin>:SHELL:-Xlinker -framework -Xlinker Security>")
@@ -15,7 +15,7 @@
@_implementationOnly import CCryptoBoringSSL
@_implementationOnly import CCryptoBoringSSLShims
import Crypto
@_implementationOnly import CryptoBoringWrapper
import CryptoBoringWrapper
import Foundation
enum OpenSSLChaCha20CTRImpl {
@@ -15,12 +15,8 @@
@_implementationOnly import CCryptoBoringSSL
@_implementationOnly import CCryptoBoringSSLShims
import Crypto
@_implementationOnly import CryptoBoringWrapper
#if canImport(Darwin) || swift(>=5.9.1)
import CryptoBoringWrapper
import Foundation
#else
@preconcurrency import Foundation
#endif
typealias ChaCha20CTRImpl = OpenSSLChaCha20CTRImpl
@@ -13,6 +13,7 @@
//===----------------------------------------------------------------------===//
import Foundation
import Crypto
import CryptoBoringWrapper
// NOTE: RSABSSA API is implemented using BoringSSL on all platforms.
fileprivate typealias BackingPublicKey = BoringSSLRSAPublicKey
@@ -26,6 +27,16 @@ extension _RSA.BlindSigning {
public struct PublicKey<H: HashFunction>: Sendable {
public typealias Parameters = _RSA.BlindSigning.Parameters<H>
public struct Primitives: Sendable, Hashable {
public var modulus: Data
public var publicExponent: Data
public init(modulus: Data, publicExponent: Data) {
self.modulus = modulus
self.publicExponent = publicExponent
}
}
private var backing: BackingPublicKey
private let parameters: Parameters
@@ -113,6 +124,11 @@ extension _RSA.BlindSigning {
self.backing = backing
self.parameters = parameters
}
public func getKeyPrimitives() throws -> Primitives {
let (n, e) = try self.backing.getKeyPrimitives()
return Primitives(modulus: n, publicExponent: e)
}
}
}
@@ -227,6 +243,34 @@ extension _RSA.BlindSigning {
public var publicKey: _RSA.BlindSigning.PublicKey<H> {
_RSA.BlindSigning.PublicKey(self.backing.publicKey, self.parameters)
}
/// Construct a private key with the specified parameters.
///
/// The use of this API is strongly discouraged for performance reasons,
/// as it requires the factorization of the modulus, which is resource-intensive.
/// It is recommended to use the other initializers to construct a private key,
/// unless you have only the modulus, public exponent, and private exponent
/// to construct the key.
///
/// - Parameters:
/// - n: modulus of the key
/// - e: public exponent of the key
/// - d: private exponent of the key
/// - parameters: parameters used in the blind signing protocol
public static func _createFromNumbers(n: some ContiguousBytes, e: some ContiguousBytes, d: some ContiguousBytes, parameters: Parameters) throws -> Self {
let (p, q) = try _RSA.extractPrimeFactors(
n: try ArbitraryPrecisionInteger(bytes: n),
e: try ArbitraryPrecisionInteger(bytes: e),
d: try ArbitraryPrecisionInteger(bytes: d)
)
return try Self.init(
n: n, e: e, d: d,
p: try Data(bytesOf: p, paddedToSize: p.byteCount),
q: try Data(bytesOf: q, paddedToSize: q.byteCount),
parameters: parameters
)
}
}
}
+155 -15
View File
@@ -13,6 +13,8 @@
//===----------------------------------------------------------------------===//
import Foundation
import Crypto
import CryptoBoringWrapper
import SwiftASN1
#if CRYPTO_IN_SWIFTPM && !CRYPTO_IN_SWIFTPM_FORCE_BUILD_API
fileprivate typealias BackingPublicKey = SecurityRSAPublicKey
@@ -31,12 +33,8 @@ fileprivate typealias BackingPrivateKey = BoringSSLRSAPrivateKey
///
/// When rolling out new cryptosystems, users should avoid RSA and use ECDSA or edDSA instead. RSA
/// support is provided for interoperability with legacy systems.
#if swift(>=5.8)
@_documentation(visibility: public)
public enum _RSA { }
#else
public enum _RSA { }
#endif
extension _RSA {
public enum Signing { }
@@ -45,40 +43,50 @@ extension _RSA {
extension _RSA.Signing {
public struct PublicKey: Sendable {
public struct Primitives: Sendable, Hashable {
public var modulus: Data
public var publicExponent: Data
public init(modulus: Data, publicExponent: Data) {
self.modulus = modulus
self.publicExponent = publicExponent
}
}
private var backing: BackingPublicKey
/// Construct an RSA public key from a PEM representation.
///
/// This constructor supports key sizes of 2048 bits or more. Users should validate that key sizes are appropriate
/// for their use-case.
/// Parameters from RSA PSS keys will be stripped.
public init(pemRepresentation: String) throws {
self.backing = try BackingPublicKey(pemRepresentation: pemRepresentation)
let derBytes = try PEMDocument(pemString: pemRepresentation).derBytes
guard self.keySizeInBits >= 2048 else {
throw CryptoKitError.incorrectParameterSize
}
try self.init(derRepresentation: derBytes)
}
/// Construct an RSA public key from a PEM representation.
///
/// This constructor supports key sizes of 1024 bits or more. Users should validate that key sizes are appropriate
/// for their use-case.
/// Parameters from RSA PSS keys will be stripped.
/// - Warning: Key sizes less than 2048 are not recommended and should only be used for compatibility reasons.
public init(unsafePEMRepresentation pemRepresentation: String) throws {
self.backing = try BackingPublicKey(pemRepresentation: pemRepresentation)
guard self.keySizeInBits >= 1024 else {
throw CryptoKitError.incorrectParameterSize
}
let derBytes = try PEMDocument(pemString: pemRepresentation).derBytes
try self.init(unsafeDERRepresentation: derBytes)
}
/// Construct an RSA public key from a DER representation.
///
/// This constructor supports key sizes of 2048 bits or more. Users should validate that key sizes are appropriate
/// for their use-case.
/// Parameters from RSA PSS keys will be stripped.
public init<Bytes: DataProtocol>(derRepresentation: Bytes) throws {
self.backing = try BackingPublicKey(derRepresentation: derRepresentation)
let sanitizedDer = try SubjectPublicKeyInfo.stripRsaPssParameters(derEncoded: [UInt8](derRepresentation))
self.backing = try BackingPublicKey(derRepresentation: sanitizedDer)
guard self.keySizeInBits >= 2048 else {
throw CryptoKitError.incorrectParameterSize
@@ -89,9 +97,12 @@ extension _RSA.Signing {
///
/// This constructor supports key sizes of 1024 bits or more. Users should validate that key sizes are appropriate
/// for their use-case.
/// Parameters from RSA PSS keys will be stripped.
/// - Warning: Key sizes less than 2048 are not recommended and should only be used for compatibility reasons.
public init<Bytes: DataProtocol>(unsafeDERRepresentation derRepresentation: Bytes) throws {
self.backing = try BackingPublicKey(derRepresentation: derRepresentation)
let sanitizedDer = try SubjectPublicKeyInfo.stripRsaPssParameters(derEncoded: [UInt8](derRepresentation))
self.backing = try BackingPublicKey(derRepresentation: sanitizedDer)
guard self.keySizeInBits >= 1024 else {
throw CryptoKitError.incorrectParameterSize
@@ -132,6 +143,11 @@ extension _RSA.Signing {
fileprivate init(_ backing: BackingPublicKey) {
self.backing = backing
}
public func getKeyPrimitives() throws -> Primitives {
let (n, e) = try self.backing.getKeyPrimitives()
return Primitives(modulus: n, publicExponent: e)
}
}
}
@@ -242,6 +258,32 @@ extension _RSA.Signing {
public var publicKey: _RSA.Signing.PublicKey {
_RSA.Signing.PublicKey(self.backing.publicKey)
}
/// Construct a private key with the specified parameters.
///
/// The use of this API is strongly discouraged for performance reasons,
/// as it requires the factorization of the modulus, which is resource-intensive.
/// It is recommended to use the other initializers to construct a private key,
/// unless you have only the modulus, public exponent, and private exponent
/// to construct the key.
///
/// - Parameters:
/// - n: modulus of the key
/// - e: public exponent of the key
/// - d: private exponent of the key
public static func _createFromNumbers(n: some ContiguousBytes, e: some ContiguousBytes, d: some ContiguousBytes) throws -> Self {
let (p, q) = try _RSA.extractPrimeFactors(
n: try ArbitraryPrecisionInteger(bytes: n),
e: try ArbitraryPrecisionInteger(bytes: e),
d: try ArbitraryPrecisionInteger(bytes: d)
)
return try Self.init(
n: n, e: e, d: d,
p: try Data(bytesOf: p, paddedToSize: p.byteCount),
q: try Data(bytesOf: q, paddedToSize: q.byteCount)
)
}
}
}
@@ -426,6 +468,16 @@ extension _RSA.Signing {
extension _RSA.Encryption {
/// Identical to ``_RSA/Signing/PublicKey``.
public struct PublicKey {
public struct Primitives: Sendable, Hashable {
public var modulus: Data
public var publicExponent: Data
public init(modulus: Data, publicExponent: Data) {
self.modulus = modulus
self.publicExponent = publicExponent
}
}
private var backing: BackingPublicKey
/// Construct an RSA public key from a PEM representation.
@@ -483,6 +535,11 @@ extension _RSA.Encryption {
public var pemRepresentation: String { self.backing.pemRepresentation }
public var keySizeInBits: Int { self.backing.keySizeInBits }
fileprivate init(_ backing: BackingPublicKey) { self.backing = backing }
public func getKeyPrimitives() throws -> Primitives {
let (n, e) = try self.backing.getKeyPrimitives()
return Primitives(modulus: n, publicExponent: e)
}
}
/// Identical to ``_RSA/Signing/PrivateKey``.
@@ -563,6 +620,32 @@ extension _RSA.Encryption {
public var pkcs8PEMRepresentation: String { self.backing.pkcs8PEMRepresentation }
public var keySizeInBits: Int { self.backing.keySizeInBits }
public var publicKey: _RSA.Encryption.PublicKey { .init(self.backing.publicKey) }
/// Construct a private key with the specified parameters.
///
/// The use of this API is strongly discouraged for performance reasons,
/// as it requires the factorization of the modulus, which is resource-intensive.
/// It is recommended to use the other initializers to construct a private key,
/// unless you have only the modulus, public exponent, and private exponent
/// to construct the key.
///
/// - Parameters:
/// - n: modulus of the key
/// - e: public exponent of the key
/// - d: private exponent of the key
public static func _createFromNumbers(n: some ContiguousBytes, e: some ContiguousBytes, d: some ContiguousBytes) throws -> Self {
let (p, q) = try _RSA.extractPrimeFactors(
n: try ArbitraryPrecisionInteger(bytes: n),
e: try ArbitraryPrecisionInteger(bytes: e),
d: try ArbitraryPrecisionInteger(bytes: d)
)
return try Self.init(
n: n, e: e, d: d,
p: try Data(bytesOf: p, paddedToSize: p.byteCount),
q: try Data(bytesOf: q, paddedToSize: q.byteCount)
)
}
}
}
@@ -639,3 +722,60 @@ extension _RSA {
static let SPKIPublicKeyType = "PUBLIC KEY"
}
extension _RSA {
static func extractPrimeFactors(
n: ArbitraryPrecisionInteger,
e: ArbitraryPrecisionInteger,
d: ArbitraryPrecisionInteger
) throws -> (p: ArbitraryPrecisionInteger, q: ArbitraryPrecisionInteger) {
// This is based on the proof of fact 1 in https://www.ams.org/notices/199902/boneh.pdf
let k = (d * e) - 1
let t = k.trailingZeroBitCount
let r = k >> t
guard k.isEven else {
throw CryptoKitError.incorrectParameterSize
}
var y: ArbitraryPrecisionInteger = 0
var i = 1
let context = try FiniteFieldArithmeticContext(fieldSize: n)
while i <= 100 {
let g = try ArbitraryPrecisionInteger.random(inclusiveMin: 2, exclusiveMax: n)
y = try context.pow(g, r)
guard y != 1, y != n - 1 else {
continue
}
var j = 1
var x: ArbitraryPrecisionInteger
while j <= t &- 1 {
x = try context.pow(y, 2)
guard x != 1, x != n - 1 else {
break
}
y = x
j &+= 1
}
x = try context.pow(y, 2)
if x == 1 {
let p = try ArbitraryPrecisionInteger.gcd(y - 1, n)
let q = n / p
return (p, q)
}
i &+= 1
}
throw CryptoKitError.incorrectParameterSize
}
}
@@ -15,6 +15,7 @@ import Foundation
import Crypto
// NOTE: This file is unconditionally compiled because RSABSSA is implemented using BoringSSL on all platforms.
import CryptoBoringWrapper
@_implementationOnly import CCryptoBoringSSL
@_implementationOnly import CCryptoBoringSSLShims
@@ -60,6 +61,10 @@ internal struct BoringSSLRSAPublicKey: Sendable {
fileprivate init(_ backing: Backing) {
self.backing = backing
}
func getKeyPrimitives() throws -> (n: Data, e: Data) {
try self.backing.getKeyPrimitives()
}
}
@@ -465,6 +470,22 @@ extension BoringSSLRSAPublicKey {
deinit {
CCryptoBoringSSL_EVP_PKEY_free(self.pointer)
}
fileprivate func getKeyPrimitives() -> (n: Data, e: Data) {
let key = CCryptoBoringSSL_EVP_PKEY_get0_RSA(self.pointer)
func getPrimitive(_ getPointer: (OpaquePointer?) -> UnsafePointer<BIGNUM>?) -> Data {
let ptr = getPointer(key)
let size = Int(CCryptoBoringSSL_BN_num_bytes(ptr))
var data = Data(count: size)
data.withUnsafeMutableBytes { dataPtr in
_ = CCryptoBoringSSL_BN_bn2bin(ptr, dataPtr.baseAddress)
}
return data
}
return (getPrimitive(CCryptoBoringSSL_RSA_get0_n), getPrimitive(CCryptoBoringSSL_RSA_get0_e))
}
}
}
@@ -72,6 +72,10 @@ internal struct SecurityRSAPublicKey: @unchecked Sendable {
fileprivate init(_ backing: SecKey) {
self.backing = backing
}
func getKeyPrimitives() throws -> (n: Data, e: Data) {
try BoringSSLRSAPublicKey(derRepresentation: self.derRepresentation).getKeyPrimitives()
}
}
// unchecked sendable until `SecKey` gets sendable annotations
-1
View File
@@ -1 +0,0 @@
../../Crypto/Util/BoringSSL/Shared
@@ -0,0 +1,124 @@
//===----------------------------------------------------------------------===//
//
// This source file is part of the SwiftCrypto open source project
//
// Copyright (c) 2024 Apple Inc. and the SwiftCrypto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//
import SwiftASN1
struct SubjectPublicKeyInfo: DERImplicitlyTaggable, Hashable {
static var defaultIdentifier: ASN1Identifier {
.sequence
}
var algorithmIdentifier: RFC5480AlgorithmIdentifier
var key: ASN1BitString
init(derEncoded rootNode: ASN1Node, withIdentifier identifier: ASN1Identifier) throws {
// The SPKI block looks like this:
//
// SubjectPublicKeyInfo ::= SEQUENCE {
// algorithm AlgorithmIdentifier,
// subjectPublicKey BIT STRING
// }
self = try DER.sequence(rootNode, identifier: identifier) { nodes in
let algorithmIdentifier = try RFC5480AlgorithmIdentifier(derEncoded: &nodes)
let key = try ASN1BitString(derEncoded: &nodes)
return SubjectPublicKeyInfo(algorithmIdentifier: algorithmIdentifier, key: key)
}
}
private init(algorithmIdentifier: RFC5480AlgorithmIdentifier, key: ASN1BitString) {
self.algorithmIdentifier = algorithmIdentifier
self.key = key
}
internal init(algorithmIdentifier: RFC5480AlgorithmIdentifier, key: [UInt8]) {
self.algorithmIdentifier = algorithmIdentifier
self.key = ASN1BitString(bytes: key[...])
}
func serialize(into coder: inout DER.Serializer, withIdentifier identifier: ASN1Identifier) throws {
try coder.appendConstructedNode(identifier: identifier) { coder in
try coder.serialize(self.algorithmIdentifier)
try coder.serialize(self.key)
}
}
}
struct RFC5480AlgorithmIdentifier: DERImplicitlyTaggable, Hashable {
static var defaultIdentifier: ASN1Identifier {
.sequence
}
var algorithm: ASN1ObjectIdentifier
var parameters: ASN1Any?
init(algorithm: ASN1ObjectIdentifier, parameters: ASN1Any?) {
self.algorithm = algorithm
self.parameters = parameters
}
init(derEncoded rootNode: ASN1Node, withIdentifier identifier: ASN1Identifier) throws {
// The AlgorithmIdentifier block looks like this.
//
// AlgorithmIdentifier ::= SEQUENCE {
// algorithm OBJECT IDENTIFIER,
// parameters ANY DEFINED BY algorithm OPTIONAL
// }
//
// ECParameters ::= CHOICE {
// namedCurve OBJECT IDENTIFIER
// -- implicitCurve NULL
// -- specifiedCurve SpecifiedECDomain
// }
//
// We don't bother with helpers: we just try to decode it directly.
self = try DER.sequence(rootNode, identifier: identifier) { nodes in
let algorithmOID = try ASN1ObjectIdentifier(derEncoded: &nodes)
let parameters = nodes.next().map { ASN1Any(derEncoded: $0) }
return .init(algorithm: algorithmOID, parameters: parameters)
}
}
func serialize(into coder: inout DER.Serializer, withIdentifier identifier: ASN1Identifier) throws {
try coder.appendConstructedNode(identifier: identifier) { coder in
try coder.serialize(self.algorithm)
if let parameters = self.parameters {
try coder.serialize(parameters)
}
}
}
}
extension SubjectPublicKeyInfo {
static func stripRsaPssParameters(derEncoded: [UInt8]) throws -> [UInt8] {
guard var spki = try? SubjectPublicKeyInfo(derEncoded: derEncoded),
spki.algorithmIdentifier.algorithm == .AlgorithmIdentifier.rsaPSS
else {
// If it's neither a SPKI nor a PSS key, we don't have to modify it.
return derEncoded
}
spki.algorithmIdentifier.algorithm = .AlgorithmIdentifier.rsaEncryption
spki.algorithmIdentifier.parameters = try ASN1Any(erasing: ASN1Null())
var serializer = DER.Serializer()
try serializer.serialize(spki)
return serializer.serializedBytes
}
}
@@ -13,7 +13,7 @@
//===----------------------------------------------------------------------===//
#if CRYPTO_IN_SWIFTPM && !CRYPTO_IN_SWIFTPM_FORCE_BUILD_API
#else
@testable import Crypto
@testable import CryptoBoringWrapper
import XCTest
final class ArbitraryPrecisionIntegerTests: XCTestCase {
@@ -43,7 +43,7 @@ final class ArbitraryPrecisionIntegerTests: XCTestCase {
func testPositiveSquareRoot() {
XCTAssertNoThrow(XCTAssertEqual(try ArbitraryPrecisionInteger(144).positiveSquareRoot(), 12))
XCTAssertThrowsError(try ArbitraryPrecisionInteger(101).positiveSquareRoot()) { error in
guard case .some(.underlyingCoreCryptoError) = error as? CryptoKitError else {
guard case .some(.underlyingCoreCryptoError) = error as? CryptoBoringWrapperError else {
XCTFail("Unexpected error: \(error)")
return
}
@@ -13,7 +13,7 @@
//===----------------------------------------------------------------------===//
#if CRYPTO_IN_SWIFTPM && !CRYPTO_IN_SWIFTPM_FORCE_BUILD_API
#else
@testable import Crypto
@testable import CryptoBoringWrapper
import XCTest
final class FiniteFieldArithmeticTests: XCTestCase {
@@ -115,7 +115,7 @@ final class FiniteFieldArithmeticTests: XCTestCase {
XCTAssertEqual(try ff.pow(secret: x, secret: p), expectedResult, message)
} else {
XCTAssertThrowsError(try ff.pow(secret: x, p), message) { error in
switch error as? CryptoKitError {
switch error as? CryptoBoringWrapperError {
case .incorrectParameterSize: break // OK
default: XCTFail("Unexpected error: \(error)")
}
@@ -202,4 +202,37 @@ final class TestRSABlindSigning: XCTestCase {
parameters: .RSABSSA_SHA384_PSS_Randomized
)
}
func testConstructAndUseKeyFromRSANumbersWhileRecoveringPrimes() throws {
let data = Array("hello, world!".utf8)
for testVector in RFC9474TestVector.allValues {
let key = try _RSA.BlindSigning.PrivateKey._createFromNumbers(
n: Data(hexString: testVector.n),
e: Data(hexString: testVector.e),
d: Data(hexString: testVector.d),
parameters: testVector.parameters
)
let preparedMessage = key.publicKey.prepare(data)
let blindedMessage = try key.publicKey.blind(preparedMessage)
let blindSignature = try key.blindSignature(for: blindedMessage.blindedMessage)
let signature = try key.publicKey.finalize(blindSignature, for: preparedMessage, blindingInverse: blindedMessage.inverse)
XCTAssert(key.publicKey.isValidSignature(signature, for: preparedMessage))
}
}
func testGetKeyPrimitives() throws {
for testVector in RFC9474TestVector.allValues {
let n = try Data(hexString: testVector.n)
let e = try Data(hexString: testVector.e)
let primitives = try _RSA.BlindSigning.PublicKey(
n: n, e: e,
parameters: testVector.parameters
).getKeyPrimitives()
XCTAssertEqual(primitives.modulus, n)
XCTAssertEqual(primitives.publicExponent, e)
}
}
}
@@ -108,6 +108,34 @@ final class TestRSAEncryption: XCTestCase {
e: bytesValues.randomElement()!
)
}
func testConstructAndUseKeyFromRSANumbersWhileRecoveringPrimes() throws {
let data = Array("hello, world!".utf8)
for testVector in RFC9474TestVector.allValues {
let key = try _RSA.Encryption.PrivateKey._createFromNumbers(
n: Data(hexString: testVector.n),
e: Data(hexString: testVector.e),
d: Data(hexString: testVector.d)
)
let encrypted = try key.publicKey.encrypt(data, padding: .PKCS1_OAEP_SHA256)
let decrypted = try key.decrypt(encrypted, padding: .PKCS1_OAEP_SHA256)
XCTAssertEqual(Data(data), decrypted)
}
}
func testGetKeyPrimitives() throws {
for testVector in RFC9474TestVector.allValues {
let n = try Data(hexString: testVector.n)
let e = try Data(hexString: testVector.e)
let primitives = try _RSA.Encryption.PublicKey(n: n, e: e).getKeyPrimitives()
XCTAssertEqual(primitives.modulus, n)
XCTAssertEqual(primitives.publicExponent, e)
}
}
}
struct RSAEncryptionOAEPTestGroup: Codable {
+123 -2
View File
@@ -13,10 +13,61 @@
//===----------------------------------------------------------------------===//
import Foundation
import XCTest
@testable import Crypto
import _CryptoExtras
import Crypto
import CryptoBoringWrapper
@testable import _CryptoExtras
final class TestRSASigning: XCTestCase {
func test_rsaPssParameters() throws {
let rsaPssPublicKeyPEM = """
-----BEGIN PUBLIC KEY-----
MIIBUjA9BgkqhkiG9w0BAQowMKANMAsGCWCGSAFlAwQCAaEaMBgGCSqGSIb3DQEB
CDALBglghkgBZQMEAgGiAwIBIAOCAQ8AMIIBCgKCAQEAvcOaxSJoSiiXIQme6HEF
d0/QHjtk5+U1RbeejxeUR80Q1f8E5v7+uIBEFVbwZpIJZtmSB3bxbS31rOBGVcrI
IAfCnUlq6DK1fEL1fgn61XMiSSyKr75L5ZXv9Rib95h3lrNbhW0DUaXzf61kw3+Z
4KV1btD7C+fdiLzPm18UQv8jJSbCE6hv3MWdkG3NcwgZC+iXwz3DFcsclyYg/+Om
0hx8UJ/34vNpeE+0MHwyl0j/eO7izrzTZnfsm4ZRaU3mw0ORDQmo8MyIDFa55R/v
30otk9y3LFkaeEyl1+7VFjJzoOEtze6VkTEzV8e/BTu4eXlKQ6CEYvHhUkNmHGC+
mwIDAQAB
-----END PUBLIC KEY-----
"""
let rsaPssPublicKeyDER = Data(base64Encoded:
"MIIBUjA9BgkqhkiG9w0BAQowMKANMAsGCWCGSAFlAwQCAaEaMBgGCSqGSIb3DQEB" +
"CDALBglghkgBZQMEAgGiAwIBIAOCAQ8AMIIBCgKCAQEAxPJvJDGPzb2rBWfE5JCB" +
"p2OAmR46zIbaVjIR1lUabKCdb5CxdnHvQBymp3AlvOGTNzSLxTXOaYn7MzeFvAVI" +
"mpRRzXzalG0ZfM4AkPBtjPz93pPLWEfgk+/i+JLWlWUStUGgGKNbJn4yJ8cJ8n+E" +
"/5+ry+tUYHEJm9A4/HwH4Agg78kPtnEvIvdC/aIw4TEpjZDewVNAEW2rBuQNd01r" +
"fAo2CSzbH76gL02mnLuvh1xyrKz+v9gyo9Taw273KU+83HPs91obgX4WpEfWOnd6" +
"LMJHRZo92FXnW6IHkCdz12khyS1TVIq4ONwjvmS6q3V9UwQg/uuyoSNnRfWXvZXQ" +
"aQIDAQAB"
)!
let rsaPssPublicKey1024PEM = """
-----BEGIN PUBLIC KEY-----
MIHPMD0GCSqGSIb3DQEBCjAwoA0wCwYJYIZIAWUDBAIBoRowGAYJKoZIhvcNAQEI
MAsGCWCGSAFlAwQCAaIDAgEgA4GNADCBiQKBgQDGv67JltnwgkFxQOI8YUldC1LG
rCLOpyAN/Vq4WyLQ6TKcPevcYA8XmuXL8tC85rMQQG1GMwMWKcf/kf0NDKblUFjZ
BevUPmQF3Jadsn9ST+RMn8D+kq31Hdc0UG/WjZSpMHTkc8SWIjr2E6DIILn/OA/w
G3jVOeTsEfUeGExhVwIDAQAB
-----END PUBLIC KEY-----
"""
let rsaPssPublicKey1024DER = Data(base64Encoded:
"MIHPMD0GCSqGSIb3DQEBCjAwoA0wCwYJYIZIAWUDBAIBoRowGAYJKoZIhvcNAQEI" +
"MAsGCWCGSAFlAwQCAaIDAgEgA4GNADCBiQKBgQC7LZLbFhzOCoTmXEABRsyOkRiB" +
"18XkkJBwTkn2JES1jVZogXtcq5ZV+KmPulOrzLuaC45IliS5OZ1hJuC7m8/devXk" +
"HaNId+y2cZxRYnfNCsEzvTryxt+01VMQJA4VHsdmhJO6TEIUzDIfj3BlahZuoU11" +
"VZ4wgVIpYymQidJigQIDAQAB"
)!
XCTAssertEqual(try _RSA.Signing.PublicKey(pemRepresentation: rsaPssPublicKeyPEM).keySizeInBits, 2048)
XCTAssertEqual(try _RSA.Signing.PublicKey(derRepresentation: rsaPssPublicKeyDER).keySizeInBits, 2048)
XCTAssertEqual(try _RSA.Signing.PublicKey(unsafePEMRepresentation: rsaPssPublicKey1024PEM).keySizeInBits, 1024)
XCTAssertEqual(try _RSA.Signing.PublicKey(unsafeDERRepresentation: rsaPssPublicKey1024DER).keySizeInBits, 1024)
}
func test_wycheproofPKCS1Vectors() throws {
try wycheproofTest(
jsonName: "rsa_signature_test",
@@ -73,6 +124,15 @@ final class TestRSASigning: XCTestCase {
testFunction: self.testPSSGroup)
}
func test_wycheproofPrimitives() throws {
try wycheproofTest(
jsonName: "rsa_oaep_2048_sha1_mgf1sha1_test",
testFunction: self.testPrimeFactors)
try wycheproofTest(
jsonName: "rsa_oaep_2048_sha256_mgf1sha256_test",
testFunction: self.testPrimeFactors)
}
func testPKCS1Signing() throws {
try self.testPKCS1Signing(_RSA.Signing.PrivateKey(keySize: .bits2048))
try self.testPKCS1Signing(_RSA.Signing.PrivateKey(keySize: .bits3072))
@@ -708,6 +768,34 @@ final class TestRSASigning: XCTestCase {
)
}
func testConstructAndUseKeyFromRSANumbersWhileRecoveringPrimes() throws {
let data = Array("hello, world!".utf8)
for testVector in RFC9474TestVector.allValues {
let key = try _RSA.Signing.PrivateKey._createFromNumbers(
n: Data(hexString: testVector.n),
e: Data(hexString: testVector.e),
d: Data(hexString: testVector.d)
)
let signature = try key.signature(for: data)
let roundTripped = _RSA.Signing.RSASignature(rawRepresentation: signature.rawRepresentation)
XCTAssertEqual(signature.rawRepresentation, roundTripped.rawRepresentation)
XCTAssertTrue(key.publicKey.isValidSignature(roundTripped, for: data))
}
}
func testGetKeyPrimitives() throws {
for testVector in RFC9474TestVector.allValues {
let n = try Data(hexString: testVector.n)
let e = try Data(hexString: testVector.e)
let primitives = try _RSA.Signing.PublicKey(n: n, e: e).getKeyPrimitives()
XCTAssertEqual(primitives.modulus, n)
XCTAssertEqual(primitives.publicExponent, e)
}
}
private func testPKCS1Group(_ group: RSAPKCS1TestGroup) throws {
let derKey: _RSA.Signing.PublicKey
let pemKey: _RSA.Signing.PublicKey
@@ -790,6 +878,15 @@ final class TestRSASigning: XCTestCase {
}
}
private func testPrimeFactors(_ group: RSAPrimitivesTestGroup) throws {
let n = try ArbitraryPrecisionInteger(hexString: group.n)
let e = try ArbitraryPrecisionInteger(hexString: group.e)
let d = try ArbitraryPrecisionInteger(hexString: group.d)
let (p, q) = try _RSA.extractPrimeFactors(n: n, e: e, d: d)
XCTAssertEqual(p * q, n, "The product of p and q should equal n; got \(p) * \(q) != \(n)")
}
private func pemForDERBytes(discriminator: String, derBytes: Data) -> String {
let lineLength = 64
var encoded = derBytes.base64EncodedString()[...]
@@ -871,3 +968,27 @@ struct RSATest: Codable {
}
}
}
struct RSAPrimitivesTestGroup: Codable {
let n: String
let e: String
let d: String
let privateKeyJwk: PrivateKeyJWK?
struct PrivateKeyJWK: Codable {
let kty: String
let n: String
let e: String
let d: String
let p: String
let q: String
let dp: String
let dq: String
let qi: String
}
}
struct RSAPrimitivesTestVectors: Codable {
let testGroups: [RSAPrimitivesTestGroup]
}
-21
View File
@@ -1,21 +0,0 @@
version: "3"
services:
runtime-setup:
image: swift-crypto:22.04-5.8
build:
args:
ubuntu_version: "jammy"
swift_version: "5.8"
test:
image: swift-crypto:22.04-5.8
environment: []
#- SANITIZER_ARG=--sanitize=thread
cmake:
image: swift-crypto:22.04-5.8
shell:
image: swift-crypto:22.04-5.8
+2 -10
View File
@@ -101,9 +101,9 @@ function mangle_symbols {
)
# Now cross compile for our targets.
docker run -t -i --rm --privileged -v$(pwd):/src -w/src --platform linux/arm64 swift:5.8-jammy \
docker run -t -i --rm --privileged -v$(pwd):/src -w/src --platform linux/arm64 swift:5.9-jammy \
swift build --product CCryptoBoringSSL
docker run -t -i --rm --privileged -v$(pwd):/src -w/src --platform linux/amd64 swift:5.8-jammy \
docker run -t -i --rm --privileged -v$(pwd):/src -w/src --platform linux/amd64 swift:5.9-jammy \
swift build --product CCryptoBoringSSL
# Now we need to generate symbol mangles for Linux. We can do this in
@@ -241,14 +241,6 @@ echo "REMOVING libssl"
mangle_symbols
# Removing ASM on 32 bit Apple platforms
echo "REMOVING assembly on 32-bit Apple platforms"
gsed -i "/#define OPENSSL_HEADER_BASE_H/a#if defined(__APPLE__) && defined(__i386__)\n#define OPENSSL_NO_ASM\n#endif" "$DSTROOT/include/openssl/base.h"
# Remove assembly on non-x86 Windows
echo "REMOVING assembly on non-x86 Windows"
gsed -i "/#define OPENSSL_HEADER_BASE_H/a#if defined(_WIN32) && !(defined(_M_IX86) || defined(__i386__))\n#define OPENSSL_NO_ASM\n#endif" "$DSTROOT/include/openssl/base.h"
echo "RENAMING header files"
(
# We need to rearrange a coouple of things here, the end state will be: