mirror of
https://github.com/apple/swift-crypto
synced 2026-11-22 04:30:39 +00:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
629f0b679d | ||
|
|
953b34a601 | ||
|
|
710deacf79 | ||
|
|
a234f8a62e | ||
|
|
9c1b699540 | ||
|
|
5ac5632286 | ||
|
|
cba358dec9 | ||
|
|
c433cd3341 | ||
|
|
940a631a68 | ||
|
|
dcf0815f8f | ||
|
|
33a20e650c | ||
|
|
65f8c60ab3 | ||
|
|
1863cc9dcf |
No files matched your search
+1
-53
@@ -1,55 +1,3 @@
|
||||
# Code of Conduct
|
||||
To be a truly great community, swift-crypto needs to welcome developers from all walks of life,
|
||||
with different backgrounds, and with a wide range of experience. A diverse and friendly
|
||||
community will have more great ideas, more unique perspectives, and produce more great
|
||||
code. We will work diligently to make the swift-crypto community welcoming to everyone.
|
||||
|
||||
To give clarity of what is expected of our members, swift-crypto has adopted the code of conduct
|
||||
defined by [contributor-covenant.org](https://www.contributor-covenant.org). This document is used across many open source
|
||||
communities, and we think it articulates our values well. The full text is copied below:
|
||||
|
||||
### Contributor Code of Conduct v1.3
|
||||
As contributors and maintainers of this project, and in the interest of fostering an open and
|
||||
welcoming community, we pledge to respect all people who contribute through reporting
|
||||
issues, posting feature requests, updating documentation, submitting pull requests or patches,
|
||||
and other activities.
|
||||
|
||||
We are committed to making participation in this project a harassment-free experience for
|
||||
everyone, regardless of level of experience, gender, gender identity and expression, sexual
|
||||
orientation, disability, personal appearance, body size, race, ethnicity, age, religion, or
|
||||
nationality.
|
||||
|
||||
Examples of unacceptable behavior by participants include:
|
||||
- The use of sexualized language or imagery
|
||||
- Personal attacks
|
||||
- Trolling or insulting/derogatory comments
|
||||
- Public or private harassment
|
||||
- Publishing other’s private information, such as physical or electronic addresses, without explicit permission
|
||||
- Other unethical or unprofessional conduct
|
||||
|
||||
Project maintainers have the right and responsibility to remove, edit, or reject comments,
|
||||
commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of
|
||||
Conduct, or to ban temporarily or permanently any contributor for other behaviors that they
|
||||
deem inappropriate, threatening, offensive, or harmful.
|
||||
|
||||
By adopting this Code of Conduct, project maintainers commit themselves to fairly and
|
||||
consistently applying these principles to every aspect of managing this project. Project
|
||||
maintainers who do not follow or enforce the Code of Conduct may be permanently removed
|
||||
from the project team.
|
||||
|
||||
This code of conduct applies both within project spaces and in public spaces when an
|
||||
individual is representing the project or its community.
|
||||
|
||||
Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by
|
||||
contacting a project maintainer at [swift-server-conduct@group.apple.com](mailto:swift-server-conduct@group.apple.com). All complaints will be reviewed and
|
||||
investigated and will result in a response that is deemed necessary and appropriate to the
|
||||
circumstances. Maintainers are obligated to maintain confidentiality with regard to the reporter
|
||||
of an incident.
|
||||
|
||||
*This policy is adapted from the Contributor Code of Conduct [version 1.3.0](https://contributor-covenant.org/version/1/3/0/).*
|
||||
|
||||
### Reporting
|
||||
A working group of community members is committed to promptly addressing any [reported issues](mailto:swift-server-conduct@group.apple.com).
|
||||
Working group members are volunteers appointed by the project lead, with a
|
||||
preference for individuals with varied backgrounds and perspectives. Membership is expected
|
||||
to change regularly, and may grow or shrink.
|
||||
The code of conduct for this project can be found at https://swift.org/code-of-conduct.
|
||||
+19
-12
@@ -1,4 +1,4 @@
|
||||
// swift-tools-version:5.5
|
||||
// swift-tools-version:5.6
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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: abfd5ebc87ddca0fab9fca067c9d7edbc355eae8
|
||||
// BoringSSL Commit: 7ae2b910c13017b63f1a8bd6c8decfce692869b0
|
||||
|
||||
import PackageDescription
|
||||
|
||||
@@ -40,15 +40,16 @@ if development {
|
||||
"CryptoBoringWrapper"
|
||||
]
|
||||
} else {
|
||||
swiftSettings = [
|
||||
.define("CRYPTO_IN_SWIFTPM"),
|
||||
]
|
||||
let platforms: [Platform] = [
|
||||
Platform.linux,
|
||||
Platform.android,
|
||||
Platform.windows,
|
||||
Platform.wasi,
|
||||
]
|
||||
swiftSettings = [
|
||||
.define("CRYPTO_IN_SWIFTPM"),
|
||||
.define("CRYPTO_IN_SWIFTPM_FORCE_BUILD_API", .when(platforms: platforms)),
|
||||
]
|
||||
dependencies = [
|
||||
.target(name: "CCryptoBoringSSL", condition: .when(platforms: platforms)),
|
||||
.target(name: "CCryptoBoringSSLShims", condition: .when(platforms: platforms)),
|
||||
@@ -88,12 +89,11 @@ let package = Package(
|
||||
"crypto/bio/socket.c"
|
||||
],
|
||||
cSettings: [
|
||||
/*
|
||||
* This define is required on Windows, but because we need older
|
||||
* versions of SPM, we cannot conditionally define this on Windows
|
||||
* only. Unconditionally define it instead.
|
||||
*/
|
||||
.define("WIN32_LEAN_AND_MEAN"),
|
||||
// These defines come from BoringSSL's build system
|
||||
.define("_HAS_EXCEPTIONS", to: "0", .when(platforms: [Platform.windows])),
|
||||
.define("WIN32_LEAN_AND_MEAN", .when(platforms: [Platform.windows])),
|
||||
.define("NOMINMAX", .when(platforms: [Platform.windows])),
|
||||
.define("_CRT_SECURE_NO_WARNINGS", .when(platforms: [Platform.windows])),
|
||||
/*
|
||||
* These defines are required on Wasm/WASI, to disable use of pthread.
|
||||
*/
|
||||
@@ -143,7 +143,14 @@ let package = Package(
|
||||
]
|
||||
),
|
||||
.executableTarget(name: "crypto-shasum", dependencies: ["Crypto"]),
|
||||
.testTarget(name: "CryptoTests", dependencies: ["Crypto"], swiftSettings: swiftSettings),
|
||||
.testTarget(
|
||||
name: "CryptoTests",
|
||||
dependencies: ["Crypto"],
|
||||
resources: [
|
||||
.copy("HPKE/hpke-test-vectors.json"),
|
||||
],
|
||||
swiftSettings: swiftSettings
|
||||
),
|
||||
.testTarget(name: "_CryptoExtrasTests", dependencies: ["_CryptoExtras"]),
|
||||
],
|
||||
cxxLanguageStandard: .cxx11
|
||||
|
||||
@@ -108,13 +108,14 @@ If you believe you have identified a vulnerability in Swift Crypto, please [repo
|
||||
|
||||
### Swift versions
|
||||
|
||||
The most recent versions of Swift Crypto support Swift 5.5 and newer. The minimum Swift version supported by Swift Crypto releases are detailed below:
|
||||
The most recent versions of Swift Crypto support Swift 5.6 and newer. The minimum Swift version supported by Swift Crypto releases are detailed below:
|
||||
|
||||
Swift Crypto | Minimum Swift Version
|
||||
------------------|----------------------
|
||||
`2.0.0 ..< 2.1.0` | 5.2
|
||||
`2.1.0 ..< 2.2.0` | 5.4
|
||||
`2.2.0 ...` | 5.5
|
||||
`2.2.0 ..< 2.4.2` | 5.5
|
||||
`2.4.2 ...` | 5.6
|
||||
|
||||
### Compatibility
|
||||
|
||||
|
||||
+9
-5
@@ -44,6 +44,7 @@ add_library(CCryptoBoringSSL STATIC
|
||||
"crypto/bio/bio.c"
|
||||
"crypto/bio/bio_mem.c"
|
||||
"crypto/bio/connect.c"
|
||||
"crypto/bio/errno.c"
|
||||
"crypto/bio/fd.c"
|
||||
"crypto/bio/file.c"
|
||||
"crypto/bio/hexdump.c"
|
||||
@@ -74,9 +75,10 @@ add_library(CCryptoBoringSSL STATIC
|
||||
"crypto/cipher_extra/tls_cbc.c"
|
||||
"crypto/conf/conf.c"
|
||||
"crypto/cpu_aarch64_apple.c"
|
||||
"crypto/cpu_aarch64_freebsd.c"
|
||||
"crypto/cpu_aarch64_fuchsia.c"
|
||||
"crypto/cpu_aarch64_linux.c"
|
||||
"crypto/cpu_aarch64_openbsd.c"
|
||||
"crypto/cpu_aarch64_sysreg.c"
|
||||
"crypto/cpu_aarch64_win.c"
|
||||
"crypto/cpu_arm.c"
|
||||
"crypto/cpu_arm_freebsd.c"
|
||||
@@ -84,6 +86,7 @@ add_library(CCryptoBoringSSL STATIC
|
||||
"crypto/cpu_intel.c"
|
||||
"crypto/crypto.c"
|
||||
"crypto/curve25519/curve25519.c"
|
||||
"crypto/curve25519/curve25519_64_adx.c"
|
||||
"crypto/curve25519/spake25519.c"
|
||||
"crypto/des/des.c"
|
||||
"crypto/dh_extra/dh_asn1.c"
|
||||
@@ -168,6 +171,7 @@ add_library(CCryptoBoringSSL STATIC
|
||||
"crypto/fipsmodule/ecdh/ecdh.c"
|
||||
"crypto/fipsmodule/ecdsa/ecdsa.c"
|
||||
"crypto/fipsmodule/fips_shared_support.c"
|
||||
"crypto/fipsmodule/hkdf/hkdf.c"
|
||||
"crypto/fipsmodule/hmac/hmac.c"
|
||||
"crypto/fipsmodule/md4/md4.c"
|
||||
"crypto/fipsmodule/md5/md5.c"
|
||||
@@ -193,7 +197,6 @@ add_library(CCryptoBoringSSL STATIC
|
||||
"crypto/fipsmodule/sha/sha256.c"
|
||||
"crypto/fipsmodule/sha/sha512.c"
|
||||
"crypto/fipsmodule/tls/kdf.c"
|
||||
"crypto/hkdf/hkdf.c"
|
||||
"crypto/hpke/hpke.c"
|
||||
"crypto/hrss/hrss.c"
|
||||
"crypto/kyber/keccak.c"
|
||||
@@ -221,13 +224,14 @@ add_library(CCryptoBoringSSL STATIC
|
||||
"crypto/pool/pool.c"
|
||||
"crypto/rand_extra/deterministic.c"
|
||||
"crypto/rand_extra/forkunsafe.c"
|
||||
"crypto/rand_extra/fuchsia.c"
|
||||
"crypto/rand_extra/getentropy.c"
|
||||
"crypto/rand_extra/ios.c"
|
||||
"crypto/rand_extra/passive.c"
|
||||
"crypto/rand_extra/rand_extra.c"
|
||||
"crypto/rand_extra/trusty.c"
|
||||
"crypto/rand_extra/windows.c"
|
||||
"crypto/rc4/rc4.c"
|
||||
"crypto/refcount_c11.c"
|
||||
"crypto/refcount_lock.c"
|
||||
"crypto/refcount.c"
|
||||
"crypto/rsa_extra/rsa_asn1.c"
|
||||
"crypto/rsa_extra/rsa_crypt.c"
|
||||
"crypto/rsa_extra/rsa_print.c"
|
||||
|
||||
@@ -60,6 +60,7 @@
|
||||
#include <CCryptoBoringSSL_mem.h>
|
||||
#include <CCryptoBoringSSL_time.h>
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
|
||||
@@ -123,9 +124,12 @@ ASN1_GENERALIZEDTIME *ASN1_GENERALIZEDTIME_adj(ASN1_GENERALIZEDTIME *s,
|
||||
}
|
||||
|
||||
char buf[16];
|
||||
BIO_snprintf(buf, sizeof(buf), "%04d%02d%02d%02d%02d%02dZ",
|
||||
data.tm_year + 1900, data.tm_mon + 1, data.tm_mday, data.tm_hour,
|
||||
data.tm_min, data.tm_sec);
|
||||
int ret = snprintf(buf, sizeof(buf), "%04d%02d%02d%02d%02d%02dZ",
|
||||
data.tm_year + 1900, data.tm_mon + 1, data.tm_mday,
|
||||
data.tm_hour, data.tm_min, data.tm_sec);
|
||||
if (ret != (int)(sizeof(buf) - 1)) {
|
||||
abort(); // |snprintf| should neither truncate nor write fewer bytes.
|
||||
}
|
||||
|
||||
int free_s = 0;
|
||||
if (s == NULL) {
|
||||
|
||||
@@ -73,18 +73,19 @@
|
||||
// horrible: it has to be :-( The 'ncopy' form checks minimum and maximum
|
||||
// size limits too.
|
||||
|
||||
int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in, int len,
|
||||
int inform, unsigned long mask) {
|
||||
return ASN1_mbstring_ncopy(out, in, len, inform, mask, 0, 0);
|
||||
int ASN1_mbstring_copy(ASN1_STRING **out, const unsigned char *in,
|
||||
ossl_ssize_t len, int inform, unsigned long mask) {
|
||||
return ASN1_mbstring_ncopy(out, in, len, inform, mask, /*minsize=*/0,
|
||||
/*maxsize=*/0);
|
||||
}
|
||||
|
||||
OPENSSL_DECLARE_ERROR_REASON(ASN1, INVALID_BMPSTRING)
|
||||
OPENSSL_DECLARE_ERROR_REASON(ASN1, INVALID_UNIVERSALSTRING)
|
||||
OPENSSL_DECLARE_ERROR_REASON(ASN1, INVALID_UTF8STRING)
|
||||
|
||||
int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
|
||||
int inform, unsigned long mask, long minsize,
|
||||
long maxsize) {
|
||||
int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in,
|
||||
ossl_ssize_t len, int inform, unsigned long mask,
|
||||
ossl_ssize_t minsize, ossl_ssize_t maxsize) {
|
||||
if (len == -1) {
|
||||
len = strlen((const char *)in);
|
||||
}
|
||||
@@ -164,14 +165,14 @@ int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in, int len,
|
||||
utf8_len += cbb_get_utf8_len(c);
|
||||
if (maxsize > 0 && nchar > (size_t)maxsize) {
|
||||
OPENSSL_PUT_ERROR(ASN1, ASN1_R_STRING_TOO_LONG);
|
||||
ERR_add_error_dataf("maxsize=%ld", maxsize);
|
||||
ERR_add_error_dataf("maxsize=%zu", (size_t)maxsize);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
if (minsize > 0 && nchar < (size_t)minsize) {
|
||||
OPENSSL_PUT_ERROR(ASN1, ASN1_R_STRING_TOO_SHORT);
|
||||
ERR_add_error_dataf("minsize=%ld", minsize);
|
||||
ERR_add_error_dataf("minsize=%zu", (size_t)minsize);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
@@ -89,18 +89,18 @@ static int do_esc_char(uint32_t c, unsigned long flags, char *do_quotes,
|
||||
char buf[16]; // Large enough for "\\W01234567".
|
||||
unsigned char u8 = (unsigned char)c;
|
||||
if (c > 0xffff) {
|
||||
BIO_snprintf(buf, sizeof(buf), "\\W%08" PRIX32, c);
|
||||
snprintf(buf, sizeof(buf), "\\W%08" PRIX32, c);
|
||||
} else if (c > 0xff) {
|
||||
BIO_snprintf(buf, sizeof(buf), "\\U%04" PRIX32, c);
|
||||
snprintf(buf, sizeof(buf), "\\U%04" PRIX32, c);
|
||||
} else if ((flags & ASN1_STRFLGS_ESC_MSB) && c > 0x7f) {
|
||||
BIO_snprintf(buf, sizeof(buf), "\\%02X", c);
|
||||
snprintf(buf, sizeof(buf), "\\%02X", c);
|
||||
} else if ((flags & ASN1_STRFLGS_ESC_CTRL) && is_control_character(c)) {
|
||||
BIO_snprintf(buf, sizeof(buf), "\\%02X", c);
|
||||
snprintf(buf, sizeof(buf), "\\%02X", c);
|
||||
} else if (flags & ASN1_STRFLGS_ESC_2253) {
|
||||
// See RFC 2253, sections 2.4 and 4.
|
||||
if (c == '\\' || c == '"') {
|
||||
// Quotes and backslashes are always escaped, quoted or not.
|
||||
BIO_snprintf(buf, sizeof(buf), "\\%c", (int)c);
|
||||
snprintf(buf, sizeof(buf), "\\%c", (int)c);
|
||||
} else if (c == ',' || c == '+' || c == '<' || c == '>' || c == ';' ||
|
||||
(is_first && (c == ' ' || c == '#')) ||
|
||||
(is_last && (c == ' '))) {
|
||||
@@ -111,13 +111,13 @@ static int do_esc_char(uint32_t c, unsigned long flags, char *do_quotes,
|
||||
}
|
||||
return maybe_write(out, &u8, 1) ? 1 : -1;
|
||||
}
|
||||
BIO_snprintf(buf, sizeof(buf), "\\%c", (int)c);
|
||||
snprintf(buf, sizeof(buf), "\\%c", (int)c);
|
||||
} else {
|
||||
return maybe_write(out, &u8, 1) ? 1 : -1;
|
||||
}
|
||||
} else if ((flags & ESC_FLAGS) && c == '\\') {
|
||||
// If any escape flags are set, also escape backslashes.
|
||||
BIO_snprintf(buf, sizeof(buf), "\\%c", (int)c);
|
||||
snprintf(buf, sizeof(buf), "\\%c", (int)c);
|
||||
} else {
|
||||
return maybe_write(out, &u8, 1) ? 1 : -1;
|
||||
}
|
||||
|
||||
@@ -72,7 +72,7 @@
|
||||
DEFINE_LHASH_OF(ASN1_STRING_TABLE)
|
||||
|
||||
static LHASH_OF(ASN1_STRING_TABLE) *string_tables = NULL;
|
||||
static struct CRYPTO_STATIC_MUTEX string_tables_lock = CRYPTO_STATIC_MUTEX_INIT;
|
||||
static CRYPTO_MUTEX string_tables_lock = CRYPTO_MUTEX_INIT;
|
||||
|
||||
void ASN1_STRING_set_default_mask(unsigned long mask) {}
|
||||
|
||||
@@ -87,7 +87,7 @@ static const ASN1_STRING_TABLE *asn1_string_table_get(int nid);
|
||||
// a corresponding OID. For example certificates and certificate requests.
|
||||
|
||||
ASN1_STRING *ASN1_STRING_set_by_NID(ASN1_STRING **out, const unsigned char *in,
|
||||
int len, int inform, int nid) {
|
||||
ossl_ssize_t len, int inform, int nid) {
|
||||
ASN1_STRING *str = NULL;
|
||||
int ret;
|
||||
if (!out) {
|
||||
@@ -176,11 +176,11 @@ static const ASN1_STRING_TABLE *asn1_string_table_get(int nid) {
|
||||
return tbl;
|
||||
}
|
||||
|
||||
CRYPTO_STATIC_MUTEX_lock_read(&string_tables_lock);
|
||||
CRYPTO_MUTEX_lock_read(&string_tables_lock);
|
||||
if (string_tables != NULL) {
|
||||
tbl = lh_ASN1_STRING_TABLE_retrieve(string_tables, &key);
|
||||
}
|
||||
CRYPTO_STATIC_MUTEX_unlock_read(&string_tables_lock);
|
||||
CRYPTO_MUTEX_unlock_read(&string_tables_lock);
|
||||
// Note returning |tbl| without the lock is only safe because
|
||||
// |ASN1_STRING_TABLE_add| cannot modify or delete existing entries. If we
|
||||
// wish to support that, this function must copy the result under a lock.
|
||||
@@ -196,7 +196,7 @@ int ASN1_STRING_TABLE_add(int nid, long minsize, long maxsize,
|
||||
}
|
||||
|
||||
int ret = 0;
|
||||
CRYPTO_STATIC_MUTEX_lock_write(&string_tables_lock);
|
||||
CRYPTO_MUTEX_lock_write(&string_tables_lock);
|
||||
|
||||
if (string_tables == NULL) {
|
||||
string_tables = lh_ASN1_STRING_TABLE_new(table_hash, table_cmp);
|
||||
@@ -232,7 +232,7 @@ int ASN1_STRING_TABLE_add(int nid, long minsize, long maxsize,
|
||||
ret = 1;
|
||||
|
||||
err:
|
||||
CRYPTO_STATIC_MUTEX_unlock_write(&string_tables_lock);
|
||||
CRYPTO_MUTEX_unlock_write(&string_tables_lock);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
@@ -61,6 +61,7 @@
|
||||
#include <time.h>
|
||||
|
||||
#include <CCryptoBoringSSL_asn1t.h>
|
||||
#include <CCryptoBoringSSL_bytestring.h>
|
||||
#include <CCryptoBoringSSL_err.h>
|
||||
#include <CCryptoBoringSSL_mem.h>
|
||||
|
||||
@@ -82,6 +83,10 @@ ASN1_TIME *ASN1_TIME_set(ASN1_TIME *s, time_t time) {
|
||||
return ASN1_TIME_adj(s, time, 0, 0);
|
||||
}
|
||||
|
||||
static int fits_in_utc_time(const struct tm *tm) {
|
||||
return 50 <= tm->tm_year && tm->tm_year < 150;
|
||||
}
|
||||
|
||||
ASN1_TIME *ASN1_TIME_adj(ASN1_TIME *s, int64_t posix_time, int offset_day,
|
||||
long offset_sec) {
|
||||
struct tm tm;
|
||||
@@ -95,7 +100,7 @@ ASN1_TIME *ASN1_TIME_adj(ASN1_TIME *s, int64_t posix_time, int offset_day,
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
if ((tm.tm_year >= 50) && (tm.tm_year < 150)) {
|
||||
if (fits_in_utc_time(&tm)) {
|
||||
return ASN1_UTCTIME_adj(s, posix_time, offset_day, offset_sec);
|
||||
}
|
||||
return ASN1_GENERALIZEDTIME_adj(s, posix_time, offset_day, offset_sec);
|
||||
@@ -171,6 +176,34 @@ int ASN1_TIME_set_string(ASN1_TIME *s, const char *str) {
|
||||
ASN1_GENERALIZEDTIME_set_string(s, str);
|
||||
}
|
||||
|
||||
int ASN1_TIME_set_string_X509(ASN1_TIME *s, const char *str) {
|
||||
CBS cbs;
|
||||
CBS_init(&cbs, (const uint8_t*)str, strlen(str));
|
||||
int type;
|
||||
struct tm tm;
|
||||
if (CBS_parse_utc_time(&cbs, /*out_tm=*/NULL,
|
||||
/*allow_timezone_offset=*/0)) {
|
||||
type = V_ASN1_UTCTIME;
|
||||
} else if (CBS_parse_generalized_time(&cbs, &tm,
|
||||
/*allow_timezone_offset=*/0)) {
|
||||
type = V_ASN1_GENERALIZEDTIME;
|
||||
if (fits_in_utc_time(&tm)) {
|
||||
type = V_ASN1_UTCTIME;
|
||||
CBS_skip(&cbs, 2);
|
||||
}
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (s != NULL) {
|
||||
if (!ASN1_STRING_set(s, CBS_data(&cbs), CBS_len(&cbs))) {
|
||||
return 0;
|
||||
}
|
||||
s->type = type;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int asn1_time_to_tm(struct tm *tm, const ASN1_TIME *t,
|
||||
int allow_timezone_offset) {
|
||||
if (t == NULL) {
|
||||
|
||||
@@ -60,6 +60,7 @@
|
||||
#include <CCryptoBoringSSL_mem.h>
|
||||
#include <CCryptoBoringSSL_time.h>
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
|
||||
@@ -83,11 +84,14 @@ int ASN1_UTCTIME_check(const ASN1_UTCTIME *d) {
|
||||
}
|
||||
|
||||
int ASN1_UTCTIME_set_string(ASN1_UTCTIME *s, const char *str) {
|
||||
// Although elsewhere we allow timezone offsets with UTCTime, to be compatible
|
||||
// with some existing misissued certificates, this function is used to
|
||||
// construct new certificates and can be stricter.
|
||||
size_t len = strlen(str);
|
||||
CBS cbs;
|
||||
CBS_init(&cbs, (const uint8_t *)str, len);
|
||||
if (!CBS_parse_utc_time(&cbs, /*out_tm=*/NULL,
|
||||
/*allow_timezone_offset=*/1)) {
|
||||
/*allow_timezone_offset=*/0)) {
|
||||
return 0;
|
||||
}
|
||||
if (s != NULL) {
|
||||
@@ -121,9 +125,12 @@ ASN1_UTCTIME *ASN1_UTCTIME_adj(ASN1_UTCTIME *s, int64_t posix_time, int offset_d
|
||||
}
|
||||
|
||||
char buf[14];
|
||||
BIO_snprintf(buf, sizeof(buf), "%02d%02d%02d%02d%02d%02dZ",
|
||||
data.tm_year % 100, data.tm_mon + 1, data.tm_mday, data.tm_hour,
|
||||
data.tm_min, data.tm_sec);
|
||||
int ret = snprintf(buf, sizeof(buf), "%02d%02d%02d%02d%02d%02dZ",
|
||||
data.tm_year % 100, data.tm_mon + 1, data.tm_mday,
|
||||
data.tm_hour, data.tm_min, data.tm_sec);
|
||||
if (ret != (int)(sizeof(buf) - 1)) {
|
||||
abort(); // |snprintf| should neither truncate nor write fewer bytes.
|
||||
}
|
||||
|
||||
int free_s = 0;
|
||||
if (s == NULL) {
|
||||
|
||||
@@ -628,14 +628,14 @@ void BIO_set_retry_special(BIO *bio) {
|
||||
|
||||
int BIO_set_write_buffer_size(BIO *bio, int buffer_size) { return 0; }
|
||||
|
||||
static struct CRYPTO_STATIC_MUTEX g_index_lock = CRYPTO_STATIC_MUTEX_INIT;
|
||||
static CRYPTO_MUTEX g_index_lock = CRYPTO_MUTEX_INIT;
|
||||
static int g_index = BIO_TYPE_START;
|
||||
|
||||
int BIO_get_new_index(void) {
|
||||
CRYPTO_STATIC_MUTEX_lock_write(&g_index_lock);
|
||||
CRYPTO_MUTEX_lock_write(&g_index_lock);
|
||||
// If |g_index| exceeds 255, it will collide with the flags bits.
|
||||
int ret = g_index > 255 ? -1 : g_index++;
|
||||
CRYPTO_STATIC_MUTEX_unlock_write(&g_index_lock);
|
||||
CRYPTO_MUTEX_unlock_write(&g_index_lock);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
@@ -206,7 +206,6 @@ static int mem_gets(BIO *bio, char *buf, int size) {
|
||||
|
||||
static long mem_ctrl(BIO *bio, int cmd, long num, void *ptr) {
|
||||
long ret = 1;
|
||||
char **pptr;
|
||||
|
||||
BUF_MEM *b = (BUF_MEM *)bio->ptr;
|
||||
|
||||
@@ -232,8 +231,8 @@ static long mem_ctrl(BIO *bio, int cmd, long num, void *ptr) {
|
||||
case BIO_CTRL_INFO:
|
||||
ret = (long)b->length;
|
||||
if (ptr != NULL) {
|
||||
pptr = (char **)ptr;
|
||||
*pptr = (char *)&b->data[0];
|
||||
char **pptr = ptr;
|
||||
*pptr = b->data;
|
||||
}
|
||||
break;
|
||||
case BIO_C_SET_BUF_MEM:
|
||||
@@ -243,8 +242,8 @@ static long mem_ctrl(BIO *bio, int cmd, long num, void *ptr) {
|
||||
break;
|
||||
case BIO_C_GET_BUF_MEM_PTR:
|
||||
if (ptr != NULL) {
|
||||
pptr = (char **)ptr;
|
||||
*pptr = (char *)b;
|
||||
BUF_MEM **pptr = ptr;
|
||||
*pptr = b;
|
||||
}
|
||||
break;
|
||||
case BIO_CTRL_GET_CLOSE:
|
||||
@@ -294,15 +293,15 @@ int BIO_mem_contents(const BIO *bio, const uint8_t **out_contents,
|
||||
}
|
||||
|
||||
long BIO_get_mem_data(BIO *bio, char **contents) {
|
||||
return BIO_ctrl(bio, BIO_CTRL_INFO, 0, (char *) contents);
|
||||
return BIO_ctrl(bio, BIO_CTRL_INFO, 0, contents);
|
||||
}
|
||||
|
||||
int BIO_get_mem_ptr(BIO *bio, BUF_MEM **out) {
|
||||
return (int)BIO_ctrl(bio, BIO_C_GET_BUF_MEM_PTR, 0, (char *) out);
|
||||
return (int)BIO_ctrl(bio, BIO_C_GET_BUF_MEM_PTR, 0, out);
|
||||
}
|
||||
|
||||
int BIO_set_mem_buf(BIO *bio, BUF_MEM *b, int take_ownership) {
|
||||
return (int)BIO_ctrl(bio, BIO_C_SET_BUF_MEM, take_ownership, (char *) b);
|
||||
return (int)BIO_ctrl(bio, BIO_C_SET_BUF_MEM, take_ownership, b);
|
||||
}
|
||||
|
||||
int BIO_set_mem_eof_return(BIO *bio, int eof_value) {
|
||||
|
||||
@@ -56,7 +56,7 @@
|
||||
|
||||
#include <CCryptoBoringSSL_bio.h>
|
||||
|
||||
#if !defined(OPENSSL_TRUSTY)
|
||||
#if !defined(OPENSSL_NO_SOCK)
|
||||
|
||||
#include <assert.h>
|
||||
#include <errno.h>
|
||||
@@ -233,7 +233,7 @@ static int conn_state(BIO *bio, BIO_CONNECT *c) {
|
||||
BIO_clear_retry_flags(bio);
|
||||
ret = connect(bio->num, (struct sockaddr*) &c->them, c->them_length);
|
||||
if (ret < 0) {
|
||||
if (bio_fd_should_retry(ret)) {
|
||||
if (bio_socket_should_retry(ret)) {
|
||||
BIO_set_flags(bio, (BIO_FLAGS_IO_SPECIAL | BIO_FLAGS_SHOULD_RETRY));
|
||||
c->state = BIO_CONN_S_BLOCKED_CONNECT;
|
||||
bio->retry_reason = BIO_RR_CONNECT;
|
||||
@@ -252,7 +252,7 @@ static int conn_state(BIO *bio, BIO_CONNECT *c) {
|
||||
case BIO_CONN_S_BLOCKED_CONNECT:
|
||||
i = bio_sock_error(bio->num);
|
||||
if (i) {
|
||||
if (bio_fd_should_retry(ret)) {
|
||||
if (bio_socket_should_retry(ret)) {
|
||||
BIO_set_flags(bio, (BIO_FLAGS_IO_SPECIAL | BIO_FLAGS_SHOULD_RETRY));
|
||||
c->state = BIO_CONN_S_BLOCKED_CONNECT;
|
||||
bio->retry_reason = BIO_RR_CONNECT;
|
||||
@@ -366,7 +366,7 @@ static int conn_read(BIO *bio, char *out, int out_len) {
|
||||
ret = (int)recv(bio->num, out, out_len, 0);
|
||||
BIO_clear_retry_flags(bio);
|
||||
if (ret <= 0) {
|
||||
if (bio_fd_should_retry(ret)) {
|
||||
if (bio_socket_should_retry(ret)) {
|
||||
BIO_set_retry_read(bio);
|
||||
}
|
||||
}
|
||||
@@ -390,7 +390,7 @@ static int conn_write(BIO *bio, const char *in, int in_len) {
|
||||
ret = (int)send(bio->num, in, in_len, 0);
|
||||
BIO_clear_retry_flags(bio);
|
||||
if (ret <= 0) {
|
||||
if (bio_fd_should_retry(ret)) {
|
||||
if (bio_socket_should_retry(ret)) {
|
||||
BIO_set_retry_write(bio);
|
||||
}
|
||||
}
|
||||
@@ -532,7 +532,7 @@ int BIO_set_conn_port(BIO *bio, const char *port_str) {
|
||||
|
||||
int BIO_set_conn_int_port(BIO *bio, const int *port) {
|
||||
char buf[DECIMAL_SIZE(int) + 1];
|
||||
BIO_snprintf(buf, sizeof(buf), "%d", *port);
|
||||
snprintf(buf, sizeof(buf), "%d", *port);
|
||||
return BIO_set_conn_port(bio, buf);
|
||||
}
|
||||
|
||||
@@ -544,4 +544,4 @@ int BIO_do_connect(BIO *bio) {
|
||||
return (int)BIO_ctrl(bio, BIO_C_DO_STATE_MACHINE, 0, NULL);
|
||||
}
|
||||
|
||||
#endif // OPENSSL_TRUSTY
|
||||
#endif // OPENSSL_NO_SOCK
|
||||
@@ -0,0 +1,92 @@
|
||||
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
||||
* All rights reserved.
|
||||
*
|
||||
* This package is an SSL implementation written
|
||||
* by Eric Young (eay@cryptsoft.com).
|
||||
* The implementation was written so as to conform with Netscapes SSL.
|
||||
*
|
||||
* This library is free for commercial and non-commercial use as long as
|
||||
* the following conditions are aheared to. The following conditions
|
||||
* apply to all code found in this distribution, be it the RC4, RSA,
|
||||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
|
||||
* included with this distribution is covered by the same copyright terms
|
||||
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
|
||||
*
|
||||
* Copyright remains Eric Young's, and as such any Copyright notices in
|
||||
* the code are not to be removed.
|
||||
* If this package is used in a product, Eric Young should be given attribution
|
||||
* as the author of the parts of the library used.
|
||||
* This can be in the form of a textual message at program startup or
|
||||
* in documentation (online or textual) provided with the package.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. All advertising materials mentioning features or use of this software
|
||||
* must display the following acknowledgement:
|
||||
* "This product includes cryptographic software written by
|
||||
* Eric Young (eay@cryptsoft.com)"
|
||||
* The word 'cryptographic' can be left out if the rouines from the library
|
||||
* being used are not cryptographic related :-).
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* the apps directory (application code) you must include an acknowledgement:
|
||||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
* The licence and distribution terms for any publically available version or
|
||||
* derivative of this code cannot be changed. i.e. this code cannot simply be
|
||||
* copied and put under another distribution licence
|
||||
* [including the GNU Public Licence.] */
|
||||
|
||||
#include <CCryptoBoringSSL_bio.h>
|
||||
|
||||
#include <errno.h>
|
||||
|
||||
#include "internal.h"
|
||||
|
||||
|
||||
int bio_errno_should_retry(int return_value) {
|
||||
if (return_value != -1) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return
|
||||
#ifdef EWOULDBLOCK
|
||||
errno == EWOULDBLOCK ||
|
||||
#endif
|
||||
#ifdef ENOTCONN
|
||||
errno == ENOTCONN ||
|
||||
#endif
|
||||
#ifdef EINTR
|
||||
errno == EINTR ||
|
||||
#endif
|
||||
#ifdef EAGAIN
|
||||
errno == EAGAIN ||
|
||||
#endif
|
||||
#ifdef EPROTO
|
||||
errno == EPROTO ||
|
||||
#endif
|
||||
#ifdef EINPROGRESS
|
||||
errno == EINPROGRESS ||
|
||||
#endif
|
||||
#ifdef EALREADY
|
||||
errno == EALREADY ||
|
||||
#endif
|
||||
0;
|
||||
}
|
||||
@@ -56,7 +56,7 @@
|
||||
|
||||
#include <CCryptoBoringSSL_bio.h>
|
||||
|
||||
#if !defined(OPENSSL_TRUSTY)
|
||||
#if !defined(OPENSSL_NO_POSIX_IO)
|
||||
|
||||
#include <errno.h>
|
||||
#include <string.h>
|
||||
@@ -65,9 +65,6 @@
|
||||
#include <unistd.h>
|
||||
#else
|
||||
#include <io.h>
|
||||
OPENSSL_MSVC_PRAGMA(warning(push, 3))
|
||||
#include <windows.h>
|
||||
OPENSSL_MSVC_PRAGMA(warning(pop))
|
||||
#endif
|
||||
|
||||
#include <CCryptoBoringSSL_err.h>
|
||||
@@ -77,59 +74,18 @@ OPENSSL_MSVC_PRAGMA(warning(pop))
|
||||
#include "../internal.h"
|
||||
|
||||
|
||||
static int bio_fd_non_fatal_error(int err) {
|
||||
if (
|
||||
#ifdef EWOULDBLOCK
|
||||
err == EWOULDBLOCK ||
|
||||
#endif
|
||||
#ifdef WSAEWOULDBLOCK
|
||||
err == WSAEWOULDBLOCK ||
|
||||
#endif
|
||||
#ifdef ENOTCONN
|
||||
err == ENOTCONN ||
|
||||
#endif
|
||||
#ifdef EINTR
|
||||
err == EINTR ||
|
||||
#endif
|
||||
#ifdef EAGAIN
|
||||
err == EAGAIN ||
|
||||
#endif
|
||||
#ifdef EPROTO
|
||||
err == EPROTO ||
|
||||
#endif
|
||||
#ifdef EINPROGRESS
|
||||
err == EINPROGRESS ||
|
||||
#endif
|
||||
#ifdef EALREADY
|
||||
err == EALREADY ||
|
||||
#endif
|
||||
0) {
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
#if defined(OPENSSL_WINDOWS)
|
||||
#define BORINGSSL_ERRNO (int)GetLastError()
|
||||
#define BORINGSSL_CLOSE _close
|
||||
#define BORINGSSL_LSEEK _lseek
|
||||
#define BORINGSSL_READ _read
|
||||
#define BORINGSSL_WRITE _write
|
||||
#else
|
||||
#define BORINGSSL_ERRNO errno
|
||||
#define BORINGSSL_CLOSE close
|
||||
#define BORINGSSL_LSEEK lseek
|
||||
#define BORINGSSL_READ read
|
||||
#define BORINGSSL_WRITE write
|
||||
#endif
|
||||
|
||||
int bio_fd_should_retry(int i) {
|
||||
if (i == -1) {
|
||||
return bio_fd_non_fatal_error(BORINGSSL_ERRNO);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
BIO *BIO_new_fd(int fd, int close_flag) {
|
||||
BIO *ret = BIO_new(BIO_s_fd());
|
||||
if (ret == NULL) {
|
||||
@@ -161,7 +117,7 @@ static int fd_read(BIO *b, char *out, int outl) {
|
||||
ret = (int)BORINGSSL_READ(b->num, out, outl);
|
||||
BIO_clear_retry_flags(b);
|
||||
if (ret <= 0) {
|
||||
if (bio_fd_should_retry(ret)) {
|
||||
if (bio_errno_should_retry(ret)) {
|
||||
BIO_set_retry_read(b);
|
||||
}
|
||||
}
|
||||
@@ -173,7 +129,7 @@ static int fd_write(BIO *b, const char *in, int inl) {
|
||||
int ret = (int)BORINGSSL_WRITE(b->num, in, inl);
|
||||
BIO_clear_retry_flags(b);
|
||||
if (ret <= 0) {
|
||||
if (bio_fd_should_retry(ret)) {
|
||||
if (bio_errno_should_retry(ret)) {
|
||||
BIO_set_retry_write(b);
|
||||
}
|
||||
}
|
||||
@@ -268,6 +224,8 @@ static const BIO_METHOD methods_fdp = {
|
||||
|
||||
const BIO_METHOD *BIO_s_fd(void) { return &methods_fdp; }
|
||||
|
||||
#endif // OPENSSL_NO_POSIX_IO
|
||||
|
||||
int BIO_set_fd(BIO *bio, int fd, int close_flag) {
|
||||
return (int)BIO_int_ctrl(bio, BIO_C_SET_FD, close_flag, fd);
|
||||
}
|
||||
@@ -275,5 +233,3 @@ int BIO_set_fd(BIO *bio, int fd, int close_flag) {
|
||||
int BIO_get_fd(BIO *bio, int *out_fd) {
|
||||
return (int)BIO_ctrl(bio, BIO_C_GET_FD, 0, (char *) out_fd);
|
||||
}
|
||||
|
||||
#endif // OPENSSL_TRUSTY
|
||||
@@ -73,8 +73,6 @@
|
||||
|
||||
#include <CCryptoBoringSSL_bio.h>
|
||||
|
||||
#if !defined(OPENSSL_TRUSTY)
|
||||
|
||||
#include <errno.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
@@ -89,11 +87,20 @@
|
||||
#define BIO_FP_WRITE 0x04
|
||||
#define BIO_FP_APPEND 0x08
|
||||
|
||||
#if !defined(OPENSSL_NO_FILESYSTEM)
|
||||
#define fopen_if_available fopen
|
||||
#else
|
||||
static FILE *fopen_if_available(const char *path, const char *mode) {
|
||||
errno = ENOENT;
|
||||
return NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
BIO *BIO_new_file(const char *filename, const char *mode) {
|
||||
BIO *ret;
|
||||
FILE *file;
|
||||
|
||||
file = fopen(filename, mode);
|
||||
file = fopen_if_available(filename, mode);
|
||||
if (file == NULL) {
|
||||
OPENSSL_PUT_SYSTEM_ERROR();
|
||||
|
||||
@@ -172,7 +179,6 @@ static long file_ctrl(BIO *b, int cmd, long num, void *ptr) {
|
||||
long ret = 1;
|
||||
FILE *fp = (FILE *)b->ptr;
|
||||
FILE **fpp;
|
||||
char p[4];
|
||||
|
||||
switch (cmd) {
|
||||
case BIO_CTRL_RESET:
|
||||
@@ -197,27 +203,28 @@ static long file_ctrl(BIO *b, int cmd, long num, void *ptr) {
|
||||
case BIO_C_SET_FILENAME:
|
||||
file_free(b);
|
||||
b->shutdown = (int)num & BIO_CLOSE;
|
||||
const char *mode;
|
||||
if (num & BIO_FP_APPEND) {
|
||||
if (num & BIO_FP_READ) {
|
||||
OPENSSL_strlcpy(p, "a+", sizeof(p));
|
||||
mode = "a+";
|
||||
} else {
|
||||
OPENSSL_strlcpy(p, "a", sizeof(p));
|
||||
mode = "a";
|
||||
}
|
||||
} else if ((num & BIO_FP_READ) && (num & BIO_FP_WRITE)) {
|
||||
OPENSSL_strlcpy(p, "r+", sizeof(p));
|
||||
mode = "r+";
|
||||
} else if (num & BIO_FP_WRITE) {
|
||||
OPENSSL_strlcpy(p, "w", sizeof(p));
|
||||
mode = "w";
|
||||
} else if (num & BIO_FP_READ) {
|
||||
OPENSSL_strlcpy(p, "r", sizeof(p));
|
||||
mode = "r";
|
||||
} else {
|
||||
OPENSSL_PUT_ERROR(BIO, BIO_R_BAD_FOPEN_MODE);
|
||||
ret = 0;
|
||||
break;
|
||||
}
|
||||
fp = fopen(ptr, p);
|
||||
fp = fopen_if_available(ptr, mode);
|
||||
if (fp == NULL) {
|
||||
OPENSSL_PUT_SYSTEM_ERROR();
|
||||
ERR_add_error_data(5, "fopen('", ptr, "','", p, "')");
|
||||
ERR_add_error_data(5, "fopen('", ptr, "','", mode, "')");
|
||||
OPENSSL_PUT_ERROR(BIO, ERR_R_SYS_LIB);
|
||||
ret = 0;
|
||||
break;
|
||||
@@ -310,5 +317,3 @@ long BIO_tell(BIO *bio) { return BIO_ctrl(bio, BIO_C_FILE_TELL, 0, NULL); }
|
||||
long BIO_seek(BIO *bio, long offset) {
|
||||
return BIO_ctrl(bio, BIO_C_FILE_SEEK, offset, NULL);
|
||||
}
|
||||
|
||||
#endif // OPENSSL_TRUSTY
|
||||
@@ -59,6 +59,7 @@
|
||||
|
||||
#include <CCryptoBoringSSL_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_SOCK)
|
||||
#if !defined(OPENSSL_WINDOWS)
|
||||
#if defined(OPENSSL_PNACL)
|
||||
// newlib uses u_short in socket.h without defining it.
|
||||
@@ -72,13 +73,16 @@ OPENSSL_MSVC_PRAGMA(warning(push, 3))
|
||||
OPENSSL_MSVC_PRAGMA(warning(pop))
|
||||
typedef int socklen_t;
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_SOCK
|
||||
|
||||
#if defined(__cplusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
// BIO_ip_and_port_to_socket_and_addr creates a socket and fills in |*out_addr|
|
||||
#if !defined(OPENSSL_NO_SOCK)
|
||||
|
||||
// bio_ip_and_port_to_socket_and_addr creates a socket and fills in |*out_addr|
|
||||
// and |*out_addr_length| with the correct values for connecting to |hostname|
|
||||
// on |port_str|. It returns one on success or zero on error.
|
||||
int bio_ip_and_port_to_socket_and_addr(int *out_sock,
|
||||
@@ -87,21 +91,27 @@ int bio_ip_and_port_to_socket_and_addr(int *out_sock,
|
||||
const char *hostname,
|
||||
const char *port_str);
|
||||
|
||||
// BIO_socket_nbio sets whether |sock| is non-blocking. It returns one on
|
||||
// bio_socket_nbio sets whether |sock| is non-blocking. It returns one on
|
||||
// success and zero otherwise.
|
||||
int bio_socket_nbio(int sock, int on);
|
||||
|
||||
// BIO_clear_socket_error clears the last system socket error.
|
||||
// bio_clear_socket_error clears the last system socket error.
|
||||
//
|
||||
// TODO(fork): remove all callers of this.
|
||||
void bio_clear_socket_error(void);
|
||||
|
||||
// BIO_sock_error returns the last socket error on |sock|.
|
||||
// bio_sock_error returns the last socket error on |sock|.
|
||||
int bio_sock_error(int sock);
|
||||
|
||||
// BIO_fd_should_retry returns non-zero if |return_value| indicates an error
|
||||
// bio_socket_should_retry returns non-zero if |return_value| indicates an error
|
||||
// and the last socket error indicates that it's non-fatal.
|
||||
int bio_socket_should_retry(int return_value);
|
||||
|
||||
#endif // !OPENSSL_NO_SOCK
|
||||
|
||||
// bio_errno_should_retry returns non-zero if |return_value| indicates an error
|
||||
// and |errno| indicates that it's non-fatal.
|
||||
int bio_fd_should_retry(int return_value);
|
||||
int bio_errno_should_retry(int return_value);
|
||||
|
||||
|
||||
#if defined(__cplusplus)
|
||||
|
||||
@@ -56,7 +56,7 @@
|
||||
|
||||
#include <CCryptoBoringSSL_bio.h>
|
||||
|
||||
#if !defined(OPENSSL_TRUSTY)
|
||||
#if !defined(OPENSSL_NO_SOCK)
|
||||
|
||||
#include <fcntl.h>
|
||||
#include <string.h>
|
||||
@@ -104,7 +104,7 @@ static int sock_read(BIO *b, char *out, int outl) {
|
||||
#endif
|
||||
BIO_clear_retry_flags(b);
|
||||
if (ret <= 0) {
|
||||
if (bio_fd_should_retry(ret)) {
|
||||
if (bio_socket_should_retry(ret)) {
|
||||
BIO_set_retry_read(b);
|
||||
}
|
||||
}
|
||||
@@ -120,7 +120,7 @@ static int sock_write(BIO *b, const char *in, int inl) {
|
||||
#endif
|
||||
BIO_clear_retry_flags(b);
|
||||
if (ret <= 0) {
|
||||
if (bio_fd_should_retry(ret)) {
|
||||
if (bio_socket_should_retry(ret)) {
|
||||
BIO_set_retry_write(b);
|
||||
}
|
||||
}
|
||||
@@ -186,4 +186,4 @@ BIO *BIO_new_socket(int fd, int close_flag) {
|
||||
return ret;
|
||||
}
|
||||
|
||||
#endif // OPENSSL_TRUSTY
|
||||
#endif // OPENSSL_NO_SOCK
|
||||
@@ -20,7 +20,7 @@
|
||||
#include <CCryptoBoringSSL_bio.h>
|
||||
#include <CCryptoBoringSSL_err.h>
|
||||
|
||||
#if !defined(OPENSSL_TRUSTY)
|
||||
#if !defined(OPENSSL_NO_SOCK)
|
||||
|
||||
#include <fcntl.h>
|
||||
#include <string.h>
|
||||
@@ -121,4 +121,13 @@ int bio_sock_error(int sock) {
|
||||
return error;
|
||||
}
|
||||
|
||||
#endif // OPENSSL_TRUSTY
|
||||
int bio_socket_should_retry(int return_value) {
|
||||
#if defined(OPENSSL_WINDOWS)
|
||||
return return_value == -1 && WSAGetLastError() == WSAEWOULDBLOCK;
|
||||
#else
|
||||
// On POSIX platforms, sockets and fds are the same.
|
||||
return bio_errno_should_retry(return_value);
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif // OPENSSL_NO_SOCK
|
||||
@@ -55,10 +55,13 @@ static void blake2b_mix(uint64_t v[16], int a, int b, int c, int d, uint64_t x,
|
||||
v[b] = CRYPTO_rotr_u64(v[b] ^ v[c], 63);
|
||||
}
|
||||
|
||||
static void blake2b_transform(
|
||||
BLAKE2B_CTX *b2b,
|
||||
const uint64_t block_words[BLAKE2B_CBLOCK / sizeof(uint64_t)],
|
||||
size_t num_bytes, int is_final_block) {
|
||||
static uint64_t blake2b_load(const uint8_t block[BLAKE2B_CBLOCK], size_t i) {
|
||||
return CRYPTO_load_u64_le(block + 8 * i);
|
||||
}
|
||||
|
||||
static void blake2b_transform(BLAKE2B_CTX *b2b,
|
||||
const uint8_t block[BLAKE2B_CBLOCK],
|
||||
size_t num_bytes, int is_final_block) {
|
||||
// https://tools.ietf.org/html/rfc7693#section-3.2
|
||||
uint64_t v[16];
|
||||
static_assert(sizeof(v) == sizeof(b2b->h) + sizeof(kIV), "");
|
||||
@@ -78,14 +81,22 @@ static void blake2b_transform(
|
||||
|
||||
for (int round = 0; round < 12; round++) {
|
||||
const uint8_t *const s = &kSigma[16 * (round % 10)];
|
||||
blake2b_mix(v, 0, 4, 8, 12, block_words[s[0]], block_words[s[1]]);
|
||||
blake2b_mix(v, 1, 5, 9, 13, block_words[s[2]], block_words[s[3]]);
|
||||
blake2b_mix(v, 2, 6, 10, 14, block_words[s[4]], block_words[s[5]]);
|
||||
blake2b_mix(v, 3, 7, 11, 15, block_words[s[6]], block_words[s[7]]);
|
||||
blake2b_mix(v, 0, 5, 10, 15, block_words[s[8]], block_words[s[9]]);
|
||||
blake2b_mix(v, 1, 6, 11, 12, block_words[s[10]], block_words[s[11]]);
|
||||
blake2b_mix(v, 2, 7, 8, 13, block_words[s[12]], block_words[s[13]]);
|
||||
blake2b_mix(v, 3, 4, 9, 14, block_words[s[14]], block_words[s[15]]);
|
||||
blake2b_mix(v, 0, 4, 8, 12, blake2b_load(block, s[0]),
|
||||
blake2b_load(block, s[1]));
|
||||
blake2b_mix(v, 1, 5, 9, 13, blake2b_load(block, s[2]),
|
||||
blake2b_load(block, s[3]));
|
||||
blake2b_mix(v, 2, 6, 10, 14, blake2b_load(block, s[4]),
|
||||
blake2b_load(block, s[5]));
|
||||
blake2b_mix(v, 3, 7, 11, 15, blake2b_load(block, s[6]),
|
||||
blake2b_load(block, s[7]));
|
||||
blake2b_mix(v, 0, 5, 10, 15, blake2b_load(block, s[8]),
|
||||
blake2b_load(block, s[9]));
|
||||
blake2b_mix(v, 1, 6, 11, 12, blake2b_load(block, s[10]),
|
||||
blake2b_load(block, s[11]));
|
||||
blake2b_mix(v, 2, 7, 8, 13, blake2b_load(block, s[12]),
|
||||
blake2b_load(block, s[13]));
|
||||
blake2b_mix(v, 3, 4, 9, 14, blake2b_load(block, s[14]),
|
||||
blake2b_load(block, s[15]));
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < OPENSSL_ARRAY_SIZE(b2b->h); i++) {
|
||||
@@ -111,11 +122,11 @@ void BLAKE2B256_Update(BLAKE2B_CTX *b2b, const void *in_data, size_t len) {
|
||||
}
|
||||
|
||||
const uint8_t *data = in_data;
|
||||
size_t todo = sizeof(b2b->block.bytes) - b2b->block_used;
|
||||
size_t todo = sizeof(b2b->block) - b2b->block_used;
|
||||
if (todo > len) {
|
||||
todo = len;
|
||||
}
|
||||
OPENSSL_memcpy(&b2b->block.bytes[b2b->block_used], data, todo);
|
||||
OPENSSL_memcpy(&b2b->block[b2b->block_used], data, todo);
|
||||
b2b->block_used += todo;
|
||||
data += todo;
|
||||
len -= todo;
|
||||
@@ -126,26 +137,24 @@ void BLAKE2B256_Update(BLAKE2B_CTX *b2b, const void *in_data, size_t len) {
|
||||
|
||||
// More input remains therefore we must have filled |b2b->block|.
|
||||
assert(b2b->block_used == BLAKE2B_CBLOCK);
|
||||
blake2b_transform(b2b, b2b->block.words, BLAKE2B_CBLOCK,
|
||||
blake2b_transform(b2b, b2b->block, BLAKE2B_CBLOCK,
|
||||
/*is_final_block=*/0);
|
||||
b2b->block_used = 0;
|
||||
|
||||
while (len > BLAKE2B_CBLOCK) {
|
||||
uint64_t block_words[BLAKE2B_CBLOCK / sizeof(uint64_t)];
|
||||
OPENSSL_memcpy(block_words, data, sizeof(block_words));
|
||||
blake2b_transform(b2b, block_words, BLAKE2B_CBLOCK, /*is_final_block=*/0);
|
||||
blake2b_transform(b2b, data, BLAKE2B_CBLOCK, /*is_final_block=*/0);
|
||||
data += BLAKE2B_CBLOCK;
|
||||
len -= BLAKE2B_CBLOCK;
|
||||
}
|
||||
|
||||
OPENSSL_memcpy(b2b->block.bytes, data, len);
|
||||
OPENSSL_memcpy(b2b->block, data, len);
|
||||
b2b->block_used = len;
|
||||
}
|
||||
|
||||
void BLAKE2B256_Final(uint8_t out[BLAKE2B256_DIGEST_LENGTH], BLAKE2B_CTX *b2b) {
|
||||
OPENSSL_memset(&b2b->block.bytes[b2b->block_used], 0,
|
||||
sizeof(b2b->block.bytes) - b2b->block_used);
|
||||
blake2b_transform(b2b, b2b->block.words, b2b->block_used,
|
||||
OPENSSL_memset(&b2b->block[b2b->block_used], 0,
|
||||
sizeof(b2b->block) - b2b->block_used);
|
||||
blake2b_transform(b2b, b2b->block, b2b->block_used,
|
||||
/*is_final_block=*/1);
|
||||
static_assert(BLAKE2B256_DIGEST_LENGTH <= sizeof(b2b->h), "");
|
||||
memcpy(out, b2b->h, BLAKE2B256_DIGEST_LENGTH);
|
||||
|
||||
@@ -694,7 +694,7 @@ int CBS_is_unsigned_asn1_integer(const CBS *cbs) {
|
||||
|
||||
static int add_decimal(CBB *out, uint64_t v) {
|
||||
char buf[DECIMAL_SIZE(uint64_t) + 1];
|
||||
BIO_snprintf(buf, sizeof(buf), "%" PRIu64, v);
|
||||
snprintf(buf, sizeof(buf), "%" PRIu64, v);
|
||||
return CBB_add_bytes(out, (const uint8_t *)buf, strlen(buf));
|
||||
}
|
||||
|
||||
|
||||
@@ -3,17 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if !defined(__has_feature)
|
||||
#define __has_feature(x) 0
|
||||
#endif
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__ARMEL__) && defined(__APPLE__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_ARM) && defined(__APPLE__)
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
|
||||
@ Silence ARMv8 deprecated IT instruction warnings. This file is used by both
|
||||
@@ -1497,11 +1489,7 @@ OPENSSL_armcap_P:
|
||||
.indirect_symbol _OPENSSL_armcap_P
|
||||
.long 0
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(__ARMEL__) && defined(__APPLE__)
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(OPENSSL_ARM) && defined(__APPLE__)
|
||||
#endif // defined(__arm__) && defined(__APPLE__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,17 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if !defined(__has_feature)
|
||||
#define __has_feature(x) 0
|
||||
#endif
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__ARMEL__) && defined(__ELF__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_ARM) && defined(__ELF__)
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
|
||||
@ Silence ARMv8 deprecated IT instruction warnings. This file is used by both
|
||||
@@ -1489,11 +1481,7 @@ ChaCha20_neon:
|
||||
.size ChaCha20_neon,.-ChaCha20_neon
|
||||
.comm OPENSSL_armcap_P,4,4
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(__ARMEL__) && defined(__ELF__)
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(OPENSSL_ARM) && defined(__ELF__)
|
||||
#endif // defined(__arm__) && defined(__linux__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,17 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if !defined(__has_feature)
|
||||
#define __has_feature(x) 0
|
||||
#endif
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__AARCH64EL__) && defined(__APPLE__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_AARCH64) && defined(__APPLE__)
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
|
||||
|
||||
@@ -38,7 +30,7 @@ Lone:
|
||||
_ChaCha20_ctr32:
|
||||
AARCH64_VALID_CALL_TARGET
|
||||
cbz x2,Labort
|
||||
#if __has_feature(hwaddress_sanitizer) && __clang_major__ >= 10
|
||||
#if defined(OPENSSL_HWASAN) && __clang_major__ >= 10
|
||||
adrp x5,:pg_hi21_nc:_OPENSSL_armcap_P
|
||||
#else
|
||||
adrp x5,_OPENSSL_armcap_P@PAGE
|
||||
@@ -1991,11 +1983,7 @@ Ldone_512_neon:
|
||||
AARCH64_VALIDATE_LINK_REGISTER
|
||||
ret
|
||||
|
||||
#endif // !OPENSSL_NO_ASM && defined(__AARCH64EL__) && defined(__APPLE__)
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(OPENSSL_AARCH64) && defined(__APPLE__)
|
||||
#endif // defined(__aarch64__) && defined(__APPLE__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,17 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if !defined(__has_feature)
|
||||
#define __has_feature(x) 0
|
||||
#endif
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__AARCH64EL__) && defined(__ELF__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_AARCH64) && defined(__ELF__)
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
|
||||
|
||||
@@ -38,7 +30,7 @@
|
||||
ChaCha20_ctr32:
|
||||
AARCH64_VALID_CALL_TARGET
|
||||
cbz x2,.Labort
|
||||
#if __has_feature(hwaddress_sanitizer) && __clang_major__ >= 10
|
||||
#if defined(OPENSSL_HWASAN) && __clang_major__ >= 10
|
||||
adrp x5,:pg_hi21_nc:OPENSSL_armcap_P
|
||||
#else
|
||||
adrp x5,OPENSSL_armcap_P
|
||||
@@ -1991,11 +1983,7 @@ ChaCha20_512_neon:
|
||||
AARCH64_VALIDATE_LINK_REGISTER
|
||||
ret
|
||||
.size ChaCha20_512_neon,.-ChaCha20_512_neon
|
||||
#endif // !OPENSSL_NO_ASM && defined(__AARCH64EL__) && defined(__ELF__)
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(OPENSSL_AARCH64) && defined(__ELF__)
|
||||
#endif // defined(__aarch64__) && defined(__linux__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,16 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if defined(__has_feature)
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__i386__) && defined(__ELF__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86) && defined(__ELF__)
|
||||
.text
|
||||
.globl ChaCha20_ctr32
|
||||
.hidden ChaCha20_ctr32
|
||||
@@ -979,11 +972,7 @@ ChaCha20_ssse3:
|
||||
.byte 44,32,67,82,89,80,84,79,71,65,77,83,32,98,121,32
|
||||
.byte 60,97,112,112,114,111,64,111,112,101,110,115,115,108,46,111
|
||||
.byte 114,103,62,0
|
||||
#endif // !defined(OPENSSL_NO_ASM) && defined(__i386__) && defined(__ELF__)
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86) && defined(__ELF__)
|
||||
#endif // defined(__i386__) && defined(__linux__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,16 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if defined(__has_feature)
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if defined(__x86_64__) && !defined(OPENSSL_NO_ASM) && defined(__ELF__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86_64) && defined(__ELF__)
|
||||
.text
|
||||
|
||||
.extern OPENSSL_ia32cap_P
|
||||
@@ -55,6 +48,7 @@
|
||||
.align 64
|
||||
ChaCha20_ctr32:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
cmpq $0,%rdx
|
||||
je .Lno_data
|
||||
movq OPENSSL_ia32cap_P+4(%rip),%r10
|
||||
@@ -1634,10 +1628,6 @@ ChaCha20_8x:
|
||||
.cfi_endproc
|
||||
.size ChaCha20_8x,.-ChaCha20_8x
|
||||
#endif
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // defined(__x86_64__) && defined(__linux__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,16 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if defined(__has_feature)
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if defined(__x86_64__) && !defined(OPENSSL_NO_ASM) && defined(__APPLE__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86_64) && defined(__APPLE__)
|
||||
.text
|
||||
|
||||
|
||||
@@ -54,6 +47,7 @@ L$sixteen:
|
||||
.p2align 6
|
||||
_ChaCha20_ctr32:
|
||||
|
||||
_CET_ENDBR
|
||||
cmpq $0,%rdx
|
||||
je L$no_data
|
||||
movq _OPENSSL_ia32cap_P+4(%rip),%r10
|
||||
@@ -1626,10 +1620,6 @@ L$8x_epilogue:
|
||||
.byte 0xf3,0xc3
|
||||
|
||||
|
||||
#endif
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // defined(__x86_64__) && defined(__APPLE__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
|
||||
@@ -91,7 +91,25 @@ void CRYPTO_chacha_20(uint8_t *out, const uint8_t *in, size_t in_len,
|
||||
}
|
||||
#endif
|
||||
|
||||
ChaCha20_ctr32(out, in, in_len, key_ptr, counter_nonce);
|
||||
while (in_len > 0) {
|
||||
// The assembly functions do not have defined overflow behavior. While
|
||||
// overflow is almost always a bug in the caller, we prefer our functions to
|
||||
// behave the same across platforms, so divide into multiple calls to avoid
|
||||
// this case.
|
||||
uint64_t todo = 64 * ((UINT64_C(1) << 32) - counter_nonce[0]);
|
||||
if (todo > in_len) {
|
||||
todo = in_len;
|
||||
}
|
||||
|
||||
ChaCha20_ctr32(out, in, (size_t)todo, key_ptr, counter_nonce);
|
||||
in += todo;
|
||||
out += todo;
|
||||
in_len -= todo;
|
||||
|
||||
// We're either done and will next break out of the loop, or we stopped at
|
||||
// the wraparound point and the counter should continue at zero.
|
||||
counter_nonce[0] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
@@ -32,7 +32,14 @@ void CRYPTO_hchacha20(uint8_t out[32], const uint8_t key[32],
|
||||
defined(OPENSSL_ARM) || defined(OPENSSL_AARCH64))
|
||||
#define CHACHA20_ASM
|
||||
|
||||
// ChaCha20_ctr32 is defined in asm/chacha-*.pl.
|
||||
// ChaCha20_ctr32 encrypts |in_len| bytes from |in| and writes the result to
|
||||
// |out|. If |in| and |out| alias, they must be equal.
|
||||
//
|
||||
// |counter[0]| is the initial 32-bit block counter, and the remainder is the
|
||||
// 96-bit nonce. If the counter overflows, the output is undefined. The function
|
||||
// will produce output, but the output may vary by machine and may not be
|
||||
// self-consistent. (On some architectures, the assembly implements a mix of
|
||||
// 64-bit and 32-bit counters.)
|
||||
void ChaCha20_ctr32(uint8_t *out, const uint8_t *in, size_t in_len,
|
||||
const uint32_t key[8], const uint32_t counter[4]);
|
||||
#endif
|
||||
|
||||
+20
-13
@@ -3,16 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if defined(__has_feature)
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if defined(__x86_64__) && !defined(OPENSSL_NO_ASM) && defined(__ELF__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86_64) && defined(__ELF__)
|
||||
.section .rodata
|
||||
|
||||
.align 16
|
||||
@@ -80,6 +73,7 @@ GFMUL:
|
||||
.align 16
|
||||
aesgcmsiv_htable_init:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
vmovdqa (%rsi),%xmm0
|
||||
vmovdqa %xmm0,%xmm1
|
||||
vmovdqa %xmm0,(%rdi)
|
||||
@@ -106,6 +100,7 @@ aesgcmsiv_htable_init:
|
||||
.align 16
|
||||
aesgcmsiv_htable6_init:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
vmovdqa (%rsi),%xmm0
|
||||
vmovdqa %xmm0,%xmm1
|
||||
vmovdqa %xmm0,(%rdi)
|
||||
@@ -128,6 +123,7 @@ aesgcmsiv_htable6_init:
|
||||
.align 16
|
||||
aesgcmsiv_htable_polyval:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
testq %rdx,%rdx
|
||||
jnz .Lhtable_polyval_start
|
||||
.byte 0xf3,0xc3
|
||||
@@ -345,6 +341,7 @@ aesgcmsiv_htable_polyval:
|
||||
.align 16
|
||||
aesgcmsiv_polyval_horner:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
testq %rcx,%rcx
|
||||
jnz .Lpolyval_horner_start
|
||||
.byte 0xf3,0xc3
|
||||
@@ -378,6 +375,7 @@ aesgcmsiv_polyval_horner:
|
||||
.align 16
|
||||
aes128gcmsiv_aes_ks:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
vmovdqu (%rdi),%xmm1
|
||||
vmovdqa %xmm1,(%rsi)
|
||||
|
||||
@@ -434,6 +432,7 @@ aes128gcmsiv_aes_ks:
|
||||
.align 16
|
||||
aes256gcmsiv_aes_ks:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
vmovdqu (%rdi),%xmm1
|
||||
vmovdqu 16(%rdi),%xmm3
|
||||
vmovdqa %xmm1,(%rsi)
|
||||
@@ -481,6 +480,7 @@ aes256gcmsiv_aes_ks:
|
||||
.align 16
|
||||
aes128gcmsiv_aes_ks_enc_x1:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
vmovdqa (%rcx),%xmm1
|
||||
vmovdqa 0(%rdi),%xmm4
|
||||
|
||||
@@ -623,6 +623,7 @@ aes128gcmsiv_aes_ks_enc_x1:
|
||||
.align 16
|
||||
aes128gcmsiv_kdf:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
|
||||
|
||||
|
||||
@@ -716,6 +717,7 @@ aes128gcmsiv_kdf:
|
||||
.align 16
|
||||
aes128gcmsiv_enc_msg_x4:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
testq %r8,%r8
|
||||
jnz .L128_enc_msg_x4_start
|
||||
.byte 0xf3,0xc3
|
||||
@@ -895,6 +897,7 @@ aes128gcmsiv_enc_msg_x4:
|
||||
.align 16
|
||||
aes128gcmsiv_enc_msg_x8:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
testq %r8,%r8
|
||||
jnz .L128_enc_msg_x8_start
|
||||
.byte 0xf3,0xc3
|
||||
@@ -1156,6 +1159,7 @@ aes128gcmsiv_enc_msg_x8:
|
||||
.align 16
|
||||
aes128gcmsiv_dec:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
testq $~15,%r9
|
||||
jnz .L128_dec_start
|
||||
.byte 0xf3,0xc3
|
||||
@@ -1648,6 +1652,7 @@ aes128gcmsiv_dec:
|
||||
.align 16
|
||||
aes128gcmsiv_ecb_enc_block:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
vmovdqa (%rdi),%xmm1
|
||||
|
||||
vpxor (%rdx),%xmm1,%xmm1
|
||||
@@ -1673,6 +1678,7 @@ aes128gcmsiv_ecb_enc_block:
|
||||
.align 16
|
||||
aes256gcmsiv_aes_ks_enc_x1:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
vmovdqa con1(%rip),%xmm0
|
||||
vmovdqa mask(%rip),%xmm15
|
||||
vmovdqa (%rdi),%xmm8
|
||||
@@ -1856,6 +1862,7 @@ aes256gcmsiv_aes_ks_enc_x1:
|
||||
.align 16
|
||||
aes256gcmsiv_ecb_enc_block:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
vmovdqa (%rdi),%xmm1
|
||||
vpxor (%rdx),%xmm1,%xmm1
|
||||
vaesenc 16(%rdx),%xmm1,%xmm1
|
||||
@@ -1882,6 +1889,7 @@ aes256gcmsiv_ecb_enc_block:
|
||||
.align 16
|
||||
aes256gcmsiv_enc_msg_x4:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
testq %r8,%r8
|
||||
jnz .L256_enc_msg_x4_start
|
||||
.byte 0xf3,0xc3
|
||||
@@ -2083,6 +2091,7 @@ aes256gcmsiv_enc_msg_x4:
|
||||
.align 16
|
||||
aes256gcmsiv_enc_msg_x8:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
testq %r8,%r8
|
||||
jnz .L256_enc_msg_x8_start
|
||||
.byte 0xf3,0xc3
|
||||
@@ -2372,6 +2381,7 @@ aes256gcmsiv_enc_msg_x8:
|
||||
.align 16
|
||||
aes256gcmsiv_dec:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
testq $~15,%r9
|
||||
jnz .L256_dec_start
|
||||
.byte 0xf3,0xc3
|
||||
@@ -2932,6 +2942,7 @@ aes256gcmsiv_dec:
|
||||
.align 16
|
||||
aes256gcmsiv_kdf:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
|
||||
|
||||
|
||||
@@ -3078,10 +3089,6 @@ aes256gcmsiv_kdf:
|
||||
.cfi_endproc
|
||||
.size aes256gcmsiv_kdf, .-aes256gcmsiv_kdf
|
||||
#endif
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // defined(__x86_64__) && defined(__linux__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,16 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if defined(__has_feature)
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if defined(__x86_64__) && !defined(OPENSSL_NO_ASM) && defined(__APPLE__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86_64) && defined(__APPLE__)
|
||||
.section __DATA,__const
|
||||
|
||||
.p2align 4
|
||||
@@ -80,6 +73,7 @@ GFMUL:
|
||||
.p2align 4
|
||||
_aesgcmsiv_htable_init:
|
||||
|
||||
_CET_ENDBR
|
||||
vmovdqa (%rsi),%xmm0
|
||||
vmovdqa %xmm0,%xmm1
|
||||
vmovdqa %xmm0,(%rdi)
|
||||
@@ -106,6 +100,7 @@ _aesgcmsiv_htable_init:
|
||||
.p2align 4
|
||||
_aesgcmsiv_htable6_init:
|
||||
|
||||
_CET_ENDBR
|
||||
vmovdqa (%rsi),%xmm0
|
||||
vmovdqa %xmm0,%xmm1
|
||||
vmovdqa %xmm0,(%rdi)
|
||||
@@ -128,6 +123,7 @@ _aesgcmsiv_htable6_init:
|
||||
.p2align 4
|
||||
_aesgcmsiv_htable_polyval:
|
||||
|
||||
_CET_ENDBR
|
||||
testq %rdx,%rdx
|
||||
jnz L$htable_polyval_start
|
||||
.byte 0xf3,0xc3
|
||||
@@ -345,6 +341,7 @@ L$htable_polyval_out:
|
||||
.p2align 4
|
||||
_aesgcmsiv_polyval_horner:
|
||||
|
||||
_CET_ENDBR
|
||||
testq %rcx,%rcx
|
||||
jnz L$polyval_horner_start
|
||||
.byte 0xf3,0xc3
|
||||
@@ -378,6 +375,7 @@ L$polyval_horner_loop:
|
||||
.p2align 4
|
||||
_aes128gcmsiv_aes_ks:
|
||||
|
||||
_CET_ENDBR
|
||||
vmovdqu (%rdi),%xmm1
|
||||
vmovdqa %xmm1,(%rsi)
|
||||
|
||||
@@ -434,6 +432,7 @@ L$ks128_loop:
|
||||
.p2align 4
|
||||
_aes256gcmsiv_aes_ks:
|
||||
|
||||
_CET_ENDBR
|
||||
vmovdqu (%rdi),%xmm1
|
||||
vmovdqu 16(%rdi),%xmm3
|
||||
vmovdqa %xmm1,(%rsi)
|
||||
@@ -481,6 +480,7 @@ L$ks256_loop:
|
||||
.p2align 4
|
||||
_aes128gcmsiv_aes_ks_enc_x1:
|
||||
|
||||
_CET_ENDBR
|
||||
vmovdqa (%rcx),%xmm1
|
||||
vmovdqa 0(%rdi),%xmm4
|
||||
|
||||
@@ -623,6 +623,7 @@ _aes128gcmsiv_aes_ks_enc_x1:
|
||||
.p2align 4
|
||||
_aes128gcmsiv_kdf:
|
||||
|
||||
_CET_ENDBR
|
||||
|
||||
|
||||
|
||||
@@ -716,6 +717,7 @@ _aes128gcmsiv_kdf:
|
||||
.p2align 4
|
||||
_aes128gcmsiv_enc_msg_x4:
|
||||
|
||||
_CET_ENDBR
|
||||
testq %r8,%r8
|
||||
jnz L$128_enc_msg_x4_start
|
||||
.byte 0xf3,0xc3
|
||||
@@ -891,6 +893,7 @@ L$128_enc_msg_x4_out:
|
||||
.p2align 4
|
||||
_aes128gcmsiv_enc_msg_x8:
|
||||
|
||||
_CET_ENDBR
|
||||
testq %r8,%r8
|
||||
jnz L$128_enc_msg_x8_start
|
||||
.byte 0xf3,0xc3
|
||||
@@ -1146,6 +1149,7 @@ L$128_enc_msg_x8_out:
|
||||
.p2align 4
|
||||
_aes128gcmsiv_dec:
|
||||
|
||||
_CET_ENDBR
|
||||
testq $~15,%r9
|
||||
jnz L$128_dec_start
|
||||
.byte 0xf3,0xc3
|
||||
@@ -1638,6 +1642,7 @@ L$128_dec_out:
|
||||
.p2align 4
|
||||
_aes128gcmsiv_ecb_enc_block:
|
||||
|
||||
_CET_ENDBR
|
||||
vmovdqa (%rdi),%xmm1
|
||||
|
||||
vpxor (%rdx),%xmm1,%xmm1
|
||||
@@ -1663,6 +1668,7 @@ _aes128gcmsiv_ecb_enc_block:
|
||||
.p2align 4
|
||||
_aes256gcmsiv_aes_ks_enc_x1:
|
||||
|
||||
_CET_ENDBR
|
||||
vmovdqa con1(%rip),%xmm0
|
||||
vmovdqa mask(%rip),%xmm15
|
||||
vmovdqa (%rdi),%xmm8
|
||||
@@ -1846,6 +1852,7 @@ _aes256gcmsiv_aes_ks_enc_x1:
|
||||
.p2align 4
|
||||
_aes256gcmsiv_ecb_enc_block:
|
||||
|
||||
_CET_ENDBR
|
||||
vmovdqa (%rdi),%xmm1
|
||||
vpxor (%rdx),%xmm1,%xmm1
|
||||
vaesenc 16(%rdx),%xmm1,%xmm1
|
||||
@@ -1872,6 +1879,7 @@ _aes256gcmsiv_ecb_enc_block:
|
||||
.p2align 4
|
||||
_aes256gcmsiv_enc_msg_x4:
|
||||
|
||||
_CET_ENDBR
|
||||
testq %r8,%r8
|
||||
jnz L$256_enc_msg_x4_start
|
||||
.byte 0xf3,0xc3
|
||||
@@ -2073,6 +2081,7 @@ L$256_enc_msg_x4_out:
|
||||
.p2align 4
|
||||
_aes256gcmsiv_enc_msg_x8:
|
||||
|
||||
_CET_ENDBR
|
||||
testq %r8,%r8
|
||||
jnz L$256_enc_msg_x8_start
|
||||
.byte 0xf3,0xc3
|
||||
@@ -2362,6 +2371,7 @@ L$256_enc_msg_x8_out:
|
||||
.p2align 4
|
||||
_aes256gcmsiv_dec:
|
||||
|
||||
_CET_ENDBR
|
||||
testq $~15,%r9
|
||||
jnz L$256_dec_start
|
||||
.byte 0xf3,0xc3
|
||||
@@ -2922,6 +2932,7 @@ L$256_dec_out:
|
||||
.p2align 4
|
||||
_aes256gcmsiv_kdf:
|
||||
|
||||
_CET_ENDBR
|
||||
|
||||
|
||||
|
||||
@@ -3067,10 +3078,6 @@ _aes256gcmsiv_kdf:
|
||||
.byte 0xf3,0xc3
|
||||
|
||||
|
||||
#endif
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // defined(__x86_64__) && defined(__APPLE__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
|
||||
+3
-15
@@ -3,17 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if !defined(__has_feature)
|
||||
#define __has_feature(x) 0
|
||||
#endif
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__AARCH64EL__) && defined(__APPLE__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_AARCH64) && defined(__APPLE__)
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
.section __TEXT,__const
|
||||
|
||||
@@ -3016,11 +3008,7 @@ Lopen_128_hash_64:
|
||||
b Lopen_128_hash_64
|
||||
.cfi_endproc
|
||||
|
||||
#endif // !OPENSSL_NO_ASM && defined(__AARCH64EL__) && defined(__APPLE__)
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(OPENSSL_AARCH64) && defined(__APPLE__)
|
||||
#endif // defined(__aarch64__) && defined(__APPLE__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
+3
-15
@@ -3,17 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if !defined(__has_feature)
|
||||
#define __has_feature(x) 0
|
||||
#endif
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__AARCH64EL__) && defined(__ELF__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_AARCH64) && defined(__ELF__)
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
.section .rodata
|
||||
|
||||
@@ -3016,11 +3008,7 @@ chacha20_poly1305_open:
|
||||
b .Lopen_128_hash_64
|
||||
.cfi_endproc
|
||||
.size chacha20_poly1305_open,.-chacha20_poly1305_open
|
||||
#endif // !OPENSSL_NO_ASM && defined(__AARCH64EL__) && defined(__ELF__)
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(OPENSSL_AARCH64) && defined(__ELF__)
|
||||
#endif // defined(__aarch64__) && defined(__linux__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
+4
-13
@@ -3,16 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if defined(__has_feature)
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if defined(__x86_64__) && !defined(OPENSSL_NO_ASM) && defined(__ELF__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86_64) && defined(__ELF__)
|
||||
.text
|
||||
.extern OPENSSL_ia32cap_P
|
||||
.hidden OPENSSL_ia32cap_P
|
||||
@@ -232,6 +225,7 @@ poly_hash_ad_internal:
|
||||
.align 64
|
||||
chacha20_poly1305_open:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
pushq %rbp
|
||||
.cfi_adjust_cfa_offset 8
|
||||
.cfi_offset %rbp,-16
|
||||
@@ -2117,6 +2111,7 @@ chacha20_poly1305_open:
|
||||
.align 64
|
||||
chacha20_poly1305_seal:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
pushq %rbp
|
||||
.cfi_adjust_cfa_offset 8
|
||||
.cfi_offset %rbp,-16
|
||||
@@ -8923,10 +8918,6 @@ chacha20_poly1305_seal_avx2:
|
||||
.cfi_endproc
|
||||
.size chacha20_poly1305_seal_avx2, .-chacha20_poly1305_seal_avx2
|
||||
#endif
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // defined(__x86_64__) && defined(__linux__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
+4
-13
@@ -3,16 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if defined(__has_feature)
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if defined(__x86_64__) && !defined(OPENSSL_NO_ASM) && defined(__APPLE__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86_64) && defined(__APPLE__)
|
||||
.text
|
||||
|
||||
|
||||
@@ -231,6 +224,7 @@ L$hash_ad_done:
|
||||
.p2align 6
|
||||
_chacha20_poly1305_open:
|
||||
|
||||
_CET_ENDBR
|
||||
pushq %rbp
|
||||
|
||||
pushq %rbx
|
||||
@@ -2102,6 +2096,7 @@ L$open_sse_128_xor_hash:
|
||||
.p2align 6
|
||||
_chacha20_poly1305_seal:
|
||||
|
||||
_CET_ENDBR
|
||||
pushq %rbp
|
||||
|
||||
pushq %rbx
|
||||
@@ -8879,10 +8874,6 @@ L$seal_avx2_exit:
|
||||
jmp L$seal_sse_tail_16
|
||||
|
||||
|
||||
#endif
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // defined(__x86_64__) && defined(__APPLE__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
|
||||
@@ -400,6 +400,14 @@ static int aead_aes_128_cbc_sha1_tls_implicit_iv_init(
|
||||
EVP_sha1(), 1);
|
||||
}
|
||||
|
||||
static int aead_aes_128_cbc_sha256_tls_init(EVP_AEAD_CTX *ctx,
|
||||
const uint8_t *key, size_t key_len,
|
||||
size_t tag_len,
|
||||
enum evp_aead_direction_t dir) {
|
||||
return aead_tls_init(ctx, key, key_len, tag_len, dir, EVP_aes_128_cbc(),
|
||||
EVP_sha256(), 0);
|
||||
}
|
||||
|
||||
static int aead_aes_256_cbc_sha1_tls_init(EVP_AEAD_CTX *ctx, const uint8_t *key,
|
||||
size_t key_len, size_t tag_len,
|
||||
enum evp_aead_direction_t dir) {
|
||||
@@ -442,13 +450,6 @@ static int aead_tls_get_iv(const EVP_AEAD_CTX *ctx, const uint8_t **out_iv,
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int aead_null_sha1_tls_init(EVP_AEAD_CTX *ctx, const uint8_t *key,
|
||||
size_t key_len, size_t tag_len,
|
||||
enum evp_aead_direction_t dir) {
|
||||
return aead_tls_init(ctx, key, key_len, tag_len, dir, EVP_enc_null(),
|
||||
EVP_sha1(), 1 /* implicit iv */);
|
||||
}
|
||||
|
||||
static const EVP_AEAD aead_aes_128_cbc_sha1_tls = {
|
||||
SHA_DIGEST_LENGTH + 16, // key len (SHA1 + AES128)
|
||||
16, // nonce len (IV)
|
||||
@@ -483,6 +484,23 @@ static const EVP_AEAD aead_aes_128_cbc_sha1_tls_implicit_iv = {
|
||||
aead_tls_tag_len,
|
||||
};
|
||||
|
||||
static const EVP_AEAD aead_aes_128_cbc_sha256_tls = {
|
||||
SHA256_DIGEST_LENGTH + 16, // key len (SHA256 + AES128)
|
||||
16, // nonce len (IV)
|
||||
16 + SHA256_DIGEST_LENGTH, // overhead (padding + SHA256)
|
||||
SHA256_DIGEST_LENGTH, // max tag length
|
||||
0, // seal_scatter_supports_extra_in
|
||||
|
||||
NULL, // init
|
||||
aead_aes_128_cbc_sha256_tls_init,
|
||||
aead_tls_cleanup,
|
||||
aead_tls_open,
|
||||
aead_tls_seal_scatter,
|
||||
NULL, // open_gather
|
||||
NULL, // get_iv
|
||||
aead_tls_tag_len,
|
||||
};
|
||||
|
||||
static const EVP_AEAD aead_aes_256_cbc_sha1_tls = {
|
||||
SHA_DIGEST_LENGTH + 32, // key len (SHA1 + AES256)
|
||||
16, // nonce len (IV)
|
||||
@@ -551,23 +569,6 @@ static const EVP_AEAD aead_des_ede3_cbc_sha1_tls_implicit_iv = {
|
||||
aead_tls_tag_len,
|
||||
};
|
||||
|
||||
static const EVP_AEAD aead_null_sha1_tls = {
|
||||
SHA_DIGEST_LENGTH, // key len
|
||||
0, // nonce len
|
||||
SHA_DIGEST_LENGTH, // overhead (SHA1)
|
||||
SHA_DIGEST_LENGTH, // max tag length
|
||||
0, // seal_scatter_supports_extra_in
|
||||
|
||||
NULL, // init
|
||||
aead_null_sha1_tls_init,
|
||||
aead_tls_cleanup,
|
||||
aead_tls_open,
|
||||
aead_tls_seal_scatter,
|
||||
NULL, // open_gather
|
||||
NULL, // get_iv
|
||||
aead_tls_tag_len,
|
||||
};
|
||||
|
||||
const EVP_AEAD *EVP_aead_aes_128_cbc_sha1_tls(void) {
|
||||
return &aead_aes_128_cbc_sha1_tls;
|
||||
}
|
||||
@@ -576,6 +577,10 @@ const EVP_AEAD *EVP_aead_aes_128_cbc_sha1_tls_implicit_iv(void) {
|
||||
return &aead_aes_128_cbc_sha1_tls_implicit_iv;
|
||||
}
|
||||
|
||||
const EVP_AEAD *EVP_aead_aes_128_cbc_sha256_tls(void) {
|
||||
return &aead_aes_128_cbc_sha256_tls;
|
||||
}
|
||||
|
||||
const EVP_AEAD *EVP_aead_aes_256_cbc_sha1_tls(void) {
|
||||
return &aead_aes_256_cbc_sha1_tls;
|
||||
}
|
||||
@@ -591,5 +596,3 @@ const EVP_AEAD *EVP_aead_des_ede3_cbc_sha1_tls(void) {
|
||||
const EVP_AEAD *EVP_aead_des_ede3_cbc_sha1_tls_implicit_iv(void) {
|
||||
return &aead_des_ede3_cbc_sha1_tls_implicit_iv;
|
||||
}
|
||||
|
||||
const EVP_AEAD *EVP_aead_null_sha1_tls(void) { return &aead_null_sha1_tls; }
|
||||
@@ -109,6 +109,14 @@ OPENSSL_EXPORT int EVP_sha1_final_with_secret_suffix(
|
||||
SHA_CTX *ctx, uint8_t out[SHA_DIGEST_LENGTH], const uint8_t *in, size_t len,
|
||||
size_t max_len);
|
||||
|
||||
// EVP_sha256_final_with_secret_suffix acts like
|
||||
// |EVP_sha1_final_with_secret_suffix|, but for SHA-256.
|
||||
//
|
||||
// This function is exported for unit tests.
|
||||
OPENSSL_EXPORT int EVP_sha256_final_with_secret_suffix(
|
||||
SHA256_CTX *ctx, uint8_t out[SHA256_DIGEST_LENGTH], const uint8_t *in,
|
||||
size_t len, size_t max_len);
|
||||
|
||||
// EVP_tls_cbc_digest_record computes the MAC of a decrypted, padded TLS
|
||||
// record.
|
||||
//
|
||||
|
||||
@@ -267,24 +267,115 @@ int EVP_sha1_final_with_secret_suffix(SHA_CTX *ctx,
|
||||
return 1;
|
||||
}
|
||||
|
||||
int EVP_tls_cbc_record_digest_supported(const EVP_MD *md) {
|
||||
return EVP_MD_type(md) == NID_sha1;
|
||||
}
|
||||
|
||||
int EVP_tls_cbc_digest_record(const EVP_MD *md, uint8_t *md_out,
|
||||
size_t *md_out_size, const uint8_t header[13],
|
||||
const uint8_t *data, size_t data_size,
|
||||
size_t data_plus_mac_plus_padding_size,
|
||||
const uint8_t *mac_secret,
|
||||
unsigned mac_secret_length) {
|
||||
if (EVP_MD_type(md) != NID_sha1) {
|
||||
// EVP_tls_cbc_record_digest_supported should have been called first to
|
||||
// check that the hash function is supported.
|
||||
assert(0);
|
||||
*md_out_size = 0;
|
||||
return 0;
|
||||
int EVP_sha256_final_with_secret_suffix(SHA256_CTX *ctx,
|
||||
uint8_t out[SHA256_DIGEST_LENGTH],
|
||||
const uint8_t *in, size_t len,
|
||||
size_t max_len) {
|
||||
// Bound the input length so |total_bits| below fits in four bytes. This is
|
||||
// redundant with TLS record size limits. This also ensures |input_idx| below
|
||||
// does not overflow.
|
||||
size_t max_len_bits = max_len << 3;
|
||||
if (ctx->Nh != 0 ||
|
||||
(max_len_bits >> 3) != max_len || // Overflow
|
||||
ctx->Nl + max_len_bits < max_len_bits ||
|
||||
ctx->Nl + max_len_bits > UINT32_MAX) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
// We need to hash the following into |ctx|:
|
||||
//
|
||||
// - ctx->data[:ctx->num]
|
||||
// - in[:len]
|
||||
// - A 0x80 byte
|
||||
// - However many zero bytes are needed to pad up to a block.
|
||||
// - Eight bytes of length.
|
||||
size_t num_blocks = (ctx->num + len + 1 + 8 + SHA256_CBLOCK - 1) >> 6;
|
||||
size_t last_block = num_blocks - 1;
|
||||
size_t max_blocks = (ctx->num + max_len + 1 + 8 + SHA256_CBLOCK - 1) >> 6;
|
||||
|
||||
// The bounds above imply |total_bits| fits in four bytes.
|
||||
size_t total_bits = ctx->Nl + (len << 3);
|
||||
uint8_t length_bytes[4];
|
||||
length_bytes[0] = (uint8_t)(total_bits >> 24);
|
||||
length_bytes[1] = (uint8_t)(total_bits >> 16);
|
||||
length_bytes[2] = (uint8_t)(total_bits >> 8);
|
||||
length_bytes[3] = (uint8_t)total_bits;
|
||||
|
||||
// We now construct and process each expected block in constant-time.
|
||||
uint8_t block[SHA256_CBLOCK] = {0};
|
||||
uint32_t result[8] = {0};
|
||||
// input_idx is the index into |in| corresponding to the current block.
|
||||
// However, we allow this index to overflow beyond |max_len|, to simplify the
|
||||
// 0x80 byte.
|
||||
size_t input_idx = 0;
|
||||
for (size_t i = 0; i < max_blocks; i++) {
|
||||
// Fill |block| with data from the partial block in |ctx| and |in|. We copy
|
||||
// as if we were hashing up to |max_len| and then zero the excess later.
|
||||
size_t block_start = 0;
|
||||
if (i == 0) {
|
||||
OPENSSL_memcpy(block, ctx->data, ctx->num);
|
||||
block_start = ctx->num;
|
||||
}
|
||||
if (input_idx < max_len) {
|
||||
size_t to_copy = SHA256_CBLOCK - block_start;
|
||||
if (to_copy > max_len - input_idx) {
|
||||
to_copy = max_len - input_idx;
|
||||
}
|
||||
OPENSSL_memcpy(block + block_start, in + input_idx, to_copy);
|
||||
}
|
||||
|
||||
// Zero any bytes beyond |len| and add the 0x80 byte.
|
||||
for (size_t j = block_start; j < SHA256_CBLOCK; j++) {
|
||||
// input[idx] corresponds to block[j].
|
||||
size_t idx = input_idx + j - block_start;
|
||||
// The barriers on |len| are not strictly necessary. However, without
|
||||
// them, GCC compiles this code by incorporating |len| into the loop
|
||||
// counter and subtracting it out later. This is still constant-time, but
|
||||
// it frustrates attempts to validate this.
|
||||
uint8_t is_in_bounds = constant_time_lt_8(idx, value_barrier_w(len));
|
||||
uint8_t is_padding_byte = constant_time_eq_8(idx, value_barrier_w(len));
|
||||
block[j] &= is_in_bounds;
|
||||
block[j] |= 0x80 & is_padding_byte;
|
||||
}
|
||||
|
||||
input_idx += SHA256_CBLOCK - block_start;
|
||||
|
||||
// Fill in the length if this is the last block.
|
||||
crypto_word_t is_last_block = constant_time_eq_w(i, last_block);
|
||||
for (size_t j = 0; j < 4; j++) {
|
||||
block[SHA256_CBLOCK - 4 + j] |= is_last_block & length_bytes[j];
|
||||
}
|
||||
|
||||
// Process the block and save the hash state if it is the final value.
|
||||
SHA256_Transform(ctx, block);
|
||||
for (size_t j = 0; j < 8; j++) {
|
||||
result[j] |= is_last_block & ctx->h[j];
|
||||
}
|
||||
}
|
||||
|
||||
// Write the output.
|
||||
for (size_t i = 0; i < 8; i++) {
|
||||
CRYPTO_store_u32_be(out + 4 * i, result[i]);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
int EVP_tls_cbc_record_digest_supported(const EVP_MD *md) {
|
||||
switch (EVP_MD_type(md)) {
|
||||
case NID_sha1:
|
||||
case NID_sha256:
|
||||
return 1;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static int tls_cbc_digest_record_sha1(uint8_t *md_out, size_t *md_out_size,
|
||||
const uint8_t header[13],
|
||||
const uint8_t *data, size_t data_size,
|
||||
size_t data_plus_mac_plus_padding_size,
|
||||
const uint8_t *mac_secret,
|
||||
unsigned mac_secret_length) {
|
||||
if (mac_secret_length > SHA_CBLOCK) {
|
||||
// HMAC pads small keys with zeros and hashes large keys down. This function
|
||||
// should never reach the large key case.
|
||||
@@ -336,3 +427,88 @@ int EVP_tls_cbc_digest_record(const EVP_MD *md, uint8_t *md_out,
|
||||
*md_out_size = SHA_DIGEST_LENGTH;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int tls_cbc_digest_record_sha256(uint8_t *md_out, size_t *md_out_size,
|
||||
const uint8_t header[13],
|
||||
const uint8_t *data, size_t data_size,
|
||||
size_t data_plus_mac_plus_padding_size,
|
||||
const uint8_t *mac_secret,
|
||||
unsigned mac_secret_length) {
|
||||
if (mac_secret_length > SHA256_CBLOCK) {
|
||||
// HMAC pads small keys with zeros and hashes large keys down. This function
|
||||
// should never reach the large key case.
|
||||
assert(0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Compute the initial HMAC block.
|
||||
uint8_t hmac_pad[SHA256_CBLOCK];
|
||||
OPENSSL_memset(hmac_pad, 0, sizeof(hmac_pad));
|
||||
OPENSSL_memcpy(hmac_pad, mac_secret, mac_secret_length);
|
||||
for (size_t i = 0; i < SHA256_CBLOCK; i++) {
|
||||
hmac_pad[i] ^= 0x36;
|
||||
}
|
||||
|
||||
SHA256_CTX ctx;
|
||||
SHA256_Init(&ctx);
|
||||
SHA256_Update(&ctx, hmac_pad, SHA256_CBLOCK);
|
||||
SHA256_Update(&ctx, header, 13);
|
||||
|
||||
// There are at most 256 bytes of padding, so we can compute the public
|
||||
// minimum length for |data_size|.
|
||||
size_t min_data_size = 0;
|
||||
if (data_plus_mac_plus_padding_size > SHA256_DIGEST_LENGTH + 256) {
|
||||
min_data_size =
|
||||
data_plus_mac_plus_padding_size - SHA256_DIGEST_LENGTH - 256;
|
||||
}
|
||||
|
||||
// Hash the public minimum length directly. This reduces the number of blocks
|
||||
// that must be computed in constant-time.
|
||||
SHA256_Update(&ctx, data, min_data_size);
|
||||
|
||||
// Hash the remaining data without leaking |data_size|.
|
||||
uint8_t mac_out[SHA256_DIGEST_LENGTH];
|
||||
if (!EVP_sha256_final_with_secret_suffix(
|
||||
&ctx, mac_out, data + min_data_size, data_size - min_data_size,
|
||||
data_plus_mac_plus_padding_size - min_data_size)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Complete the HMAC in the standard manner.
|
||||
SHA256_Init(&ctx);
|
||||
for (size_t i = 0; i < SHA256_CBLOCK; i++) {
|
||||
hmac_pad[i] ^= 0x6a;
|
||||
}
|
||||
|
||||
SHA256_Update(&ctx, hmac_pad, SHA256_CBLOCK);
|
||||
SHA256_Update(&ctx, mac_out, SHA256_DIGEST_LENGTH);
|
||||
SHA256_Final(md_out, &ctx);
|
||||
*md_out_size = SHA256_DIGEST_LENGTH;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int EVP_tls_cbc_digest_record(const EVP_MD *md, uint8_t *md_out,
|
||||
size_t *md_out_size, const uint8_t header[13],
|
||||
const uint8_t *data, size_t data_size,
|
||||
size_t data_plus_mac_plus_padding_size,
|
||||
const uint8_t *mac_secret,
|
||||
unsigned mac_secret_length) {
|
||||
switch (EVP_MD_type(md)) {
|
||||
case NID_sha1:
|
||||
return tls_cbc_digest_record_sha1(
|
||||
md_out, md_out_size, header, data, data_size,
|
||||
data_plus_mac_plus_padding_size, mac_secret, mac_secret_length);
|
||||
|
||||
case NID_sha256:
|
||||
return tls_cbc_digest_record_sha256(
|
||||
md_out, md_out_size, header, data, data_size,
|
||||
data_plus_mac_plus_padding_size, mac_secret, mac_secret_length);
|
||||
|
||||
default:
|
||||
// EVP_tls_cbc_record_digest_supported should have been called first to
|
||||
// check that the hash function is supported.
|
||||
assert(0);
|
||||
*md_out_size = 0;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
@@ -68,21 +68,10 @@
|
||||
#include "conf_def.h"
|
||||
#include "internal.h"
|
||||
#include "../internal.h"
|
||||
#include "../lhash/internal.h"
|
||||
|
||||
|
||||
DEFINE_LHASH_OF(CONF_VALUE)
|
||||
|
||||
struct conf_st {
|
||||
LHASH_OF(CONF_VALUE) *data;
|
||||
};
|
||||
|
||||
static const char kDefaultSectionName[] = "default";
|
||||
|
||||
// The maximum length we can grow a value to after variable expansion. 64k
|
||||
// should be more than enough for all reasonable uses.
|
||||
#define MAX_CONF_VALUE_LENGTH 65536
|
||||
|
||||
static uint32_t conf_value_hash(const CONF_VALUE *v) {
|
||||
const uint32_t section_hash = v->section ? OPENSSL_strhash(v->section) : 0;
|
||||
const uint32_t name_hash = v->name ? OPENSSL_strhash(v->name) : 0;
|
||||
@@ -139,24 +128,23 @@ CONF_VALUE *CONF_VALUE_new(void) {
|
||||
}
|
||||
|
||||
static void value_free_contents(CONF_VALUE *value) {
|
||||
if (value->section) {
|
||||
OPENSSL_free(value->section);
|
||||
}
|
||||
OPENSSL_free(value->section);
|
||||
if (value->name) {
|
||||
OPENSSL_free(value->name);
|
||||
if (value->value) {
|
||||
OPENSSL_free(value->value);
|
||||
}
|
||||
OPENSSL_free(value->value);
|
||||
} else {
|
||||
if (value->value) {
|
||||
sk_CONF_VALUE_free((STACK_OF(CONF_VALUE)*)value->value);
|
||||
}
|
||||
// TODO(davidben): When |value->name| is NULL, |CONF_VALUE| is actually an
|
||||
// entirely different structure. This is fragile and confusing. Make a
|
||||
// proper |CONF_SECTION| type that doesn't require this.
|
||||
sk_CONF_VALUE_free((STACK_OF(CONF_VALUE) *)value->value);
|
||||
}
|
||||
}
|
||||
|
||||
static void value_free(CONF_VALUE *value) {
|
||||
value_free_contents(value);
|
||||
OPENSSL_free(value);
|
||||
if (value != NULL) {
|
||||
value_free_contents(value);
|
||||
OPENSSL_free(value);
|
||||
}
|
||||
}
|
||||
|
||||
static void value_free_arg(CONF_VALUE *value, void *arg) { value_free(value); }
|
||||
@@ -192,28 +180,21 @@ static CONF_VALUE *NCONF_new_section(const CONF *conf, const char *section) {
|
||||
if (!lh_CONF_VALUE_insert(conf->data, &old_value, v)) {
|
||||
goto err;
|
||||
}
|
||||
if (old_value) {
|
||||
value_free(old_value);
|
||||
}
|
||||
value_free(old_value);
|
||||
ok = 1;
|
||||
|
||||
err:
|
||||
if (!ok) {
|
||||
if (sk != NULL) {
|
||||
sk_CONF_VALUE_free(sk);
|
||||
}
|
||||
if (v != NULL) {
|
||||
OPENSSL_free(v);
|
||||
}
|
||||
sk_CONF_VALUE_free(sk);
|
||||
OPENSSL_free(v);
|
||||
v = NULL;
|
||||
}
|
||||
return v;
|
||||
}
|
||||
|
||||
static int str_copy(CONF *conf, char *section, char **pto, char *from) {
|
||||
int q, r, rr = 0, to = 0, len = 0;
|
||||
char *s, *e, *rp, *rrp, *np, *cp, v;
|
||||
const char *p;
|
||||
int q, to = 0, len = 0;
|
||||
char v;
|
||||
BUF_MEM *buf;
|
||||
|
||||
buf = BUF_MEM_new();
|
||||
@@ -242,22 +223,6 @@ static int str_copy(CONF *conf, char *section, char **pto, char *from) {
|
||||
if (*from == q) {
|
||||
from++;
|
||||
}
|
||||
} else if (IS_DQUOTE(conf, *from)) {
|
||||
q = *from;
|
||||
from++;
|
||||
while (!IS_EOF(conf, *from)) {
|
||||
if (*from == q) {
|
||||
if (*(from + 1) == q) {
|
||||
from++;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
buf->data[to++] = *(from++);
|
||||
}
|
||||
if (*from == q) {
|
||||
from++;
|
||||
}
|
||||
} else if (IS_ESC(conf, *from)) {
|
||||
from++;
|
||||
v = *(from++);
|
||||
@@ -276,102 +241,23 @@ static int str_copy(CONF *conf, char *section, char **pto, char *from) {
|
||||
} else if (IS_EOF(conf, *from)) {
|
||||
break;
|
||||
} else if (*from == '$') {
|
||||
// try to expand it
|
||||
rrp = NULL;
|
||||
s = &(from[1]);
|
||||
if (*s == '{') {
|
||||
q = '}';
|
||||
} else if (*s == '(') {
|
||||
q = ')';
|
||||
} else {
|
||||
q = 0;
|
||||
}
|
||||
|
||||
if (q) {
|
||||
s++;
|
||||
}
|
||||
cp = section;
|
||||
e = np = s;
|
||||
while (IS_ALPHA_NUMERIC(conf, *e)) {
|
||||
e++;
|
||||
}
|
||||
if (e[0] == ':' && e[1] == ':') {
|
||||
cp = np;
|
||||
rrp = e;
|
||||
rr = *e;
|
||||
*rrp = '\0';
|
||||
e += 2;
|
||||
np = e;
|
||||
while (IS_ALPHA_NUMERIC(conf, *e)) {
|
||||
e++;
|
||||
}
|
||||
}
|
||||
r = *e;
|
||||
*e = '\0';
|
||||
rp = e;
|
||||
if (q) {
|
||||
if (r != q) {
|
||||
OPENSSL_PUT_ERROR(CONF, CONF_R_NO_CLOSE_BRACE);
|
||||
goto err;
|
||||
}
|
||||
e++;
|
||||
}
|
||||
// So at this point we have
|
||||
// np which is the start of the name string which is
|
||||
// '\0' terminated.
|
||||
// cp which is the start of the section string which is
|
||||
// '\0' terminated.
|
||||
// e is the 'next point after'.
|
||||
// r and rr are the chars replaced by the '\0'
|
||||
// rp and rrp is where 'r' and 'rr' came from.
|
||||
p = NCONF_get_string(conf, cp, np);
|
||||
if (rrp != NULL) {
|
||||
*rrp = rr;
|
||||
}
|
||||
*rp = r;
|
||||
if (p == NULL) {
|
||||
OPENSSL_PUT_ERROR(CONF, CONF_R_VARIABLE_HAS_NO_VALUE);
|
||||
goto err;
|
||||
}
|
||||
size_t newsize = strlen(p) + buf->length - (e - from);
|
||||
if (newsize > MAX_CONF_VALUE_LENGTH) {
|
||||
OPENSSL_PUT_ERROR(CONF, CONF_R_VARIABLE_EXPANSION_TOO_LONG);
|
||||
goto err;
|
||||
}
|
||||
if (!BUF_MEM_grow_clean(buf, newsize)) {
|
||||
goto err;
|
||||
}
|
||||
while (*p) {
|
||||
buf->data[to++] = *(p++);
|
||||
}
|
||||
|
||||
/* Since we change the pointer 'from', we also have
|
||||
to change the perceived length of the string it
|
||||
points at. /RL */
|
||||
len -= e - from;
|
||||
from = e;
|
||||
|
||||
/* In case there were no braces or parenthesis around
|
||||
the variable reference, we have to put back the
|
||||
character that was replaced with a '\0'. /RL */
|
||||
*rp = r;
|
||||
// Historically, $foo would expand to a previously-parsed value. This
|
||||
// feature has been removed as it was unused and is a DoS vector.
|
||||
OPENSSL_PUT_ERROR(CONF, CONF_R_VARIABLE_EXPANSION_NOT_SUPPORTED);
|
||||
goto err;
|
||||
} else {
|
||||
buf->data[to++] = *(from++);
|
||||
}
|
||||
}
|
||||
|
||||
buf->data[to] = '\0';
|
||||
if (*pto != NULL) {
|
||||
OPENSSL_free(*pto);
|
||||
}
|
||||
OPENSSL_free(*pto);
|
||||
*pto = buf->data;
|
||||
OPENSSL_free(buf);
|
||||
return 1;
|
||||
|
||||
err:
|
||||
if (buf != NULL) {
|
||||
BUF_MEM_free(buf);
|
||||
}
|
||||
BUF_MEM_free(buf);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@@ -472,33 +358,8 @@ static char *scan_quote(CONF *conf, char *p) {
|
||||
return p;
|
||||
}
|
||||
|
||||
|
||||
static char *scan_dquote(CONF *conf, char *p) {
|
||||
int q = *p;
|
||||
|
||||
p++;
|
||||
while (!(IS_EOF(conf, *p))) {
|
||||
if (*p == q) {
|
||||
if (*(p + 1) == q) {
|
||||
p++;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
p++;
|
||||
}
|
||||
if (*p == q) {
|
||||
p++;
|
||||
}
|
||||
return p;
|
||||
}
|
||||
|
||||
static void clear_comments(CONF *conf, char *p) {
|
||||
for (;;) {
|
||||
if (IS_FCOMMENT(conf, *p)) {
|
||||
*p = '\0';
|
||||
return;
|
||||
}
|
||||
if (!IS_WS(conf, *p)) {
|
||||
break;
|
||||
}
|
||||
@@ -510,10 +371,6 @@ static void clear_comments(CONF *conf, char *p) {
|
||||
*p = '\0';
|
||||
return;
|
||||
}
|
||||
if (IS_DQUOTE(conf, *p)) {
|
||||
p = scan_dquote(conf, p);
|
||||
continue;
|
||||
}
|
||||
if (IS_QUOTE(conf, *p)) {
|
||||
p = scan_quote(conf, p);
|
||||
continue;
|
||||
@@ -530,7 +387,7 @@ static void clear_comments(CONF *conf, char *p) {
|
||||
}
|
||||
}
|
||||
|
||||
static int def_load_bio(CONF *conf, BIO *in, long *out_error_line) {
|
||||
int NCONF_load_bio(CONF *conf, BIO *in, long *out_error_line) {
|
||||
static const size_t CONFBUFSIZE = 512;
|
||||
int bufnum = 0, i, ii;
|
||||
BUF_MEM *buff = NULL;
|
||||
@@ -707,37 +564,23 @@ static int def_load_bio(CONF *conf, BIO *in, long *out_error_line) {
|
||||
v = NULL;
|
||||
}
|
||||
}
|
||||
if (buff != NULL) {
|
||||
BUF_MEM_free(buff);
|
||||
}
|
||||
if (section != NULL) {
|
||||
OPENSSL_free(section);
|
||||
}
|
||||
BUF_MEM_free(buff);
|
||||
OPENSSL_free(section);
|
||||
return 1;
|
||||
|
||||
err:
|
||||
if (buff != NULL) {
|
||||
BUF_MEM_free(buff);
|
||||
}
|
||||
if (section != NULL) {
|
||||
OPENSSL_free(section);
|
||||
}
|
||||
BUF_MEM_free(buff);
|
||||
OPENSSL_free(section);
|
||||
if (out_error_line != NULL) {
|
||||
*out_error_line = eline;
|
||||
}
|
||||
BIO_snprintf(btmp, sizeof btmp, "%ld", eline);
|
||||
snprintf(btmp, sizeof btmp, "%ld", eline);
|
||||
ERR_add_error_data(2, "line ", btmp);
|
||||
|
||||
if (v != NULL) {
|
||||
if (v->name != NULL) {
|
||||
OPENSSL_free(v->name);
|
||||
}
|
||||
if (v->value != NULL) {
|
||||
OPENSSL_free(v->value);
|
||||
}
|
||||
if (v != NULL) {
|
||||
OPENSSL_free(v);
|
||||
}
|
||||
OPENSSL_free(v->name);
|
||||
OPENSSL_free(v->value);
|
||||
OPENSSL_free(v);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -751,16 +594,12 @@ int NCONF_load(CONF *conf, const char *filename, long *out_error_line) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
ret = def_load_bio(conf, in, out_error_line);
|
||||
ret = NCONF_load_bio(conf, in, out_error_line);
|
||||
BIO_free(in);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int NCONF_load_bio(CONF *conf, BIO *bio, long *out_error_line) {
|
||||
return def_load_bio(conf, bio, out_error_line);
|
||||
}
|
||||
|
||||
int CONF_parse_list(const char *list, char sep, int remove_whitespace,
|
||||
int (*list_cb)(const char *elem, size_t len, void *usr),
|
||||
void *arg) {
|
||||
|
||||
@@ -55,8 +55,9 @@
|
||||
* [including the GNU Public Licence.]
|
||||
*/
|
||||
|
||||
/* THIS FILE WAS AUTOMAGICALLY GENERATED!
|
||||
Please modify and use keysets.pl to regenerate it. */
|
||||
// This file was historically generated by keysets.pl in OpenSSL.
|
||||
//
|
||||
// TODO(davidben): Replace it with something more readable.
|
||||
|
||||
#define CONF_NUMBER 1
|
||||
#define CONF_UPPER 2
|
||||
@@ -66,9 +67,7 @@
|
||||
#define CONF_WS 16
|
||||
#define CONF_ESC 32
|
||||
#define CONF_QUOTE 64
|
||||
#define CONF_DQUOTE 1024
|
||||
#define CONF_COMMENT 128
|
||||
#define CONF_FCOMMENT 2048
|
||||
#define CONF_EOF 8
|
||||
#define CONF_HIGHBIT 4096
|
||||
#define CONF_ALPHA (CONF_UPPER|CONF_LOWER)
|
||||
@@ -78,7 +77,6 @@
|
||||
|
||||
#define KEYTYPES(c) CONF_type_default
|
||||
#define IS_COMMENT(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_COMMENT)
|
||||
#define IS_FCOMMENT(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_FCOMMENT)
|
||||
#define IS_EOF(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_EOF)
|
||||
#define IS_ESC(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_ESC)
|
||||
#define IS_NUMBER(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_NUMBER)
|
||||
@@ -87,8 +85,6 @@
|
||||
#define IS_ALPHA_NUMERIC_PUNCT(c,a) \
|
||||
(KEYTYPES(c)[(a)&0xff]&CONF_ALPHA_NUMERIC_PUNCT)
|
||||
#define IS_QUOTE(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_QUOTE)
|
||||
#define IS_DQUOTE(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_DQUOTE)
|
||||
#define IS_HIGHBIT(c,a) (KEYTYPES(c)[(a)&0xff]&CONF_HIGHBIT)
|
||||
|
||||
static const unsigned short CONF_type_default[256]={
|
||||
0x0008,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
|
||||
|
||||
@@ -17,11 +17,19 @@
|
||||
|
||||
#include <CCryptoBoringSSL_base.h>
|
||||
|
||||
#include "../lhash/internal.h"
|
||||
|
||||
#if defined(__cplusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
DEFINE_LHASH_OF(CONF_VALUE)
|
||||
|
||||
struct conf_st {
|
||||
LHASH_OF(CONF_VALUE) *data;
|
||||
};
|
||||
|
||||
// CONF_VALUE_new returns a freshly allocated and zeroed |CONF_VALUE|.
|
||||
CONF_VALUE *CONF_VALUE_new(void);
|
||||
|
||||
|
||||
@@ -23,8 +23,6 @@
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
|
||||
|
||||
extern uint32_t OPENSSL_armcap_P;
|
||||
|
||||
static int has_hw_feature(const char *name) {
|
||||
int value;
|
||||
size_t len = sizeof(value);
|
||||
@@ -65,6 +63,9 @@ void OPENSSL_cpuid_setup(void) {
|
||||
// available in macOS 12. For compatibility with macOS 11, we also support
|
||||
// the old names. The old names don't have values for features like FEAT_AES,
|
||||
// so instead we detect them statically above.
|
||||
//
|
||||
// If querying new sysctls, update the Chromium sandbox definition. See
|
||||
// https://crrev.com/c/4415225.
|
||||
if (has_hw_feature("hw.optional.arm.FEAT_SHA512") ||
|
||||
has_hw_feature("hw.optional.armv8_2_sha512")) {
|
||||
OPENSSL_armcap_P |= ARMV8_SHA512;
|
||||
|
||||
@@ -23,7 +23,6 @@
|
||||
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
|
||||
extern uint32_t OPENSSL_armcap_P;
|
||||
|
||||
void OPENSSL_cpuid_setup(void) {
|
||||
uint32_t hwcap;
|
||||
|
||||
@@ -22,8 +22,6 @@
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
|
||||
|
||||
extern uint32_t OPENSSL_armcap_P;
|
||||
|
||||
void OPENSSL_cpuid_setup(void) {
|
||||
unsigned long hwcap = getauxval(AT_HWCAP);
|
||||
|
||||
|
||||
+23
-24
@@ -1,4 +1,4 @@
|
||||
/* Copyright (c) 2022, Google Inc.
|
||||
/* Copyright (c) 2022, Robert Nagy <robert.nagy@gmail.com>
|
||||
*
|
||||
* Permission to use, copy, modify, and/or distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
@@ -12,51 +12,50 @@
|
||||
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
||||
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
|
||||
|
||||
#include "internal.h"
|
||||
#include <CCryptoBoringSSL_cpu.h>
|
||||
|
||||
#if defined(OPENSSL_AARCH64) && defined(OPENSSL_FREEBSD) && \
|
||||
#if defined(OPENSSL_AARCH64) && defined(OPENSSL_OPENBSD) && \
|
||||
!defined(OPENSSL_STATIC_ARMCAP)
|
||||
|
||||
#include <sys/sysctl.h>
|
||||
#include <machine/cpu.h>
|
||||
#include <machine/armreg.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
|
||||
extern uint32_t OPENSSL_armcap_P;
|
||||
#include "internal.h"
|
||||
|
||||
// ID_AA64ISAR0_*_VAL are defined starting FreeBSD 13.0. When FreeBSD
|
||||
// 12.x is out of support, these compatibility macros can be removed.
|
||||
|
||||
#ifndef ID_AA64ISAR0_AES_VAL
|
||||
#define ID_AA64ISAR0_AES_VAL ID_AA64ISAR0_AES
|
||||
#endif
|
||||
#ifndef ID_AA64ISAR0_SHA1_VAL
|
||||
#define ID_AA64ISAR0_SHA1_VAL ID_AA64ISAR0_SHA1
|
||||
#endif
|
||||
#ifndef ID_AA64ISAR0_SHA2_VAL
|
||||
#define ID_AA64ISAR0_SHA2_VAL ID_AA64ISAR0_SHA2
|
||||
#endif
|
||||
|
||||
void OPENSSL_cpuid_setup(void) {
|
||||
uint64_t id_aa64isar0 = READ_SPECIALREG(id_aa64isar0_el1);
|
||||
int isar0_mib[] = { CTL_MACHDEP, CPU_ID_AA64ISAR0 };
|
||||
uint64_t cpu_id = 0;
|
||||
size_t len = sizeof(cpu_id);
|
||||
|
||||
if (sysctl(isar0_mib, 2, &cpu_id, &len, NULL, 0) < 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
OPENSSL_armcap_P |= ARMV7_NEON;
|
||||
|
||||
if (ID_AA64ISAR0_AES_VAL(id_aa64isar0) >= ID_AA64ISAR0_AES_BASE) {
|
||||
if (ID_AA64ISAR0_AES(cpu_id) >= ID_AA64ISAR0_AES_BASE) {
|
||||
OPENSSL_armcap_P |= ARMV8_AES;
|
||||
}
|
||||
if (ID_AA64ISAR0_AES_VAL(id_aa64isar0) >= ID_AA64ISAR0_AES_PMULL) {
|
||||
|
||||
if (ID_AA64ISAR0_AES(cpu_id) >= ID_AA64ISAR0_AES_PMULL) {
|
||||
OPENSSL_armcap_P |= ARMV8_PMULL;
|
||||
}
|
||||
if (ID_AA64ISAR0_SHA1_VAL(id_aa64isar0) >= ID_AA64ISAR0_SHA1_BASE) {
|
||||
|
||||
if (ID_AA64ISAR0_SHA1(cpu_id) >= ID_AA64ISAR0_SHA1_BASE) {
|
||||
OPENSSL_armcap_P |= ARMV8_SHA1;
|
||||
}
|
||||
if (ID_AA64ISAR0_SHA2_VAL(id_aa64isar0) >= ID_AA64ISAR0_SHA2_BASE) {
|
||||
|
||||
if (ID_AA64ISAR0_SHA2(cpu_id) >= ID_AA64ISAR0_SHA2_BASE) {
|
||||
OPENSSL_armcap_P |= ARMV8_SHA256;
|
||||
}
|
||||
if (ID_AA64ISAR0_SHA2_VAL(id_aa64isar0) >= ID_AA64ISAR0_SHA2_512) {
|
||||
|
||||
if (ID_AA64ISAR0_SHA2(cpu_id) >= ID_AA64ISAR0_SHA2_512) {
|
||||
OPENSSL_armcap_P |= ARMV8_SHA512;
|
||||
}
|
||||
}
|
||||
|
||||
#endif // OPENSSL_AARCH64 && OPENSSL_FREEBSD && !OPENSSL_STATIC_ARMCAP
|
||||
#endif // OPENSSL_AARCH64 && OPENSSL_OPENBSD && !OPENSSL_STATIC_ARMCAP
|
||||
@@ -0,0 +1,93 @@
|
||||
/* Copyright (c) 2023, 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 "internal.h"
|
||||
|
||||
// While Arm system registers are normally not available to userspace, FreeBSD
|
||||
// expects userspace to simply read them. It traps the reads and fills in CPU
|
||||
// capabilities.
|
||||
#if defined(OPENSSL_AARCH64) && !defined(OPENSSL_STATIC_ARMCAP) && \
|
||||
(defined(ANDROID_BAREMETAL) || defined(OPENSSL_FREEBSD))
|
||||
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
|
||||
#define ID_AA64PFR0_EL1_ADVSIMD 5
|
||||
|
||||
#define ID_AA64ISAR0_EL1_AES 1
|
||||
#define ID_AA64ISAR0_EL1_SHA1 2
|
||||
#define ID_AA64ISAR0_EL1_SHA2 3
|
||||
|
||||
#define NBITS_ID_FIELD 4
|
||||
|
||||
#define READ_SYSREG(name) \
|
||||
({ \
|
||||
uint64_t _r; \
|
||||
__asm__("mrs %0, " name : "=r"(_r)); \
|
||||
_r; \
|
||||
})
|
||||
|
||||
static unsigned get_id_field(uint64_t reg, unsigned field) {
|
||||
return (reg >> (field * NBITS_ID_FIELD)) & ((1 << NBITS_ID_FIELD) - 1);
|
||||
}
|
||||
|
||||
static int get_signed_id_field(uint64_t reg, unsigned field) {
|
||||
unsigned value = get_id_field(reg, field);
|
||||
if (value & (1 << (NBITS_ID_FIELD - 1))) {
|
||||
return (int)(value | (UINT64_MAX << NBITS_ID_FIELD));
|
||||
} else {
|
||||
return (int)value;
|
||||
}
|
||||
}
|
||||
|
||||
static uint32_t read_armcap(void) {
|
||||
uint32_t armcap = ARMV7_NEON;
|
||||
|
||||
uint64_t id_aa64pfr0_el1 = READ_SYSREG("id_aa64pfr0_el1");
|
||||
|
||||
if (get_signed_id_field(id_aa64pfr0_el1, ID_AA64PFR0_EL1_ADVSIMD) < 0) {
|
||||
// If AdvSIMD ("NEON") is missing, don't report other features either.
|
||||
// This matches OpenSSL.
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint64_t id_aa64isar0_el1 = READ_SYSREG("id_aa64isar0_el1");
|
||||
|
||||
unsigned aes = get_id_field(id_aa64isar0_el1, ID_AA64ISAR0_EL1_AES);
|
||||
if (aes > 0) {
|
||||
armcap |= ARMV8_AES;
|
||||
}
|
||||
if (aes > 1) {
|
||||
armcap |= ARMV8_PMULL;
|
||||
}
|
||||
|
||||
unsigned sha1 = get_id_field(id_aa64isar0_el1, ID_AA64ISAR0_EL1_SHA1);
|
||||
if (sha1 > 0) {
|
||||
armcap |= ARMV8_SHA1;
|
||||
}
|
||||
|
||||
unsigned sha2 = get_id_field(id_aa64isar0_el1, ID_AA64ISAR0_EL1_SHA2);
|
||||
if (sha2 > 0) {
|
||||
armcap |= ARMV8_SHA256;
|
||||
}
|
||||
if (sha2 > 1) {
|
||||
armcap |= ARMV8_SHA512;
|
||||
}
|
||||
|
||||
return armcap;
|
||||
}
|
||||
|
||||
void OPENSSL_cpuid_setup(void) { OPENSSL_armcap_P |= read_armcap(); }
|
||||
|
||||
#endif // OPENSSL_AARCH64 && !OPENSSL_STATIC_ARMCAP &&
|
||||
// (ANDROID_BAREMETAL || OPENSSL_FREEBSD)
|
||||
@@ -22,7 +22,7 @@
|
||||
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
|
||||
extern uint32_t OPENSSL_armcap_P;
|
||||
|
||||
void OPENSSL_cpuid_setup(void) {
|
||||
// We do not need to check for the presence of NEON, as Armv8-A always has it
|
||||
OPENSSL_armcap_P |= ARMV7_NEON;
|
||||
|
||||
@@ -20,8 +20,6 @@
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
|
||||
|
||||
extern uint32_t OPENSSL_armcap_P;
|
||||
|
||||
int CRYPTO_is_NEON_capable_at_runtime(void) {
|
||||
return (OPENSSL_armcap_P & ARMV7_NEON) != 0;
|
||||
}
|
||||
|
||||
@@ -22,7 +22,6 @@
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
#include <CCryptoBoringSSL_mem.h>
|
||||
|
||||
extern uint32_t OPENSSL_armcap_P;
|
||||
|
||||
void OPENSSL_cpuid_setup(void) {
|
||||
unsigned long hwcap = 0, hwcap2 = 0;
|
||||
|
||||
@@ -95,8 +95,6 @@ err:
|
||||
return ret;
|
||||
}
|
||||
|
||||
extern uint32_t OPENSSL_armcap_P;
|
||||
|
||||
static int g_needs_hwcap2_workaround;
|
||||
|
||||
void OPENSSL_cpuid_setup(void) {
|
||||
|
||||
@@ -19,17 +19,9 @@
|
||||
* domain licensed but the standard ISC license is included above to keep
|
||||
* licensing simple. */
|
||||
|
||||
#if defined(__has_feature)
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__ARMEL__) && defined(__ELF__)
|
||||
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_ARM) && defined(__ELF__)
|
||||
|
||||
.fpu neon
|
||||
.text
|
||||
@@ -2131,11 +2123,7 @@ mov sp,r12
|
||||
vpop {q4,q5,q6,q7}
|
||||
bx lr
|
||||
|
||||
#endif /* !OPENSSL_NO_ASM && __ARMEL__ && __ELF__ */
|
||||
|
||||
#if defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif /* !OPENSSL_NO_ASM && OPENSSL_ARM && __ELF__ */
|
||||
#endif // defined(__arm__) && defined(__linux__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -19,8 +19,6 @@
|
||||
//
|
||||
// The field functions are shared by Ed25519 and X25519 where possible.
|
||||
|
||||
#include <CCryptoBoringSSL_curve25519.h>
|
||||
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
|
||||
@@ -31,15 +29,16 @@
|
||||
#include "internal.h"
|
||||
#include "../internal.h"
|
||||
|
||||
|
||||
// Various pre-computed constants.
|
||||
#include "./curve25519_tables.h"
|
||||
|
||||
#if defined(BORINGSSL_CURVE25519_64BIT)
|
||||
#if defined(BORINGSSL_HAS_UINT128)
|
||||
#include "../../third_party/fiat/curve25519_64.h"
|
||||
#elif defined(OPENSSL_64_BIT)
|
||||
#include "../../third_party/fiat/curve25519_64_msvc.h"
|
||||
#else
|
||||
#include "../../third_party/fiat/curve25519_32.h"
|
||||
#endif // BORINGSSL_CURVE25519_64BIT
|
||||
#endif
|
||||
|
||||
|
||||
// Low-level intrinsic operations
|
||||
@@ -64,7 +63,7 @@ static uint64_t load_4(const uint8_t *in) {
|
||||
|
||||
// Field operations.
|
||||
|
||||
#if defined(BORINGSSL_CURVE25519_64BIT)
|
||||
#if defined(OPENSSL_64_BIT)
|
||||
|
||||
typedef uint64_t fe_limb_t;
|
||||
#define FE_NUM_LIMBS 5
|
||||
@@ -144,7 +143,7 @@ typedef uint32_t fe_limb_t;
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#endif // BORINGSSL_CURVE25519_64BIT
|
||||
#endif // OPENSSL_64_BIT
|
||||
|
||||
static_assert(sizeof(fe) == sizeof(fe_limb_t) * FE_NUM_LIMBS,
|
||||
"fe_limb_t[FE_NUM_LIMBS] is inconsistent with fe");
|
||||
@@ -313,11 +312,6 @@ static void fe_copy_lt(fe_loose *h, const fe *f) {
|
||||
static_assert(sizeof(fe_loose) == sizeof(fe), "fe and fe_loose mismatch");
|
||||
OPENSSL_memmove(h, f, sizeof(fe));
|
||||
}
|
||||
#if !defined(OPENSSL_SMALL)
|
||||
static void fe_copy_ll(fe_loose *h, const fe_loose *f) {
|
||||
OPENSSL_memmove(h, f, sizeof(fe_loose));
|
||||
}
|
||||
#endif // !defined(OPENSSL_SMALL)
|
||||
|
||||
static void fe_loose_invert(fe *out, const fe_loose *z) {
|
||||
fe t0;
|
||||
@@ -696,16 +690,6 @@ void x25519_ge_sub(ge_p1p1 *r, const ge_p3 *p, const ge_cached *q) {
|
||||
fe_add(&r->T, &trZ, &trT);
|
||||
}
|
||||
|
||||
static uint8_t equal(signed char b, signed char c) {
|
||||
uint8_t ub = b;
|
||||
uint8_t uc = c;
|
||||
uint8_t x = ub ^ uc; // 0: yes; 1..255: no
|
||||
uint32_t y = x; // 0: yes; 1..255: no
|
||||
y -= 1; // 4294967295: yes; 0..254: no
|
||||
y >>= 31; // 1: yes; 0: no
|
||||
return y;
|
||||
}
|
||||
|
||||
static void cmov(ge_precomp *t, const ge_precomp *u, uint8_t b) {
|
||||
fe_cmov(&t->yplusx, &u->yplusx, b);
|
||||
fe_cmov(&t->yminusx, &u->yminusx, b);
|
||||
@@ -752,7 +736,7 @@ void x25519_ge_scalarmult_small_precomp(
|
||||
ge_precomp_0(&e);
|
||||
|
||||
for (j = 1; j < 16; j++) {
|
||||
cmov(&e, &multiples[j-1], equal(index, j));
|
||||
cmov(&e, &multiples[j-1], 1&constant_time_eq_w(index, j));
|
||||
}
|
||||
|
||||
ge_cached cached;
|
||||
@@ -774,35 +758,36 @@ void x25519_ge_scalarmult_base(ge_p3 *h, const uint8_t a[32]) {
|
||||
|
||||
#else
|
||||
|
||||
static uint8_t negative(signed char b) {
|
||||
uint32_t x = b;
|
||||
x >>= 31; // 1: yes; 0: no
|
||||
return x;
|
||||
}
|
||||
static void table_select(ge_precomp *t, const int pos, const signed char b) {
|
||||
uint8_t bnegative = constant_time_msb_w(b);
|
||||
uint8_t babs = b - ((bnegative & b) << 1);
|
||||
|
||||
uint8_t t_bytes[3][32] = {
|
||||
{constant_time_is_zero_w(b) & 1}, {constant_time_is_zero_w(b) & 1}, {0}};
|
||||
#if defined(__clang__) // materialize for vectorization, 6% speedup
|
||||
__asm__("" : "+m" (t_bytes) : /*no inputs*/);
|
||||
#endif
|
||||
static_assert(sizeof(t_bytes) == sizeof(k25519Precomp[pos][0]), "");
|
||||
for (int i = 0; i < 8; i++) {
|
||||
constant_time_conditional_memxor(t_bytes, k25519Precomp[pos][i],
|
||||
sizeof(t_bytes),
|
||||
constant_time_eq_w(babs, 1 + i));
|
||||
}
|
||||
|
||||
fe yplusx, yminusx, xy2d;
|
||||
fe_frombytes_strict(&yplusx, t_bytes[0]);
|
||||
fe_frombytes_strict(&yminusx, t_bytes[1]);
|
||||
fe_frombytes_strict(&xy2d, t_bytes[2]);
|
||||
|
||||
fe_copy_lt(&t->yplusx, &yplusx);
|
||||
fe_copy_lt(&t->yminusx, &yminusx);
|
||||
fe_copy_lt(&t->xy2d, &xy2d);
|
||||
|
||||
static void table_select(ge_precomp *t, int pos, signed char b) {
|
||||
ge_precomp minust;
|
||||
uint8_t bnegative = negative(b);
|
||||
uint8_t babs = b - ((uint8_t)((-bnegative) & b) << 1);
|
||||
|
||||
ge_precomp_0(t);
|
||||
cmov(t, &k25519Precomp[pos][0], equal(babs, 1));
|
||||
cmov(t, &k25519Precomp[pos][1], equal(babs, 2));
|
||||
cmov(t, &k25519Precomp[pos][2], equal(babs, 3));
|
||||
cmov(t, &k25519Precomp[pos][3], equal(babs, 4));
|
||||
cmov(t, &k25519Precomp[pos][4], equal(babs, 5));
|
||||
cmov(t, &k25519Precomp[pos][5], equal(babs, 6));
|
||||
cmov(t, &k25519Precomp[pos][6], equal(babs, 7));
|
||||
cmov(t, &k25519Precomp[pos][7], equal(babs, 8));
|
||||
fe_copy_ll(&minust.yplusx, &t->yminusx);
|
||||
fe_copy_ll(&minust.yminusx, &t->yplusx);
|
||||
|
||||
// NOTE: the input table is canonical, but types don't encode it
|
||||
fe tmp;
|
||||
fe_carry(&tmp, &t->xy2d);
|
||||
fe_neg(&minust.xy2d, &tmp);
|
||||
|
||||
cmov(t, &minust, bnegative);
|
||||
fe_copy_lt(&minust.yplusx, &yminusx);
|
||||
fe_copy_lt(&minust.yminusx, &yplusx);
|
||||
fe_neg(&minust.xy2d, &xy2d);
|
||||
cmov(t, &minust, bnegative>>7);
|
||||
}
|
||||
|
||||
// h = a * B
|
||||
@@ -812,6 +797,18 @@ static void table_select(ge_precomp *t, int pos, signed char b) {
|
||||
// Preconditions:
|
||||
// a[31] <= 127
|
||||
void x25519_ge_scalarmult_base(ge_p3 *h, const uint8_t a[32]) {
|
||||
#if defined(BORINGSSL_FE25519_ADX)
|
||||
if (CRYPTO_is_BMI1_capable() && CRYPTO_is_BMI2_capable() &&
|
||||
CRYPTO_is_ADX_capable()) {
|
||||
uint8_t t[4][32];
|
||||
x25519_ge_scalarmult_base_adx(t, a);
|
||||
fiat_25519_from_bytes(h->X.v, t[0]);
|
||||
fiat_25519_from_bytes(h->Y.v, t[1]);
|
||||
fiat_25519_from_bytes(h->Z.v, t[2]);
|
||||
fiat_25519_from_bytes(h->T.v, t[3]);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
signed char e[64];
|
||||
signed char carry;
|
||||
ge_p1p1 r;
|
||||
@@ -914,7 +911,7 @@ void x25519_ge_scalarmult(ge_p2 *r, const uint8_t *scalar, const ge_p3 *A) {
|
||||
ge_cached selected;
|
||||
ge_cached_0(&selected);
|
||||
for (j = 0; j < 16; j++) {
|
||||
cmov_cached(&selected, &Ai[j], equal(j, index));
|
||||
cmov_cached(&selected, &Ai[j], 1&constant_time_eq_w(index, j));
|
||||
}
|
||||
|
||||
x25519_ge_add(&t, &u, &selected);
|
||||
@@ -2081,6 +2078,12 @@ static void x25519_scalar_mult(uint8_t out[32], const uint8_t scalar[32],
|
||||
x25519_NEON(out, scalar, point);
|
||||
return;
|
||||
}
|
||||
#elif defined(BORINGSSL_FE25519_ADX)
|
||||
if (CRYPTO_is_BMI1_capable() && CRYPTO_is_BMI2_capable() &&
|
||||
CRYPTO_is_ADX_capable()) {
|
||||
x25519_scalar_mult_adx(out, scalar, point);
|
||||
return;
|
||||
}
|
||||
#endif
|
||||
|
||||
x25519_scalar_mult_generic(out, scalar, point);
|
||||
@@ -2114,7 +2117,8 @@ int X25519(uint8_t out_shared_key[32], const uint8_t private_key[32],
|
||||
static const uint8_t kZeros[32] = {0};
|
||||
x25519_scalar_mult(out_shared_key, private_key, peer_public_value);
|
||||
// The all-zero output results when the input is a point of small order.
|
||||
return CRYPTO_memcmp(kZeros, out_shared_key, 32) != 0;
|
||||
return constant_time_declassify_int(
|
||||
CRYPTO_memcmp(kZeros, out_shared_key, 32)) != 0;
|
||||
}
|
||||
|
||||
void X25519_public_from_private(uint8_t out_public_value[32],
|
||||
@@ -2145,4 +2149,5 @@ void X25519_public_from_private(uint8_t out_public_value[32],
|
||||
fe_loose_invert(&zminusy_inv, &zminusy);
|
||||
fe_mul_tlt(&zminusy_inv, &zplusy, &zminusy_inv);
|
||||
fe_tobytes(out_public_value, &zminusy_inv);
|
||||
CONSTTIME_DECLASSIFY(out_public_value, 32);
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
/* Copyright (c) 2023, 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 "internal.h"
|
||||
#if defined(BORINGSSL_FE25519_ADX)
|
||||
#include "../../third_party/fiat/curve25519_64_adx.h"
|
||||
#endif
|
||||
File diff suppressed because it is too large.
Load diff
@@ -15,14 +15,13 @@
|
||||
#ifndef OPENSSL_HEADER_CURVE25519_INTERNAL_H
|
||||
#define OPENSSL_HEADER_CURVE25519_INTERNAL_H
|
||||
|
||||
#if defined(__cplusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <CCryptoBoringSSL_base.h>
|
||||
#include <CCryptoBoringSSL_curve25519.h>
|
||||
|
||||
#include "../internal.h"
|
||||
|
||||
#if defined(__cplusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#if defined(OPENSSL_ARM) && !defined(OPENSSL_NO_ASM) && !defined(OPENSSL_APPLE)
|
||||
#define BORINGSSL_X25519_NEON
|
||||
@@ -32,11 +31,28 @@ void x25519_NEON(uint8_t out[32], const uint8_t scalar[32],
|
||||
const uint8_t point[32]);
|
||||
#endif
|
||||
|
||||
#if defined(BORINGSSL_HAS_UINT128)
|
||||
#define BORINGSSL_CURVE25519_64BIT
|
||||
#if !defined(OPENSSL_NO_ASM) && !defined(OPENSSL_SMALL) && \
|
||||
defined(__GNUC__) && defined(__x86_64__)
|
||||
#define BORINGSSL_FE25519_ADX
|
||||
|
||||
// fiat_curve25519_adx_mul is defined in
|
||||
// third_party/fiat/asm/fiat_curve25519_adx_mul.S
|
||||
void __attribute__((sysv_abi))
|
||||
fiat_curve25519_adx_mul(uint64_t out[4], const uint64_t in1[4],
|
||||
const uint64_t in2[4]);
|
||||
|
||||
// fiat_curve25519_adx_square is defined in
|
||||
// third_party/fiat/asm/fiat_curve25519_adx_square.S
|
||||
void __attribute__((sysv_abi))
|
||||
fiat_curve25519_adx_square(uint64_t out[4], const uint64_t in[4]);
|
||||
|
||||
// x25519_scalar_mult_adx is defined in third_party/fiat/curve25519_64_adx.h
|
||||
void x25519_scalar_mult_adx(uint8_t out[32], const uint8_t scalar[32],
|
||||
const uint8_t point[32]);
|
||||
void x25519_ge_scalarmult_base_adx(uint8_t h[4][32], const uint8_t a[32]);
|
||||
#endif
|
||||
|
||||
#if defined(BORINGSSL_CURVE25519_64BIT)
|
||||
#if defined(OPENSSL_64_BIT)
|
||||
// fe means field element. Here the field is \Z/(2^255-19). An element t,
|
||||
// entries t[0]...t[4], represents the integer t[0]+2^51 t[1]+2^102 t[2]+2^153
|
||||
// t[3]+2^204 t[4].
|
||||
@@ -139,6 +155,8 @@ struct spake2_ctx_st {
|
||||
};
|
||||
|
||||
|
||||
extern const uint8_t k25519Precomp[32][8][3][32];
|
||||
|
||||
#if defined(__cplusplus)
|
||||
} // extern C
|
||||
#endif
|
||||
|
||||
@@ -202,6 +202,10 @@ int DSA_set0_pqg(DSA *dsa, BIGNUM *p, BIGNUM *q, BIGNUM *g) {
|
||||
dsa->g = g;
|
||||
}
|
||||
|
||||
BN_MONT_CTX_free(dsa->method_mont_p);
|
||||
dsa->method_mont_p = NULL;
|
||||
BN_MONT_CTX_free(dsa->method_mont_q);
|
||||
dsa->method_mont_q = NULL;
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
@@ -17,11 +17,31 @@
|
||||
|
||||
#include <CCryptoBoringSSL_dsa.h>
|
||||
|
||||
#include <CCryptoBoringSSL_thread.h>
|
||||
|
||||
#include "../internal.h"
|
||||
|
||||
#if defined(__cplusplus)
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
||||
struct dsa_st {
|
||||
BIGNUM *p;
|
||||
BIGNUM *q;
|
||||
BIGNUM *g;
|
||||
|
||||
BIGNUM *pub_key;
|
||||
BIGNUM *priv_key;
|
||||
|
||||
// Normally used to cache montgomery values
|
||||
CRYPTO_MUTEX method_mont_lock;
|
||||
BN_MONT_CTX *method_mont_p;
|
||||
BN_MONT_CTX *method_mont_q;
|
||||
CRYPTO_refcount_t references;
|
||||
CRYPTO_EX_DATA ex_data;
|
||||
};
|
||||
|
||||
// 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);
|
||||
|
||||
@@ -72,6 +72,16 @@ static const CBS_ASN1_TAG kParametersTag =
|
||||
static const CBS_ASN1_TAG kPublicKeyTag =
|
||||
CBS_ASN1_CONSTRUCTED | CBS_ASN1_CONTEXT_SPECIFIC | 1;
|
||||
|
||||
// TODO(https://crbug.com/boringssl/497): Allow parsers to specify a list of
|
||||
// acceptable groups, so parsers don't have to pull in all four.
|
||||
typedef const EC_GROUP *(*ec_group_func)(void);
|
||||
static const ec_group_func kAllGroups[] = {
|
||||
&EC_group_p224,
|
||||
&EC_group_p256,
|
||||
&EC_group_p384,
|
||||
&EC_group_p521,
|
||||
};
|
||||
|
||||
EC_KEY *EC_KEY_parse_private_key(CBS *cbs, const EC_GROUP *group) {
|
||||
CBS ec_private_key, private_key;
|
||||
uint64_t version;
|
||||
@@ -84,7 +94,6 @@ EC_KEY *EC_KEY_parse_private_key(CBS *cbs, const EC_GROUP *group) {
|
||||
}
|
||||
|
||||
// Parse the optional parameters field.
|
||||
EC_GROUP *inner_group = NULL;
|
||||
EC_KEY *ret = NULL;
|
||||
BIGNUM *priv_key = NULL;
|
||||
if (CBS_peek_asn1_tag(&ec_private_key, kParametersTag)) {
|
||||
@@ -97,7 +106,7 @@ EC_KEY *EC_KEY_parse_private_key(CBS *cbs, const EC_GROUP *group) {
|
||||
OPENSSL_PUT_ERROR(EC, EC_R_DECODE_ERROR);
|
||||
goto err;
|
||||
}
|
||||
inner_group = EC_KEY_parse_parameters(&child);
|
||||
const EC_GROUP *inner_group = EC_KEY_parse_parameters(&child);
|
||||
if (inner_group == NULL) {
|
||||
goto err;
|
||||
}
|
||||
@@ -179,13 +188,11 @@ EC_KEY *EC_KEY_parse_private_key(CBS *cbs, const EC_GROUP *group) {
|
||||
}
|
||||
|
||||
BN_free(priv_key);
|
||||
EC_GROUP_free(inner_group);
|
||||
return ret;
|
||||
|
||||
err:
|
||||
EC_KEY_free(ret);
|
||||
BN_free(priv_key);
|
||||
EC_GROUP_free(inner_group);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@@ -244,9 +251,12 @@ int EC_KEY_marshal_private_key(CBB *cbb, const EC_KEY *key,
|
||||
// kPrimeFieldOID is the encoding of 1.2.840.10045.1.1.
|
||||
static const uint8_t kPrimeField[] = {0x2a, 0x86, 0x48, 0xce, 0x3d, 0x01, 0x01};
|
||||
|
||||
static int parse_explicit_prime_curve(CBS *in, CBS *out_prime, CBS *out_a,
|
||||
CBS *out_b, CBS *out_base_x,
|
||||
CBS *out_base_y, CBS *out_order) {
|
||||
struct explicit_prime_curve {
|
||||
CBS prime, a, b, base_x, base_y, order;
|
||||
};
|
||||
|
||||
static int parse_explicit_prime_curve(CBS *in,
|
||||
struct explicit_prime_curve *out) {
|
||||
// See RFC 3279, section 2.3.5. Note that RFC 3279 calls this structure an
|
||||
// ECParameters while RFC 5480 calls it a SpecifiedECDomain.
|
||||
CBS params, field_id, field_type, curve, base, cofactor;
|
||||
@@ -260,18 +270,18 @@ static int parse_explicit_prime_curve(CBS *in, CBS *out_prime, CBS *out_a,
|
||||
CBS_len(&field_type) != sizeof(kPrimeField) ||
|
||||
OPENSSL_memcmp(CBS_data(&field_type), kPrimeField, sizeof(kPrimeField)) !=
|
||||
0 ||
|
||||
!CBS_get_asn1(&field_id, out_prime, CBS_ASN1_INTEGER) ||
|
||||
!CBS_is_unsigned_asn1_integer(out_prime) ||
|
||||
!CBS_get_asn1(&field_id, &out->prime, CBS_ASN1_INTEGER) ||
|
||||
!CBS_is_unsigned_asn1_integer(&out->prime) ||
|
||||
CBS_len(&field_id) != 0 ||
|
||||
!CBS_get_asn1(¶ms, &curve, CBS_ASN1_SEQUENCE) ||
|
||||
!CBS_get_asn1(&curve, out_a, CBS_ASN1_OCTETSTRING) ||
|
||||
!CBS_get_asn1(&curve, out_b, CBS_ASN1_OCTETSTRING) ||
|
||||
!CBS_get_asn1(&curve, &out->a, CBS_ASN1_OCTETSTRING) ||
|
||||
!CBS_get_asn1(&curve, &out->b, CBS_ASN1_OCTETSTRING) ||
|
||||
// |curve| has an optional BIT STRING seed which we ignore.
|
||||
!CBS_get_optional_asn1(&curve, NULL, NULL, CBS_ASN1_BITSTRING) ||
|
||||
CBS_len(&curve) != 0 ||
|
||||
!CBS_get_asn1(¶ms, &base, CBS_ASN1_OCTETSTRING) ||
|
||||
!CBS_get_asn1(¶ms, out_order, CBS_ASN1_INTEGER) ||
|
||||
!CBS_is_unsigned_asn1_integer(out_order) ||
|
||||
!CBS_get_asn1(¶ms, &out->order, CBS_ASN1_INTEGER) ||
|
||||
!CBS_is_unsigned_asn1_integer(&out->order) ||
|
||||
!CBS_get_optional_asn1(¶ms, &cofactor, &has_cofactor,
|
||||
CBS_ASN1_INTEGER) ||
|
||||
CBS_len(¶ms) != 0) {
|
||||
@@ -300,25 +310,33 @@ static int parse_explicit_prime_curve(CBS *in, CBS *out_prime, CBS *out_a,
|
||||
return 0;
|
||||
}
|
||||
size_t field_len = CBS_len(&base) / 2;
|
||||
CBS_init(out_base_x, CBS_data(&base), field_len);
|
||||
CBS_init(out_base_y, CBS_data(&base) + field_len, field_len);
|
||||
CBS_init(&out->base_x, CBS_data(&base), field_len);
|
||||
CBS_init(&out->base_y, CBS_data(&base) + field_len, field_len);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
// integers_equal returns one if |a| and |b| are equal, up to leading zeros, and
|
||||
// integers_equal returns one if |bytes| is a big-endian encoding of |bn|, and
|
||||
// zero otherwise.
|
||||
static int integers_equal(const CBS *a, const uint8_t *b, size_t b_len) {
|
||||
// Remove leading zeros from |a| and |b|.
|
||||
CBS a_copy = *a;
|
||||
while (CBS_len(&a_copy) > 0 && CBS_data(&a_copy)[0] == 0) {
|
||||
CBS_skip(&a_copy, 1);
|
||||
static int integers_equal(const CBS *bytes, const BIGNUM *bn) {
|
||||
// Although, in SEC 1, Field-Element-to-Octet-String has a fixed width,
|
||||
// OpenSSL mis-encodes the |a| and |b|, so we tolerate any number of leading
|
||||
// zeros. (This matters for P-521 whose |b| has a leading 0.)
|
||||
CBS copy = *bytes;
|
||||
while (CBS_len(©) > 0 && CBS_data(©)[0] == 0) {
|
||||
CBS_skip(©, 1);
|
||||
}
|
||||
while (b_len > 0 && b[0] == 0) {
|
||||
b++;
|
||||
b_len--;
|
||||
|
||||
if (CBS_len(©) > EC_MAX_BYTES) {
|
||||
return 0;
|
||||
}
|
||||
return CBS_mem_equal(&a_copy, b, b_len);
|
||||
uint8_t buf[EC_MAX_BYTES];
|
||||
if (!BN_bn2bin_padded(buf, CBS_len(©), bn)) {
|
||||
ERR_clear_error();
|
||||
return 0;
|
||||
}
|
||||
|
||||
return CBS_mem_equal(©, buf, CBS_len(©));
|
||||
}
|
||||
|
||||
EC_GROUP *EC_KEY_parse_curve_name(CBS *cbs) {
|
||||
@@ -329,13 +347,10 @@ EC_GROUP *EC_KEY_parse_curve_name(CBS *cbs) {
|
||||
}
|
||||
|
||||
// Look for a matching curve.
|
||||
const struct built_in_curves *const curves = OPENSSL_built_in_curves();
|
||||
for (size_t i = 0; i < OPENSSL_NUM_BUILT_IN_CURVES; i++) {
|
||||
const struct built_in_curve *curve = &curves->curves[i];
|
||||
if (CBS_len(&named_curve) == curve->oid_len &&
|
||||
OPENSSL_memcmp(CBS_data(&named_curve), curve->oid, curve->oid_len) ==
|
||||
0) {
|
||||
return EC_GROUP_new_by_curve_name(curve->nid);
|
||||
for (size_t i = 0; i < OPENSSL_ARRAY_SIZE(kAllGroups); i++) {
|
||||
const EC_GROUP *group = kAllGroups[i]();
|
||||
if (CBS_mem_equal(&named_curve, group->oid, group->oid_len)) {
|
||||
return (EC_GROUP *)group;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -344,25 +359,15 @@ EC_GROUP *EC_KEY_parse_curve_name(CBS *cbs) {
|
||||
}
|
||||
|
||||
int EC_KEY_marshal_curve_name(CBB *cbb, const EC_GROUP *group) {
|
||||
int nid = EC_GROUP_get_curve_name(group);
|
||||
if (nid == NID_undef) {
|
||||
if (group->oid_len == 0) {
|
||||
OPENSSL_PUT_ERROR(EC, EC_R_UNKNOWN_GROUP);
|
||||
return 0;
|
||||
}
|
||||
|
||||
const struct built_in_curves *const curves = OPENSSL_built_in_curves();
|
||||
for (size_t i = 0; i < OPENSSL_NUM_BUILT_IN_CURVES; i++) {
|
||||
const struct built_in_curve *curve = &curves->curves[i];
|
||||
if (curve->nid == nid) {
|
||||
CBB child;
|
||||
return CBB_add_asn1(cbb, &child, CBS_ASN1_OBJECT) &&
|
||||
CBB_add_bytes(&child, curve->oid, curve->oid_len) &&
|
||||
CBB_flush(cbb);
|
||||
}
|
||||
}
|
||||
|
||||
OPENSSL_PUT_ERROR(EC, EC_R_UNKNOWN_GROUP);
|
||||
return 0;
|
||||
CBB child;
|
||||
return CBB_add_asn1(cbb, &child, CBS_ASN1_OBJECT) &&
|
||||
CBB_add_bytes(&child, group->oid, group->oid_len) && //
|
||||
CBB_flush(cbb);
|
||||
}
|
||||
|
||||
EC_GROUP *EC_KEY_parse_parameters(CBS *cbs) {
|
||||
@@ -374,34 +379,56 @@ EC_GROUP *EC_KEY_parse_parameters(CBS *cbs) {
|
||||
// of named curves.
|
||||
//
|
||||
// TODO(davidben): Remove support for this.
|
||||
CBS prime, a, b, base_x, base_y, order;
|
||||
if (!parse_explicit_prime_curve(cbs, &prime, &a, &b, &base_x, &base_y,
|
||||
&order)) {
|
||||
struct explicit_prime_curve curve;
|
||||
if (!parse_explicit_prime_curve(cbs, &curve)) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Look for a matching prime curve.
|
||||
const struct built_in_curves *const curves = OPENSSL_built_in_curves();
|
||||
for (size_t i = 0; i < OPENSSL_NUM_BUILT_IN_CURVES; i++) {
|
||||
const struct built_in_curve *curve = &curves->curves[i];
|
||||
const unsigned param_len = curve->param_len;
|
||||
// |curve->params| is ordered p, a, b, x, y, order, each component
|
||||
// zero-padded up to the field length. Although SEC 1 states that the
|
||||
// Field-Element-to-Octet-String conversion also pads, OpenSSL mis-encodes
|
||||
// |a| and |b|, so this comparison must allow omitting leading zeros. (This
|
||||
// is relevant for P-521 whose |b| has a leading 0.)
|
||||
if (integers_equal(&prime, curve->params, param_len) &&
|
||||
integers_equal(&a, curve->params + param_len, param_len) &&
|
||||
integers_equal(&b, curve->params + param_len * 2, param_len) &&
|
||||
integers_equal(&base_x, curve->params + param_len * 3, param_len) &&
|
||||
integers_equal(&base_y, curve->params + param_len * 4, param_len) &&
|
||||
integers_equal(&order, curve->params + param_len * 5, param_len)) {
|
||||
return EC_GROUP_new_by_curve_name(curve->nid);
|
||||
}
|
||||
const EC_GROUP *ret = NULL;
|
||||
BIGNUM *p = BN_new(), *a = BN_new(), *b = BN_new(), *x = BN_new(),
|
||||
*y = BN_new();
|
||||
if (p == NULL || a == NULL || b == NULL || x == NULL || y == NULL) {
|
||||
goto err;
|
||||
}
|
||||
|
||||
OPENSSL_PUT_ERROR(EC, EC_R_UNKNOWN_GROUP);
|
||||
return NULL;
|
||||
for (size_t i = 0; i < OPENSSL_ARRAY_SIZE(kAllGroups); i++) {
|
||||
const EC_GROUP *group = kAllGroups[i]();
|
||||
if (!integers_equal(&curve.order, EC_GROUP_get0_order(group))) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// The order alone uniquely identifies the group, but we check the other
|
||||
// parameters to avoid misinterpreting the group.
|
||||
if (!EC_GROUP_get_curve_GFp(group, p, a, b, NULL)) {
|
||||
goto err;
|
||||
}
|
||||
if (!integers_equal(&curve.prime, p) || !integers_equal(&curve.a, a) ||
|
||||
!integers_equal(&curve.b, b)) {
|
||||
break;
|
||||
}
|
||||
if (!EC_POINT_get_affine_coordinates_GFp(
|
||||
group, EC_GROUP_get0_generator(group), x, y, NULL)) {
|
||||
goto err;
|
||||
}
|
||||
if (!integers_equal(&curve.base_x, x) ||
|
||||
!integers_equal(&curve.base_y, y)) {
|
||||
break;
|
||||
}
|
||||
ret = group;
|
||||
break;
|
||||
}
|
||||
|
||||
if (ret == NULL) {
|
||||
OPENSSL_PUT_ERROR(EC, EC_R_UNKNOWN_GROUP);
|
||||
}
|
||||
|
||||
err:
|
||||
BN_free(p);
|
||||
BN_free(a);
|
||||
BN_free(b);
|
||||
BN_free(x);
|
||||
BN_free(y);
|
||||
return (EC_GROUP *)ret;
|
||||
}
|
||||
|
||||
int EC_POINT_point2cbb(CBB *out, const EC_GROUP *group, const EC_POINT *point,
|
||||
@@ -458,18 +485,16 @@ EC_KEY *d2i_ECParameters(EC_KEY **out_key, const uint8_t **inp, long len) {
|
||||
|
||||
CBS cbs;
|
||||
CBS_init(&cbs, *inp, (size_t)len);
|
||||
EC_GROUP *group = EC_KEY_parse_parameters(&cbs);
|
||||
const EC_GROUP *group = EC_KEY_parse_parameters(&cbs);
|
||||
if (group == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
EC_KEY *ret = EC_KEY_new();
|
||||
if (ret == NULL || !EC_KEY_set_group(ret, group)) {
|
||||
EC_GROUP_free(group);
|
||||
EC_KEY_free(ret);
|
||||
return NULL;
|
||||
}
|
||||
EC_GROUP_free(group);
|
||||
|
||||
if (out_key != NULL) {
|
||||
EC_KEY_free(*out_key);
|
||||
@@ -532,3 +557,16 @@ int i2o_ECPublicKey(const EC_KEY *key, uint8_t **outp) {
|
||||
// Historically, this function used the wrong return value on error.
|
||||
return ret > 0 ? ret : 0;
|
||||
}
|
||||
|
||||
size_t EC_get_builtin_curves(EC_builtin_curve *out_curves,
|
||||
size_t max_num_curves) {
|
||||
if (max_num_curves > OPENSSL_ARRAY_SIZE(kAllGroups)) {
|
||||
max_num_curves = OPENSSL_ARRAY_SIZE(kAllGroups);
|
||||
}
|
||||
for (size_t i = 0; i < max_num_curves; i++) {
|
||||
const EC_GROUP *group = kAllGroups[i]();
|
||||
out_curves[i].nid = group->curve_name;
|
||||
out_curves[i].comment = group->comment;
|
||||
}
|
||||
return OPENSSL_ARRAY_SIZE(kAllGroups);
|
||||
}
|
||||
@@ -55,7 +55,8 @@ EC_KEY *EC_KEY_derive_from_secret(const EC_GROUP *group, const uint8_t *secret,
|
||||
}
|
||||
|
||||
uint8_t derived[EC_KEY_DERIVE_EXTRA_BYTES + EC_MAX_BYTES];
|
||||
size_t derived_len = BN_num_bytes(&group->order) + EC_KEY_DERIVE_EXTRA_BYTES;
|
||||
size_t derived_len =
|
||||
BN_num_bytes(EC_GROUP_get0_order(group)) + EC_KEY_DERIVE_EXTRA_BYTES;
|
||||
assert(derived_len <= sizeof(derived));
|
||||
if (!HKDF(derived, derived_len, EVP_sha256(), secret, secret_len,
|
||||
/*salt=*/NULL, /*salt_len=*/0, (const uint8_t *)info,
|
||||
@@ -74,10 +75,10 @@ EC_KEY *EC_KEY_derive_from_secret(const EC_GROUP *group, const uint8_t *secret,
|
||||
// enough. 2^(num_bytes(order)) < 2^8 * order, so:
|
||||
//
|
||||
// priv < 2^8 * order * 2^128 < order * order < order * R
|
||||
!BN_from_montgomery(priv, priv, group->order_mont, ctx) ||
|
||||
!BN_from_montgomery(priv, priv, &group->order, ctx) ||
|
||||
// Multiply by R^2 and do another Montgomery reduction to compute
|
||||
// priv * R^-1 * R^2 * R^-1 = priv mod order.
|
||||
!BN_to_montgomery(priv, priv, group->order_mont, ctx) ||
|
||||
!BN_to_montgomery(priv, priv, &group->order, ctx) ||
|
||||
!EC_POINT_mul(group, pub, priv, NULL, NULL, ctx) ||
|
||||
!EC_KEY_set_group(key, group) || !EC_KEY_set_public_key(key, pub) ||
|
||||
!EC_KEY_set_private_key(key, priv)) {
|
||||
|
||||
@@ -179,12 +179,12 @@ static int hash_to_field2(const EC_GROUP *group, const EVP_MD *md,
|
||||
size_t msg_len) {
|
||||
size_t L;
|
||||
uint8_t buf[4 * EC_MAX_BYTES];
|
||||
if (!num_bytes_to_derive(&L, &group->field, k) ||
|
||||
if (!num_bytes_to_derive(&L, &group->field.N, k) ||
|
||||
!expand_message_xmd(md, buf, 2 * L, msg, msg_len, dst, dst_len)) {
|
||||
return 0;
|
||||
}
|
||||
BN_ULONG words[2 * EC_MAX_WORDS];
|
||||
size_t num_words = 2 * group->field.width;
|
||||
size_t num_words = 2 * group->field.N.width;
|
||||
big_endian_to_words(words, num_words, buf, L);
|
||||
group->meth->felem_reduce(group, out1, words, num_words);
|
||||
big_endian_to_words(words, num_words, buf + L, L);
|
||||
@@ -197,15 +197,16 @@ static int hash_to_field2(const EC_GROUP *group, const EVP_MD *md,
|
||||
static int hash_to_scalar(const EC_GROUP *group, const EVP_MD *md,
|
||||
EC_SCALAR *out, const uint8_t *dst, size_t dst_len,
|
||||
unsigned k, const uint8_t *msg, size_t msg_len) {
|
||||
const BIGNUM *order = EC_GROUP_get0_order(group);
|
||||
size_t L;
|
||||
uint8_t buf[EC_MAX_BYTES * 2];
|
||||
if (!num_bytes_to_derive(&L, &group->order, k) ||
|
||||
if (!num_bytes_to_derive(&L, order, k) ||
|
||||
!expand_message_xmd(md, buf, L, msg, msg_len, dst, dst_len)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
BN_ULONG words[2 * EC_MAX_WORDS];
|
||||
size_t num_words = 2 * group->order.width;
|
||||
size_t num_words = 2 * order->width;
|
||||
big_endian_to_words(words, num_words, buf, L);
|
||||
ec_scalar_reduce(group, out, words, num_words);
|
||||
return 1;
|
||||
@@ -230,7 +231,7 @@ static BN_ULONG sgn0(const EC_GROUP *group, const EC_FELEM *a) {
|
||||
}
|
||||
|
||||
OPENSSL_UNUSED static int is_3mod4(const EC_GROUP *group) {
|
||||
return group->field.width > 0 && (group->field.d[0] & 3) == 3;
|
||||
return group->field.N.width > 0 && (group->field.N.d[0] & 3) == 3;
|
||||
}
|
||||
|
||||
// sqrt_ratio_3mod4 implements the operation described in appendix F.2.1.2
|
||||
@@ -273,7 +274,7 @@ static BN_ULONG sqrt_ratio_3mod4(const EC_GROUP *group, const EC_FELEM *Z,
|
||||
// in appendix F.2.
|
||||
static void map_to_curve_simple_swu(const EC_GROUP *group, const EC_FELEM *Z,
|
||||
const BN_ULONG *c1, size_t num_c1,
|
||||
const EC_FELEM *c2, EC_RAW_POINT *out,
|
||||
const EC_FELEM *c2, EC_JACOBIAN *out,
|
||||
const EC_FELEM *u) {
|
||||
// This function requires the prime be 3 mod 4, and that A = -3.
|
||||
assert(is_3mod4(group));
|
||||
@@ -285,12 +286,12 @@ static void map_to_curve_simple_swu(const EC_GROUP *group, const EC_FELEM *Z,
|
||||
group->meth->felem_sqr;
|
||||
|
||||
EC_FELEM tv1, tv2, tv3, tv4, tv5, tv6, x, y, y1;
|
||||
felem_sqr(group, &tv1, u); // 1. tv1 = u^2
|
||||
felem_mul(group, &tv1, Z, &tv1); // 2. tv1 = Z * tv1
|
||||
felem_sqr(group, &tv2, &tv1); // 3. tv2 = tv1^2
|
||||
ec_felem_add(group, &tv2, &tv2, &tv1); // 4. tv2 = tv2 + tv1
|
||||
ec_felem_add(group, &tv3, &tv2, &group->one); // 5. tv3 = tv2 + 1
|
||||
felem_mul(group, &tv3, &group->b, &tv3); // 6. tv3 = B * tv3
|
||||
felem_sqr(group, &tv1, u); // 1. tv1 = u^2
|
||||
felem_mul(group, &tv1, Z, &tv1); // 2. tv1 = Z * tv1
|
||||
felem_sqr(group, &tv2, &tv1); // 3. tv2 = tv1^2
|
||||
ec_felem_add(group, &tv2, &tv2, &tv1); // 4. tv2 = tv2 + tv1
|
||||
ec_felem_add(group, &tv3, &tv2, ec_felem_one(group)); // 5. tv3 = tv2 + 1
|
||||
felem_mul(group, &tv3, &group->b, &tv3); // 6. tv3 = B * tv3
|
||||
|
||||
// 7. tv4 = CMOV(Z, -tv2, tv2 != 0)
|
||||
const BN_ULONG tv2_non_zero = ec_felem_non_zero_mask(group, &tv2);
|
||||
@@ -344,7 +345,7 @@ static void map_to_curve_simple_swu(const EC_GROUP *group, const EC_FELEM *Z,
|
||||
|
||||
static int hash_to_curve(const EC_GROUP *group, const EVP_MD *md,
|
||||
const EC_FELEM *Z, const EC_FELEM *c2, unsigned k,
|
||||
EC_RAW_POINT *out, const uint8_t *dst, size_t dst_len,
|
||||
EC_JACOBIAN *out, const uint8_t *dst, size_t dst_len,
|
||||
const uint8_t *msg, size_t msg_len) {
|
||||
EC_FELEM u0, u1;
|
||||
if (!hash_to_field2(group, md, &u0, &u1, dst, dst_len, k, msg, msg_len)) {
|
||||
@@ -353,13 +354,13 @@ static int hash_to_curve(const EC_GROUP *group, const EVP_MD *md,
|
||||
|
||||
// Compute |c1| = (p - 3) / 4.
|
||||
BN_ULONG c1[EC_MAX_WORDS];
|
||||
size_t num_c1 = group->field.width;
|
||||
if (!bn_copy_words(c1, num_c1, &group->field)) {
|
||||
size_t num_c1 = group->field.N.width;
|
||||
if (!bn_copy_words(c1, num_c1, &group->field.N)) {
|
||||
return 0;
|
||||
}
|
||||
bn_rshift_words(c1, c1, /*shift=*/2, /*num=*/num_c1);
|
||||
|
||||
EC_RAW_POINT Q0, Q1;
|
||||
EC_JACOBIAN Q0, Q1;
|
||||
map_to_curve_simple_swu(group, Z, c1, num_c1, c2, &Q0, &u0);
|
||||
map_to_curve_simple_swu(group, Z, c1, num_c1, c2, &Q1, &u1);
|
||||
|
||||
@@ -370,7 +371,7 @@ static int hash_to_curve(const EC_GROUP *group, const EVP_MD *md,
|
||||
|
||||
static int felem_from_u8(const EC_GROUP *group, EC_FELEM *out, uint8_t a) {
|
||||
uint8_t bytes[EC_MAX_BYTES] = {0};
|
||||
size_t len = BN_num_bytes(&group->field);
|
||||
size_t len = BN_num_bytes(&group->field.N);
|
||||
bytes[len - 1] = a;
|
||||
return ec_felem_from_bytes(group, out, bytes, len);
|
||||
}
|
||||
@@ -401,7 +402,7 @@ static const uint8_t kP384Sqrt12[] = {
|
||||
0xa8, 0x0f, 0x7e, 0x19, 0x14, 0xe2, 0xec, 0x69, 0xf5, 0xa6, 0x26, 0xb3};
|
||||
|
||||
int ec_hash_to_curve_p256_xmd_sha256_sswu(const EC_GROUP *group,
|
||||
EC_RAW_POINT *out, const uint8_t *dst,
|
||||
EC_JACOBIAN *out, const uint8_t *dst,
|
||||
size_t dst_len, const uint8_t *msg,
|
||||
size_t msg_len) {
|
||||
// See section 8.3 of draft-irtf-cfrg-hash-to-curve-16.
|
||||
@@ -434,7 +435,7 @@ int EC_hash_to_curve_p256_xmd_sha256_sswu(const EC_GROUP *group, EC_POINT *out,
|
||||
}
|
||||
|
||||
int ec_hash_to_curve_p384_xmd_sha384_sswu(const EC_GROUP *group,
|
||||
EC_RAW_POINT *out, const uint8_t *dst,
|
||||
EC_JACOBIAN *out, const uint8_t *dst,
|
||||
size_t dst_len, const uint8_t *msg,
|
||||
size_t msg_len) {
|
||||
// See section 8.3 of draft-irtf-cfrg-hash-to-curve-16.
|
||||
@@ -479,7 +480,7 @@ int ec_hash_to_scalar_p384_xmd_sha384(
|
||||
}
|
||||
|
||||
int ec_hash_to_curve_p384_xmd_sha512_sswu_draft07(
|
||||
const EC_GROUP *group, EC_RAW_POINT *out, const uint8_t *dst,
|
||||
const EC_GROUP *group, EC_JACOBIAN *out, const uint8_t *dst,
|
||||
size_t dst_len, const uint8_t *msg, size_t msg_len) {
|
||||
// See section 8.3 of draft-irtf-cfrg-hash-to-curve-07.
|
||||
if (EC_GROUP_get_curve_name(group) != NID_secp384r1) {
|
||||
|
||||
@@ -26,23 +26,23 @@ extern "C" {
|
||||
|
||||
// Hash-to-curve.
|
||||
//
|
||||
// Internal |EC_RAW_POINT| versions of the corresponding public APIs.
|
||||
// Internal |EC_JACOBIAN| versions of the corresponding public APIs.
|
||||
|
||||
// ec_hash_to_curve_p256_xmd_sha256_sswu hashes |msg| to a point on |group| and
|
||||
// writes the result to |out|, implementing the P256_XMD:SHA-256_SSWU_RO_ suite
|
||||
// from draft-irtf-cfrg-hash-to-curve-16. It returns one on success and zero on
|
||||
// error.
|
||||
OPENSSL_EXPORT int ec_hash_to_curve_p256_xmd_sha256_sswu(
|
||||
const EC_GROUP *group, EC_RAW_POINT *out, const uint8_t *dst,
|
||||
size_t dst_len, const uint8_t *msg, size_t msg_len);
|
||||
const EC_GROUP *group, EC_JACOBIAN *out, const uint8_t *dst, size_t dst_len,
|
||||
const uint8_t *msg, size_t msg_len);
|
||||
|
||||
// ec_hash_to_curve_p384_xmd_sha384_sswu hashes |msg| to a point on |group| and
|
||||
// writes the result to |out|, implementing the P384_XMD:SHA-384_SSWU_RO_ suite
|
||||
// from draft-irtf-cfrg-hash-to-curve-16. It returns one on success and zero on
|
||||
// error.
|
||||
OPENSSL_EXPORT int ec_hash_to_curve_p384_xmd_sha384_sswu(
|
||||
const EC_GROUP *group, EC_RAW_POINT *out, const uint8_t *dst,
|
||||
size_t dst_len, const uint8_t *msg, size_t msg_len);
|
||||
const EC_GROUP *group, EC_JACOBIAN *out, const uint8_t *dst, size_t dst_len,
|
||||
const uint8_t *msg, size_t msg_len);
|
||||
|
||||
// ec_hash_to_scalar_p384_xmd_sha384 hashes |msg| to a scalar on |group|
|
||||
// and writes the result to |out|, using the hash_to_field operation from the
|
||||
@@ -59,8 +59,8 @@ OPENSSL_EXPORT int ec_hash_to_scalar_p384_xmd_sha384(
|
||||
//
|
||||
// TODO(https://crbug.com/1414562): Migrate this to the final version.
|
||||
OPENSSL_EXPORT int ec_hash_to_curve_p384_xmd_sha512_sswu_draft07(
|
||||
const EC_GROUP *group, EC_RAW_POINT *out, const uint8_t *dst,
|
||||
size_t dst_len, const uint8_t *msg, size_t msg_len);
|
||||
const EC_GROUP *group, EC_JACOBIAN *out, const uint8_t *dst, size_t dst_len,
|
||||
const uint8_t *msg, size_t msg_len);
|
||||
|
||||
// ec_hash_to_scalar_p384_xmd_sha512_draft07 hashes |msg| to a scalar on |group|
|
||||
// and writes the result to |out|, using the hash_to_field operation from the
|
||||
|
||||
@@ -92,7 +92,7 @@ int ECDH_compute_key(void *out, size_t out_len, const EC_POINT *pub_key,
|
||||
return -1;
|
||||
}
|
||||
|
||||
EC_RAW_POINT shared_point;
|
||||
EC_JACOBIAN shared_point;
|
||||
uint8_t buf[EC_MAX_BYTES];
|
||||
size_t buf_len;
|
||||
if (!ec_point_mul_scalar(group, &shared_point, &pub_key->raw, priv) ||
|
||||
|
||||
@@ -146,13 +146,13 @@ struct err_error_st {
|
||||
|
||||
// ERR_STATE contains the per-thread, error queue.
|
||||
typedef struct err_state_st {
|
||||
// errors contains the ERR_NUM_ERRORS most recent errors, organised as a ring
|
||||
// buffer.
|
||||
// errors contains up to ERR_NUM_ERRORS - 1 most recent errors, organised as a
|
||||
// ring buffer.
|
||||
struct err_error_st errors[ERR_NUM_ERRORS];
|
||||
// top contains the index one past the most recent error. If |top| equals
|
||||
// |bottom| then the queue is empty.
|
||||
// top contains the index of the most recent error. If |top| equals |bottom|
|
||||
// then the queue is empty.
|
||||
unsigned top;
|
||||
// bottom contains the index of the last error in the queue.
|
||||
// bottom contains the index before the least recent error in the queue.
|
||||
unsigned bottom;
|
||||
|
||||
// to_free, if not NULL, contains a pointer owned by this structure that was
|
||||
@@ -192,8 +192,7 @@ static int global_next_library = ERR_NUM_LIBS;
|
||||
|
||||
// global_next_library_mutex protects |global_next_library| from concurrent
|
||||
// updates.
|
||||
static struct CRYPTO_STATIC_MUTEX global_next_library_mutex =
|
||||
CRYPTO_STATIC_MUTEX_INIT;
|
||||
static CRYPTO_MUTEX global_next_library_mutex = CRYPTO_MUTEX_INIT;
|
||||
|
||||
static void err_state_free(void *statep) {
|
||||
ERR_STATE *state = statep;
|
||||
@@ -367,9 +366,9 @@ void ERR_remove_thread_state(const CRYPTO_THREADID *tid) {
|
||||
int ERR_get_next_error_library(void) {
|
||||
int ret;
|
||||
|
||||
CRYPTO_STATIC_MUTEX_lock_write(&global_next_library_mutex);
|
||||
CRYPTO_MUTEX_lock_write(&global_next_library_mutex);
|
||||
ret = global_next_library++;
|
||||
CRYPTO_STATIC_MUTEX_unlock_write(&global_next_library_mutex);
|
||||
CRYPTO_MUTEX_unlock_write(&global_next_library_mutex);
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -553,22 +552,21 @@ char *ERR_error_string_n(uint32_t packed_error, char *buf, size_t len) {
|
||||
const char *lib_str = err_lib_error_string(packed_error);
|
||||
const char *reason_str = err_reason_error_string(packed_error);
|
||||
|
||||
char lib_buf[64], reason_buf[64];
|
||||
char lib_buf[32], reason_buf[32];
|
||||
if (lib_str == NULL) {
|
||||
BIO_snprintf(lib_buf, sizeof(lib_buf), "lib(%u)", lib);
|
||||
snprintf(lib_buf, sizeof(lib_buf), "lib(%u)", lib);
|
||||
lib_str = lib_buf;
|
||||
}
|
||||
|
||||
if (reason_str == NULL) {
|
||||
BIO_snprintf(reason_buf, sizeof(reason_buf), "reason(%u)", reason);
|
||||
if (reason_str == NULL) {
|
||||
snprintf(reason_buf, sizeof(reason_buf), "reason(%u)", reason);
|
||||
reason_str = reason_buf;
|
||||
}
|
||||
|
||||
BIO_snprintf(buf, len, "error:%08" PRIx32 ":%s:OPENSSL_internal:%s",
|
||||
packed_error, lib_str, reason_str);
|
||||
|
||||
if (strlen(buf) == len - 1) {
|
||||
// output may be truncated; make sure we always have 5 colon-separated
|
||||
int ret = snprintf(buf, len, "error:%08" PRIx32 ":%s:OPENSSL_internal:%s",
|
||||
packed_error, lib_str, reason_str);
|
||||
if (ret >= 0 && (size_t)ret >= len) {
|
||||
// The output was truncated; make sure we always have 5 colon-separated
|
||||
// fields, i.e. 4 colons.
|
||||
static const unsigned num_colons = 4;
|
||||
unsigned i;
|
||||
@@ -618,8 +616,8 @@ void ERR_print_errors_cb(ERR_print_errors_callback_t callback, void *ctx) {
|
||||
}
|
||||
|
||||
ERR_error_string_n(packed_error, buf, sizeof(buf));
|
||||
BIO_snprintf(buf2, sizeof(buf2), "%lu:%s:%s:%d:%s\n", thread_hash, buf,
|
||||
file, line, (flags & ERR_FLAG_STRING) ? data : "");
|
||||
snprintf(buf2, sizeof(buf2), "%lu:%s:%s:%d:%s\n", thread_hash, buf, file,
|
||||
line, (flags & ERR_FLAG_STRING) ? data : "");
|
||||
if (callback(buf2, strlen(buf2), ctx) <= 0) {
|
||||
break;
|
||||
}
|
||||
@@ -867,6 +865,10 @@ void ERR_restore_state(const ERR_SAVE_STATE *state) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (state->num_errors >= ERR_NUM_ERRORS) {
|
||||
abort();
|
||||
}
|
||||
|
||||
ERR_STATE *const dst = err_get_state();
|
||||
if (dst == NULL) {
|
||||
return;
|
||||
@@ -875,6 +877,6 @@ void ERR_restore_state(const ERR_SAVE_STATE *state) {
|
||||
for (size_t i = 0; i < state->num_errors; i++) {
|
||||
err_copy(&dst->errors[i], &state->errors[i]);
|
||||
}
|
||||
dst->top = state->num_errors - 1;
|
||||
dst->top = (unsigned)(state->num_errors - 1);
|
||||
dst->bottom = ERR_NUM_ERRORS - 1;
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -229,6 +229,13 @@ static const EVP_PKEY_ASN1_METHOD *evp_pkey_asn1_find(int nid) {
|
||||
}
|
||||
}
|
||||
|
||||
static void evp_pkey_set_method(EVP_PKEY *pkey,
|
||||
const EVP_PKEY_ASN1_METHOD *method) {
|
||||
free_it(pkey);
|
||||
pkey->ameth = method;
|
||||
pkey->type = pkey->ameth->pkey_id;
|
||||
}
|
||||
|
||||
int EVP_PKEY_type(int nid) {
|
||||
const EVP_PKEY_ASN1_METHOD *meth = evp_pkey_asn1_find(nid);
|
||||
if (meth == NULL) {
|
||||
@@ -246,7 +253,9 @@ int EVP_PKEY_set1_RSA(EVP_PKEY *pkey, RSA *key) {
|
||||
}
|
||||
|
||||
int EVP_PKEY_assign_RSA(EVP_PKEY *pkey, RSA *key) {
|
||||
return EVP_PKEY_assign(pkey, EVP_PKEY_RSA, key);
|
||||
evp_pkey_set_method(pkey, &rsa_asn1_meth);
|
||||
pkey->pkey = key;
|
||||
return key != NULL;
|
||||
}
|
||||
|
||||
RSA *EVP_PKEY_get0_RSA(const EVP_PKEY *pkey) {
|
||||
@@ -274,7 +283,9 @@ int EVP_PKEY_set1_DSA(EVP_PKEY *pkey, DSA *key) {
|
||||
}
|
||||
|
||||
int EVP_PKEY_assign_DSA(EVP_PKEY *pkey, DSA *key) {
|
||||
return EVP_PKEY_assign(pkey, EVP_PKEY_DSA, key);
|
||||
evp_pkey_set_method(pkey, &dsa_asn1_meth);
|
||||
pkey->pkey = key;
|
||||
return key != NULL;
|
||||
}
|
||||
|
||||
DSA *EVP_PKEY_get0_DSA(const EVP_PKEY *pkey) {
|
||||
@@ -302,7 +313,9 @@ int EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey, EC_KEY *key) {
|
||||
}
|
||||
|
||||
int EVP_PKEY_assign_EC_KEY(EVP_PKEY *pkey, EC_KEY *key) {
|
||||
return EVP_PKEY_assign(pkey, EVP_PKEY_EC, key);
|
||||
evp_pkey_set_method(pkey, &ec_asn1_meth);
|
||||
pkey->pkey = key;
|
||||
return key != NULL;
|
||||
}
|
||||
|
||||
EC_KEY *EVP_PKEY_get0_EC_KEY(const EVP_PKEY *pkey) {
|
||||
@@ -325,21 +338,32 @@ DH *EVP_PKEY_get0_DH(const EVP_PKEY *pkey) { return NULL; }
|
||||
DH *EVP_PKEY_get1_DH(const EVP_PKEY *pkey) { return NULL; }
|
||||
|
||||
int EVP_PKEY_assign(EVP_PKEY *pkey, int type, void *key) {
|
||||
if (!EVP_PKEY_set_type(pkey, type)) {
|
||||
return 0;
|
||||
// This function can only be used to assign RSA, DSA, and EC keys. Other key
|
||||
// types have internal representations which are not exposed through the
|
||||
// public API.
|
||||
switch (type) {
|
||||
case EVP_PKEY_RSA:
|
||||
return EVP_PKEY_assign_RSA(pkey, key);
|
||||
case EVP_PKEY_DSA:
|
||||
return EVP_PKEY_assign_DSA(pkey, key);
|
||||
case EVP_PKEY_EC:
|
||||
return EVP_PKEY_assign_EC_KEY(pkey, key);
|
||||
}
|
||||
pkey->pkey = key;
|
||||
return key != NULL;
|
||||
|
||||
OPENSSL_PUT_ERROR(EVP, EVP_R_UNSUPPORTED_ALGORITHM);
|
||||
ERR_add_error_dataf("algorithm %d", type);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int EVP_PKEY_set_type(EVP_PKEY *pkey, int type) {
|
||||
const EVP_PKEY_ASN1_METHOD *ameth;
|
||||
|
||||
if (pkey && pkey->pkey) {
|
||||
// This isn't strictly necessary, but historically |EVP_PKEY_set_type| would
|
||||
// clear |pkey| even if |evp_pkey_asn1_find| failed, so we preserve that
|
||||
// behavior.
|
||||
free_it(pkey);
|
||||
}
|
||||
|
||||
ameth = evp_pkey_asn1_find(type);
|
||||
const EVP_PKEY_ASN1_METHOD *ameth = evp_pkey_asn1_find(type);
|
||||
if (ameth == NULL) {
|
||||
OPENSSL_PUT_ERROR(EVP, EVP_R_UNSUPPORTED_ALGORITHM);
|
||||
ERR_add_error_dataf("algorithm %d", type);
|
||||
@@ -347,8 +371,7 @@ int EVP_PKEY_set_type(EVP_PKEY *pkey, int type) {
|
||||
}
|
||||
|
||||
if (pkey) {
|
||||
pkey->ameth = ameth;
|
||||
pkey->type = pkey->ameth->pkey_id;
|
||||
evp_pkey_set_method(pkey, ameth);
|
||||
}
|
||||
|
||||
return 1;
|
||||
|
||||
@@ -75,7 +75,7 @@
|
||||
typedef struct {
|
||||
// message digest
|
||||
const EVP_MD *md;
|
||||
EC_GROUP *gen_group;
|
||||
const EC_GROUP *gen_group;
|
||||
} EC_PKEY_CTX;
|
||||
|
||||
|
||||
@@ -111,7 +111,6 @@ static void pkey_ec_cleanup(EVP_PKEY_CTX *ctx) {
|
||||
return;
|
||||
}
|
||||
|
||||
EC_GROUP_free(dctx->gen_group);
|
||||
OPENSSL_free(dctx);
|
||||
}
|
||||
|
||||
@@ -195,11 +194,10 @@ static int pkey_ec_ctrl(EVP_PKEY_CTX *ctx, int type, int p1, void *p2) {
|
||||
return 1;
|
||||
|
||||
case EVP_PKEY_CTRL_EC_PARAMGEN_CURVE_NID: {
|
||||
EC_GROUP *group = EC_GROUP_new_by_curve_name(p1);
|
||||
const EC_GROUP *group = EC_GROUP_new_by_curve_name(p1);
|
||||
if (group == NULL) {
|
||||
return 0;
|
||||
}
|
||||
EC_GROUP_free(dctx->gen_group);
|
||||
dctx->gen_group = group;
|
||||
return 1;
|
||||
}
|
||||
|
||||
@@ -94,7 +94,7 @@ static int eckey_pub_decode(EVP_PKEY *out, CBS *params, CBS *key) {
|
||||
|
||||
// The parameters are a named curve.
|
||||
EC_KEY *eckey = NULL;
|
||||
EC_GROUP *group = EC_KEY_parse_curve_name(params);
|
||||
const EC_GROUP *group = EC_KEY_parse_curve_name(params);
|
||||
if (group == NULL || CBS_len(params) != 0) {
|
||||
OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
|
||||
goto err;
|
||||
@@ -107,12 +107,10 @@ static int eckey_pub_decode(EVP_PKEY *out, CBS *params, CBS *key) {
|
||||
goto err;
|
||||
}
|
||||
|
||||
EC_GROUP_free(group);
|
||||
EVP_PKEY_assign_EC_KEY(out, eckey);
|
||||
return 1;
|
||||
|
||||
err:
|
||||
EC_GROUP_free(group);
|
||||
EC_KEY_free(eckey);
|
||||
return 0;
|
||||
}
|
||||
@@ -135,15 +133,13 @@ static int eckey_pub_cmp(const EVP_PKEY *a, const EVP_PKEY *b) {
|
||||
|
||||
static int eckey_priv_decode(EVP_PKEY *out, CBS *params, CBS *key) {
|
||||
// See RFC 5915.
|
||||
EC_GROUP *group = EC_KEY_parse_parameters(params);
|
||||
const EC_GROUP *group = EC_KEY_parse_parameters(params);
|
||||
if (group == NULL || CBS_len(params) != 0) {
|
||||
OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
|
||||
EC_GROUP_free(group);
|
||||
return 0;
|
||||
}
|
||||
|
||||
EC_KEY *ec_key = EC_KEY_parse_private_key(key, group);
|
||||
EC_GROUP_free(group);
|
||||
if (ec_key == NULL || CBS_len(key) != 0) {
|
||||
OPENSSL_PUT_ERROR(EVP, EVP_R_DECODE_ERROR);
|
||||
EC_KEY_free(ec_key);
|
||||
@@ -215,7 +211,7 @@ static int ec_bits(const EVP_PKEY *pkey) {
|
||||
ERR_clear_error();
|
||||
return 0;
|
||||
}
|
||||
return BN_num_bits(EC_GROUP_get0_order(group));
|
||||
return EC_GROUP_order_bits(group);
|
||||
}
|
||||
|
||||
static int ec_missing_parameters(const EVP_PKEY *pkey) {
|
||||
|
||||
@@ -63,7 +63,7 @@
|
||||
|
||||
|
||||
int PKCS5_PBKDF2_HMAC(const char *password, size_t password_len,
|
||||
const uint8_t *salt, size_t salt_len, unsigned iterations,
|
||||
const uint8_t *salt, size_t salt_len, uint32_t iterations,
|
||||
const EVP_MD *digest, size_t key_len, uint8_t *out_key) {
|
||||
// See RFC 8018, section 5.2.
|
||||
int ret = 0;
|
||||
@@ -98,7 +98,7 @@ int PKCS5_PBKDF2_HMAC(const char *password, size_t password_len,
|
||||
}
|
||||
|
||||
OPENSSL_memcpy(out_key, digest_tmp, todo);
|
||||
for (unsigned j = 1; j < iterations; j++) {
|
||||
for (uint32_t j = 1; j < iterations; j++) {
|
||||
// Compute the remaining U_* values and XOR.
|
||||
if (!HMAC_Init_ex(&hctx, NULL, 0, NULL, NULL) ||
|
||||
!HMAC_Update(&hctx, digest_tmp, md_len) ||
|
||||
@@ -139,7 +139,7 @@ err:
|
||||
|
||||
int PKCS5_PBKDF2_HMAC_SHA1(const char *password, size_t password_len,
|
||||
const uint8_t *salt, size_t salt_len,
|
||||
unsigned iterations, size_t key_len,
|
||||
uint32_t iterations, size_t key_len,
|
||||
uint8_t *out_key) {
|
||||
return PKCS5_PBKDF2_HMAC(password, password_len, salt, salt_len, iterations,
|
||||
EVP_sha1(), key_len, out_key);
|
||||
|
||||
@@ -196,12 +196,12 @@ static int rsa_priv_print(BIO *bp, const EVP_PKEY *pkey, int indent) {
|
||||
static int do_dsa_print(BIO *bp, const DSA *x, int off, int ptype) {
|
||||
const BIGNUM *priv_key = NULL;
|
||||
if (ptype == 2) {
|
||||
priv_key = x->priv_key;
|
||||
priv_key = DSA_get0_priv_key(x);
|
||||
}
|
||||
|
||||
const BIGNUM *pub_key = NULL;
|
||||
if (ptype > 0) {
|
||||
pub_key = x->pub_key;
|
||||
pub_key = DSA_get0_pub_key(x);
|
||||
}
|
||||
|
||||
const char *ktype = "DSA-Parameters";
|
||||
@@ -212,14 +212,15 @@ static int do_dsa_print(BIO *bp, const DSA *x, int off, int ptype) {
|
||||
}
|
||||
|
||||
if (!BIO_indent(bp, off, 128) ||
|
||||
BIO_printf(bp, "%s: (%u bit)\n", ktype, BN_num_bits(x->p)) <= 0 ||
|
||||
BIO_printf(bp, "%s: (%u bit)\n", ktype, BN_num_bits(DSA_get0_p(x))) <=
|
||||
0 ||
|
||||
// |priv_key| and |pub_key| may be NULL, in which case |bn_print| will
|
||||
// silently skip them.
|
||||
!bn_print(bp, "priv:", priv_key, off) ||
|
||||
!bn_print(bp, "pub:", pub_key, off) ||
|
||||
!bn_print(bp, "P:", x->p, off) ||
|
||||
!bn_print(bp, "Q:", x->q, off) ||
|
||||
!bn_print(bp, "G:", x->g, off)) {
|
||||
!bn_print(bp, "P:", DSA_get0_p(x), off) ||
|
||||
!bn_print(bp, "Q:", DSA_get0_q(x), off) ||
|
||||
!bn_print(bp, "G:", DSA_get0_g(x), off)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@@ -116,7 +116,6 @@
|
||||
#include <CCryptoBoringSSL_crypto.h>
|
||||
#include <CCryptoBoringSSL_err.h>
|
||||
#include <CCryptoBoringSSL_mem.h>
|
||||
#include <CCryptoBoringSSL_stack.h>
|
||||
#include <CCryptoBoringSSL_thread.h>
|
||||
|
||||
#include "internal.h"
|
||||
@@ -128,14 +127,14 @@ struct crypto_ex_data_func_st {
|
||||
long argl; // Arbitary long
|
||||
void *argp; // Arbitary void pointer
|
||||
CRYPTO_EX_free *free_func;
|
||||
// next points to the next |CRYPTO_EX_DATA_FUNCS| or NULL if this is the last
|
||||
// one. It may only be read if synchronized with a read from |num_funcs|.
|
||||
CRYPTO_EX_DATA_FUNCS *next;
|
||||
};
|
||||
|
||||
int CRYPTO_get_ex_new_index(CRYPTO_EX_DATA_CLASS *ex_data_class, int *out_index,
|
||||
long argl, void *argp, CRYPTO_EX_free *free_func) {
|
||||
CRYPTO_EX_DATA_FUNCS *funcs;
|
||||
int ret = 0;
|
||||
|
||||
funcs = OPENSSL_malloc(sizeof(CRYPTO_EX_DATA_FUNCS));
|
||||
CRYPTO_EX_DATA_FUNCS *funcs = OPENSSL_malloc(sizeof(CRYPTO_EX_DATA_FUNCS));
|
||||
if (funcs == NULL) {
|
||||
return 0;
|
||||
}
|
||||
@@ -143,37 +142,32 @@ int CRYPTO_get_ex_new_index(CRYPTO_EX_DATA_CLASS *ex_data_class, int *out_index,
|
||||
funcs->argl = argl;
|
||||
funcs->argp = argp;
|
||||
funcs->free_func = free_func;
|
||||
funcs->next = NULL;
|
||||
|
||||
CRYPTO_STATIC_MUTEX_lock_write(&ex_data_class->lock);
|
||||
|
||||
if (ex_data_class->meth == NULL) {
|
||||
ex_data_class->meth = sk_CRYPTO_EX_DATA_FUNCS_new_null();
|
||||
}
|
||||
|
||||
if (ex_data_class->meth == NULL) {
|
||||
goto err;
|
||||
}
|
||||
CRYPTO_MUTEX_lock_write(&ex_data_class->lock);
|
||||
|
||||
uint32_t num_funcs = CRYPTO_atomic_load_u32(&ex_data_class->num_funcs);
|
||||
// The index must fit in |int|.
|
||||
if (sk_CRYPTO_EX_DATA_FUNCS_num(ex_data_class->meth) >
|
||||
(size_t)(INT_MAX - ex_data_class->num_reserved)) {
|
||||
if (num_funcs > (size_t)(INT_MAX - ex_data_class->num_reserved)) {
|
||||
OPENSSL_PUT_ERROR(CRYPTO, ERR_R_OVERFLOW);
|
||||
goto err;
|
||||
CRYPTO_MUTEX_unlock_write(&ex_data_class->lock);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!sk_CRYPTO_EX_DATA_FUNCS_push(ex_data_class->meth, funcs)) {
|
||||
goto err;
|
||||
// Append |funcs| to the linked list.
|
||||
if (ex_data_class->last == NULL) {
|
||||
assert(num_funcs == 0);
|
||||
ex_data_class->funcs = funcs;
|
||||
ex_data_class->last = funcs;
|
||||
} else {
|
||||
ex_data_class->last->next = funcs;
|
||||
ex_data_class->last = funcs;
|
||||
}
|
||||
funcs = NULL; // |sk_CRYPTO_EX_DATA_FUNCS_push| takes ownership.
|
||||
|
||||
*out_index = (int)sk_CRYPTO_EX_DATA_FUNCS_num(ex_data_class->meth) - 1 +
|
||||
ex_data_class->num_reserved;
|
||||
ret = 1;
|
||||
|
||||
err:
|
||||
CRYPTO_STATIC_MUTEX_unlock_write(&ex_data_class->lock);
|
||||
OPENSSL_free(funcs);
|
||||
return ret;
|
||||
CRYPTO_atomic_store_u32(&ex_data_class->num_funcs, num_funcs + 1);
|
||||
CRYPTO_MUTEX_unlock_write(&ex_data_class->lock);
|
||||
*out_index = (int)num_funcs + ex_data_class->num_reserved;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int index, void *val) {
|
||||
@@ -209,33 +203,6 @@ void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx) {
|
||||
return sk_void_value(ad->sk, idx);
|
||||
}
|
||||
|
||||
// get_func_pointers takes a copy of the CRYPTO_EX_DATA_FUNCS pointers, if any,
|
||||
// for the given class. If there are some pointers, it sets |*out| to point to
|
||||
// a fresh stack of them. Otherwise it sets |*out| to NULL. It returns one on
|
||||
// success or zero on error.
|
||||
static int get_func_pointers(STACK_OF(CRYPTO_EX_DATA_FUNCS) **out,
|
||||
CRYPTO_EX_DATA_CLASS *ex_data_class) {
|
||||
size_t n;
|
||||
|
||||
*out = NULL;
|
||||
|
||||
// CRYPTO_EX_DATA_FUNCS structures are static once set, so we can take a
|
||||
// shallow copy of the list under lock and then use the structures without
|
||||
// the lock held.
|
||||
CRYPTO_STATIC_MUTEX_lock_read(&ex_data_class->lock);
|
||||
n = sk_CRYPTO_EX_DATA_FUNCS_num(ex_data_class->meth);
|
||||
if (n > 0) {
|
||||
*out = sk_CRYPTO_EX_DATA_FUNCS_dup(ex_data_class->meth);
|
||||
}
|
||||
CRYPTO_STATIC_MUTEX_unlock_read(&ex_data_class->lock);
|
||||
|
||||
if (n > 0 && *out == NULL) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
void CRYPTO_new_ex_data(CRYPTO_EX_DATA *ad) {
|
||||
ad->sk = NULL;
|
||||
}
|
||||
@@ -247,26 +214,21 @@ void CRYPTO_free_ex_data(CRYPTO_EX_DATA_CLASS *ex_data_class, void *obj,
|
||||
return;
|
||||
}
|
||||
|
||||
STACK_OF(CRYPTO_EX_DATA_FUNCS) *func_pointers;
|
||||
if (!get_func_pointers(&func_pointers, ex_data_class)) {
|
||||
// TODO(davidben): This leaks memory on malloc error.
|
||||
return;
|
||||
}
|
||||
|
||||
uint32_t num_funcs = CRYPTO_atomic_load_u32(&ex_data_class->num_funcs);
|
||||
// |CRYPTO_get_ex_new_index| will not allocate indices beyond |INT_MAX|.
|
||||
assert(sk_CRYPTO_EX_DATA_FUNCS_num(func_pointers) <=
|
||||
(size_t)(INT_MAX - ex_data_class->num_reserved));
|
||||
for (int i = 0; i < (int)sk_CRYPTO_EX_DATA_FUNCS_num(func_pointers); i++) {
|
||||
CRYPTO_EX_DATA_FUNCS *func_pointer =
|
||||
sk_CRYPTO_EX_DATA_FUNCS_value(func_pointers, i);
|
||||
if (func_pointer->free_func) {
|
||||
void *ptr = CRYPTO_get_ex_data(ad, i + ex_data_class->num_reserved);
|
||||
func_pointer->free_func(obj, ptr, ad, i + ex_data_class->num_reserved,
|
||||
func_pointer->argl, func_pointer->argp);
|
||||
}
|
||||
}
|
||||
assert(num_funcs <= (size_t)(INT_MAX - ex_data_class->num_reserved));
|
||||
|
||||
sk_CRYPTO_EX_DATA_FUNCS_free(func_pointers);
|
||||
// Defer dereferencing |ex_data_class->funcs| and |funcs->next|. It must come
|
||||
// after the |num_funcs| comparison to be correctly synchronized.
|
||||
CRYPTO_EX_DATA_FUNCS *const *funcs = &ex_data_class->funcs;
|
||||
for (uint32_t i = 0; i < num_funcs; i++) {
|
||||
if ((*funcs)->free_func != NULL) {
|
||||
int index = (int)i + ex_data_class->num_reserved;
|
||||
void *ptr = CRYPTO_get_ex_data(ad, index);
|
||||
(*funcs)->free_func(obj, ptr, ad, index, (*funcs)->argl, (*funcs)->argp);
|
||||
}
|
||||
funcs = &(*funcs)->next;
|
||||
}
|
||||
|
||||
sk_void_free(ad->sk);
|
||||
ad->sk = NULL;
|
||||
|
||||
@@ -3,16 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if defined(__has_feature)
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if defined(__x86_64__) && !defined(OPENSSL_NO_ASM) && defined(__ELF__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86_64) && defined(__ELF__)
|
||||
.text
|
||||
|
||||
.type _aesni_ctr32_ghash_6x,@function
|
||||
@@ -355,6 +348,7 @@ _aesni_ctr32_ghash_6x:
|
||||
aesni_gcm_decrypt:
|
||||
.cfi_startproc
|
||||
|
||||
_CET_ENDBR
|
||||
xorq %rax,%rax
|
||||
|
||||
|
||||
@@ -385,17 +379,18 @@ aesni_gcm_decrypt:
|
||||
|
||||
vzeroupper
|
||||
|
||||
movq 16(%rbp),%r12
|
||||
vmovdqu (%r8),%xmm1
|
||||
addq $-128,%rsp
|
||||
movl 12(%r8),%ebx
|
||||
leaq .Lbswap_mask(%rip),%r11
|
||||
leaq -128(%rcx),%r14
|
||||
movq $0xf80,%r15
|
||||
vmovdqu (%r9),%xmm8
|
||||
vmovdqu (%r12),%xmm8
|
||||
andq $-128,%rsp
|
||||
vmovdqu (%r11),%xmm0
|
||||
leaq 128(%rcx),%rcx
|
||||
leaq 32+32(%r9),%r9
|
||||
leaq 32(%r9),%r9
|
||||
movl 240-128(%rcx),%r10d
|
||||
vpshufb %xmm0,%xmm8,%xmm8
|
||||
|
||||
@@ -440,6 +435,7 @@ aesni_gcm_decrypt:
|
||||
|
||||
call _aesni_ctr32_ghash_6x
|
||||
|
||||
movq 16(%rbp),%r12
|
||||
vmovups %xmm9,-96(%rsi)
|
||||
vmovups %xmm10,-80(%rsi)
|
||||
vmovups %xmm11,-64(%rsi)
|
||||
@@ -448,7 +444,7 @@ aesni_gcm_decrypt:
|
||||
vmovups %xmm14,-16(%rsi)
|
||||
|
||||
vpshufb (%r11),%xmm8,%xmm8
|
||||
vmovdqu %xmm8,-64(%r9)
|
||||
vmovdqu %xmm8,(%r12)
|
||||
|
||||
vzeroupper
|
||||
leaq -40(%rbp),%rsp
|
||||
@@ -576,6 +572,7 @@ _aesni_ctr32_6x:
|
||||
aesni_gcm_encrypt:
|
||||
.cfi_startproc
|
||||
|
||||
_CET_ENDBR
|
||||
#ifdef BORINGSSL_DISPATCH_TEST
|
||||
.extern BORINGSSL_function_hit
|
||||
.hidden BORINGSSL_function_hit
|
||||
@@ -660,8 +657,9 @@ aesni_gcm_encrypt:
|
||||
|
||||
call _aesni_ctr32_6x
|
||||
|
||||
vmovdqu (%r9),%xmm8
|
||||
leaq 32+32(%r9),%r9
|
||||
movq 16(%rbp),%r12
|
||||
leaq 32(%r9),%r9
|
||||
vmovdqu (%r12),%xmm8
|
||||
subq $12,%rdx
|
||||
movq $192,%rax
|
||||
vpshufb %xmm0,%xmm8,%xmm8
|
||||
@@ -839,8 +837,9 @@ aesni_gcm_encrypt:
|
||||
vpclmulqdq $0x10,%xmm3,%xmm8,%xmm8
|
||||
vpxor %xmm7,%xmm2,%xmm2
|
||||
vpxor %xmm2,%xmm8,%xmm8
|
||||
movq 16(%rbp),%r12
|
||||
vpshufb (%r11),%xmm8,%xmm8
|
||||
vmovdqu %xmm8,-64(%r9)
|
||||
vmovdqu %xmm8,(%r12)
|
||||
|
||||
vzeroupper
|
||||
leaq -40(%rbp),%rsp
|
||||
@@ -884,10 +883,6 @@ aesni_gcm_encrypt:
|
||||
.align 64
|
||||
.text
|
||||
#endif
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // defined(__x86_64__) && defined(__linux__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,16 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if defined(__has_feature)
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if defined(__x86_64__) && !defined(OPENSSL_NO_ASM) && defined(__APPLE__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86_64) && defined(__APPLE__)
|
||||
.text
|
||||
|
||||
|
||||
@@ -355,6 +348,7 @@ L$6x_done:
|
||||
_aesni_gcm_decrypt:
|
||||
|
||||
|
||||
_CET_ENDBR
|
||||
xorq %rax,%rax
|
||||
|
||||
|
||||
@@ -384,17 +378,18 @@ _aesni_gcm_decrypt:
|
||||
|
||||
vzeroupper
|
||||
|
||||
movq 16(%rbp),%r12
|
||||
vmovdqu (%r8),%xmm1
|
||||
addq $-128,%rsp
|
||||
movl 12(%r8),%ebx
|
||||
leaq L$bswap_mask(%rip),%r11
|
||||
leaq -128(%rcx),%r14
|
||||
movq $0xf80,%r15
|
||||
vmovdqu (%r9),%xmm8
|
||||
vmovdqu (%r12),%xmm8
|
||||
andq $-128,%rsp
|
||||
vmovdqu (%r11),%xmm0
|
||||
leaq 128(%rcx),%rcx
|
||||
leaq 32+32(%r9),%r9
|
||||
leaq 32(%r9),%r9
|
||||
movl 240-128(%rcx),%r10d
|
||||
vpshufb %xmm0,%xmm8,%xmm8
|
||||
|
||||
@@ -439,6 +434,7 @@ L$dec_no_key_aliasing:
|
||||
|
||||
call _aesni_ctr32_ghash_6x
|
||||
|
||||
movq 16(%rbp),%r12
|
||||
vmovups %xmm9,-96(%rsi)
|
||||
vmovups %xmm10,-80(%rsi)
|
||||
vmovups %xmm11,-64(%rsi)
|
||||
@@ -447,7 +443,7 @@ L$dec_no_key_aliasing:
|
||||
vmovups %xmm14,-16(%rsi)
|
||||
|
||||
vpshufb (%r11),%xmm8,%xmm8
|
||||
vmovdqu %xmm8,-64(%r9)
|
||||
vmovdqu %xmm8,(%r12)
|
||||
|
||||
vzeroupper
|
||||
leaq -40(%rbp),%rsp
|
||||
@@ -569,6 +565,7 @@ L$handle_ctr32_2:
|
||||
_aesni_gcm_encrypt:
|
||||
|
||||
|
||||
_CET_ENDBR
|
||||
#ifdef BORINGSSL_DISPATCH_TEST
|
||||
|
||||
movb $1,_BORINGSSL_function_hit+2(%rip)
|
||||
@@ -651,8 +648,9 @@ L$enc_no_key_aliasing:
|
||||
|
||||
call _aesni_ctr32_6x
|
||||
|
||||
vmovdqu (%r9),%xmm8
|
||||
leaq 32+32(%r9),%r9
|
||||
movq 16(%rbp),%r12
|
||||
leaq 32(%r9),%r9
|
||||
vmovdqu (%r12),%xmm8
|
||||
subq $12,%rdx
|
||||
movq $192,%rax
|
||||
vpshufb %xmm0,%xmm8,%xmm8
|
||||
@@ -830,8 +828,9 @@ L$enc_no_key_aliasing:
|
||||
vpclmulqdq $0x10,%xmm3,%xmm8,%xmm8
|
||||
vpxor %xmm7,%xmm2,%xmm2
|
||||
vpxor %xmm2,%xmm8,%xmm8
|
||||
movq 16(%rbp),%r12
|
||||
vpshufb (%r11),%xmm8,%xmm8
|
||||
vmovdqu %xmm8,-64(%r9)
|
||||
vmovdqu %xmm8,(%r12)
|
||||
|
||||
vzeroupper
|
||||
leaq -40(%rbp),%rsp
|
||||
@@ -869,10 +868,6 @@ L$one_lsb:
|
||||
.p2align 6
|
||||
.text
|
||||
#endif
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // defined(__x86_64__) && defined(__APPLE__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,16 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if defined(__has_feature)
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__i386__) && defined(__ELF__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86) && defined(__ELF__)
|
||||
.text
|
||||
#ifdef BORINGSSL_DISPATCH_TEST
|
||||
#endif
|
||||
@@ -2517,11 +2510,7 @@ aes_hw_set_decrypt_key:
|
||||
.byte 83,45,78,73,44,32,67,82,89,80,84,79,71,65,77,83
|
||||
.byte 32,98,121,32,60,97,112,112,114,111,64,111,112,101,110,115
|
||||
.byte 115,108,46,111,114,103,62,0
|
||||
#endif // !defined(OPENSSL_NO_ASM) && defined(__i386__) && defined(__ELF__)
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86) && defined(__ELF__)
|
||||
#endif // defined(__i386__) && defined(__linux__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,16 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if defined(__has_feature)
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if defined(__x86_64__) && !defined(OPENSSL_NO_ASM) && defined(__ELF__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86_64) && defined(__ELF__)
|
||||
.text
|
||||
.extern OPENSSL_ia32cap_P
|
||||
.hidden OPENSSL_ia32cap_P
|
||||
@@ -22,6 +15,7 @@
|
||||
.align 16
|
||||
aes_hw_encrypt:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
#ifdef BORINGSSL_DISPATCH_TEST
|
||||
.extern BORINGSSL_function_hit
|
||||
.hidden BORINGSSL_function_hit
|
||||
@@ -54,6 +48,7 @@ aes_hw_encrypt:
|
||||
.align 16
|
||||
aes_hw_decrypt:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
movups (%rdi),%xmm2
|
||||
movl 240(%rdx),%eax
|
||||
movups (%rdx),%xmm0
|
||||
@@ -542,6 +537,7 @@ _aesni_decrypt8:
|
||||
.align 16
|
||||
aes_hw_ecb_encrypt:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
andq $-16,%rdx
|
||||
jz .Lecb_ret
|
||||
|
||||
@@ -887,6 +883,7 @@ aes_hw_ecb_encrypt:
|
||||
.align 16
|
||||
aes_hw_ctr32_encrypt_blocks:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
#ifdef BORINGSSL_DISPATCH_TEST
|
||||
movb $1,BORINGSSL_function_hit(%rip)
|
||||
#endif
|
||||
@@ -1264,6 +1261,8 @@ aes_hw_ctr32_encrypt_blocks:
|
||||
pxor %xmm0,%xmm13
|
||||
movdqu 80(%rdi),%xmm15
|
||||
pxor %xmm0,%xmm14
|
||||
prefetcht0 448(%rdi)
|
||||
prefetcht0 512(%rdi)
|
||||
pxor %xmm0,%xmm15
|
||||
.byte 102,15,56,220,209
|
||||
.byte 102,15,56,220,217
|
||||
@@ -1470,6 +1469,7 @@ aes_hw_ctr32_encrypt_blocks:
|
||||
.align 16
|
||||
aes_hw_cbc_encrypt:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
testq %rdx,%rdx
|
||||
jz .Lcbc_ret
|
||||
|
||||
@@ -2063,6 +2063,7 @@ aes_hw_cbc_encrypt:
|
||||
.align 16
|
||||
aes_hw_set_decrypt_key:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
.byte 0x48,0x83,0xEC,0x08
|
||||
.cfi_adjust_cfa_offset 8
|
||||
call __aesni_set_encrypt_key
|
||||
@@ -2109,6 +2110,7 @@ aes_hw_set_decrypt_key:
|
||||
aes_hw_set_encrypt_key:
|
||||
__aesni_set_encrypt_key:
|
||||
.cfi_startproc
|
||||
_CET_ENDBR
|
||||
#ifdef BORINGSSL_DISPATCH_TEST
|
||||
movb $1,BORINGSSL_function_hit+3(%rip)
|
||||
#endif
|
||||
@@ -2507,10 +2509,6 @@ __aesni_set_encrypt_key:
|
||||
.align 64
|
||||
.text
|
||||
#endif
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // defined(__x86_64__) && defined(__linux__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,16 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if defined(__has_feature)
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if defined(__x86_64__) && !defined(OPENSSL_NO_ASM) && defined(__APPLE__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86_64) && defined(__APPLE__)
|
||||
.text
|
||||
|
||||
.globl _aes_hw_encrypt
|
||||
@@ -21,6 +14,7 @@
|
||||
.p2align 4
|
||||
_aes_hw_encrypt:
|
||||
|
||||
_CET_ENDBR
|
||||
#ifdef BORINGSSL_DISPATCH_TEST
|
||||
|
||||
movb $1,_BORINGSSL_function_hit+1(%rip)
|
||||
@@ -52,6 +46,7 @@ L$oop_enc1_1:
|
||||
.p2align 4
|
||||
_aes_hw_decrypt:
|
||||
|
||||
_CET_ENDBR
|
||||
movups (%rdi),%xmm2
|
||||
movl 240(%rdx),%eax
|
||||
movups (%rdx),%xmm0
|
||||
@@ -540,6 +535,7 @@ L$dec_loop8_enter:
|
||||
.p2align 4
|
||||
_aes_hw_ecb_encrypt:
|
||||
|
||||
_CET_ENDBR
|
||||
andq $-16,%rdx
|
||||
jz L$ecb_ret
|
||||
|
||||
@@ -885,6 +881,7 @@ L$ecb_ret:
|
||||
.p2align 4
|
||||
_aes_hw_ctr32_encrypt_blocks:
|
||||
|
||||
_CET_ENDBR
|
||||
#ifdef BORINGSSL_DISPATCH_TEST
|
||||
movb $1,_BORINGSSL_function_hit(%rip)
|
||||
#endif
|
||||
@@ -1262,6 +1259,8 @@ L$ctr32_enc_done:
|
||||
pxor %xmm0,%xmm13
|
||||
movdqu 80(%rdi),%xmm15
|
||||
pxor %xmm0,%xmm14
|
||||
prefetcht0 448(%rdi)
|
||||
prefetcht0 512(%rdi)
|
||||
pxor %xmm0,%xmm15
|
||||
.byte 102,15,56,220,209
|
||||
.byte 102,15,56,220,217
|
||||
@@ -1468,6 +1467,7 @@ L$ctr32_epilogue:
|
||||
.p2align 4
|
||||
_aes_hw_cbc_encrypt:
|
||||
|
||||
_CET_ENDBR
|
||||
testq %rdx,%rdx
|
||||
jz L$cbc_ret
|
||||
|
||||
@@ -2061,6 +2061,7 @@ L$cbc_ret:
|
||||
.p2align 4
|
||||
_aes_hw_set_decrypt_key:
|
||||
|
||||
_CET_ENDBR
|
||||
.byte 0x48,0x83,0xEC,0x08
|
||||
|
||||
call __aesni_set_encrypt_key
|
||||
@@ -2107,6 +2108,7 @@ L$SEH_end_set_decrypt_key:
|
||||
_aes_hw_set_encrypt_key:
|
||||
__aesni_set_encrypt_key:
|
||||
|
||||
_CET_ENDBR
|
||||
#ifdef BORINGSSL_DISPATCH_TEST
|
||||
movb $1,_BORINGSSL_function_hit+3(%rip)
|
||||
#endif
|
||||
@@ -2505,10 +2507,6 @@ L$key_rcon1b:
|
||||
.p2align 6
|
||||
.text
|
||||
#endif
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // defined(__x86_64__) && defined(__APPLE__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,17 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if !defined(__has_feature)
|
||||
#define __has_feature(x) 0
|
||||
#endif
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__ARMEL__) && defined(__APPLE__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_ARM) && defined(__APPLE__)
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
|
||||
#if __ARM_MAX_ARCH__>=7
|
||||
@@ -808,11 +800,7 @@ Lctr32_done:
|
||||
ldmia sp!,{r4,r5,r6,r7,r8,r9,r10,pc}
|
||||
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(__ARMEL__) && defined(__APPLE__)
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(OPENSSL_ARM) && defined(__APPLE__)
|
||||
#endif // defined(__arm__) && defined(__APPLE__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,17 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if !defined(__has_feature)
|
||||
#define __has_feature(x) 0
|
||||
#endif
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__ARMEL__) && defined(__ELF__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_ARM) && defined(__ELF__)
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
|
||||
#if __ARM_MAX_ARCH__>=7
|
||||
@@ -796,11 +788,7 @@ aes_hw_ctr32_encrypt_blocks:
|
||||
ldmia sp!,{r4,r5,r6,r7,r8,r9,r10,pc}
|
||||
.size aes_hw_ctr32_encrypt_blocks,.-aes_hw_ctr32_encrypt_blocks
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(__ARMEL__) && defined(__ELF__)
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(OPENSSL_ARM) && defined(__ELF__)
|
||||
#endif // defined(__arm__) && defined(__linux__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,17 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if !defined(__has_feature)
|
||||
#define __has_feature(x) 0
|
||||
#endif
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__AARCH64EL__) && defined(__APPLE__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_AARCH64) && defined(__APPLE__)
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
|
||||
#if __ARM_MAX_ARCH__>=7
|
||||
@@ -798,11 +790,7 @@ Lctr32_done:
|
||||
ret
|
||||
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(__AARCH64EL__) && defined(__APPLE__)
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(OPENSSL_AARCH64) && defined(__APPLE__)
|
||||
#endif // defined(__aarch64__) && defined(__APPLE__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,17 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if !defined(__has_feature)
|
||||
#define __has_feature(x) 0
|
||||
#endif
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__AARCH64EL__) && defined(__ELF__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_AARCH64) && defined(__ELF__)
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
|
||||
#if __ARM_MAX_ARCH__>=7
|
||||
@@ -798,11 +790,7 @@ aes_hw_ctr32_encrypt_blocks:
|
||||
ret
|
||||
.size aes_hw_ctr32_encrypt_blocks,.-aes_hw_ctr32_encrypt_blocks
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(__AARCH64EL__) && defined(__ELF__)
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(OPENSSL_AARCH64) && defined(__ELF__)
|
||||
#endif // defined(__aarch64__) && defined(__linux__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,17 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if !defined(__has_feature)
|
||||
#define __has_feature(x) 0
|
||||
#endif
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__AARCH64EL__) && defined(__APPLE__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_AARCH64) && defined(__APPLE__)
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
#if __ARM_MAX_ARCH__ >= 8
|
||||
|
||||
@@ -85,7 +77,7 @@ _aes_gcm_enc_kernel:
|
||||
ldr q23, [x8, #80] // load rk5
|
||||
aese v1.16b, v19.16b
|
||||
aesmc v1.16b, v1.16b // AES block 1 - round 1
|
||||
ldr q14, [x3, #80] // load h3l | h3h
|
||||
ldr q14, [x6, #48] // load h3l | h3h
|
||||
ext v14.16b, v14.16b, v14.16b, #8
|
||||
aese v3.16b, v18.16b
|
||||
aesmc v3.16b, v3.16b // AES block 3 - round 0
|
||||
@@ -94,14 +86,14 @@ _aes_gcm_enc_kernel:
|
||||
ldr q22, [x8, #64] // load rk4
|
||||
aese v1.16b, v20.16b
|
||||
aesmc v1.16b, v1.16b // AES block 1 - round 2
|
||||
ldr q13, [x3, #64] // load h2l | h2h
|
||||
ldr q13, [x6, #32] // load h2l | h2h
|
||||
ext v13.16b, v13.16b, v13.16b, #8
|
||||
aese v3.16b, v19.16b
|
||||
aesmc v3.16b, v3.16b // AES block 3 - round 1
|
||||
ldr q30, [x8, #192] // load rk12
|
||||
aese v2.16b, v20.16b
|
||||
aesmc v2.16b, v2.16b // AES block 2 - round 2
|
||||
ldr q15, [x3, #112] // load h4l | h4h
|
||||
ldr q15, [x6, #80] // load h4l | h4h
|
||||
ext v15.16b, v15.16b, v15.16b, #8
|
||||
aese v1.16b, v21.16b
|
||||
aesmc v1.16b, v1.16b // AES block 1 - round 3
|
||||
@@ -144,7 +136,7 @@ _aes_gcm_enc_kernel:
|
||||
ldr q27, [x8, #144] // load rk9
|
||||
aese v0.16b, v24.16b
|
||||
aesmc v0.16b, v0.16b // AES block 0 - round 6
|
||||
ldr q12, [x3, #32] // load h1l | h1h
|
||||
ldr q12, [x6] // load h1l | h1h
|
||||
ext v12.16b, v12.16b, v12.16b, #8
|
||||
aese v2.16b, v24.16b
|
||||
aesmc v2.16b, v2.16b // AES block 2 - round 6
|
||||
@@ -845,15 +837,15 @@ _aes_gcm_dec_kernel:
|
||||
ldr q19, [x8, #16] // load rk1
|
||||
aese v0.16b, v18.16b
|
||||
aesmc v0.16b, v0.16b // AES block 0 - round 0
|
||||
ldr q14, [x3, #80] // load h3l | h3h
|
||||
ldr q14, [x6, #48] // load h3l | h3h
|
||||
ext v14.16b, v14.16b, v14.16b, #8
|
||||
aese v3.16b, v18.16b
|
||||
aesmc v3.16b, v3.16b // AES block 3 - round 0
|
||||
ldr q15, [x3, #112] // load h4l | h4h
|
||||
ldr q15, [x6, #80] // load h4l | h4h
|
||||
ext v15.16b, v15.16b, v15.16b, #8
|
||||
aese v1.16b, v18.16b
|
||||
aesmc v1.16b, v1.16b // AES block 1 - round 0
|
||||
ldr q13, [x3, #64] // load h2l | h2h
|
||||
ldr q13, [x6, #32] // load h2l | h2h
|
||||
ext v13.16b, v13.16b, v13.16b, #8
|
||||
aese v2.16b, v18.16b
|
||||
aesmc v2.16b, v2.16b // AES block 2 - round 0
|
||||
@@ -873,7 +865,7 @@ _aes_gcm_dec_kernel:
|
||||
ldr q30, [x8, #192] // load rk12
|
||||
aese v0.16b, v20.16b
|
||||
aesmc v0.16b, v0.16b // AES block 0 - round 2
|
||||
ldr q12, [x3, #32] // load h1l | h1h
|
||||
ldr q12, [x6] // load h1l | h1h
|
||||
ext v12.16b, v12.16b, v12.16b, #8
|
||||
aese v2.16b, v20.16b
|
||||
aesmc v2.16b, v2.16b // AES block 2 - round 2
|
||||
@@ -1562,11 +1554,7 @@ Ldec_blocks_less_than_1: // blocks left <= 1
|
||||
ret
|
||||
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(__AARCH64EL__) && defined(__APPLE__)
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(OPENSSL_AARCH64) && defined(__APPLE__)
|
||||
#endif // defined(__aarch64__) && defined(__APPLE__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,17 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if !defined(__has_feature)
|
||||
#define __has_feature(x) 0
|
||||
#endif
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__AARCH64EL__) && defined(__ELF__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_AARCH64) && defined(__ELF__)
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
#if __ARM_MAX_ARCH__ >= 8
|
||||
|
||||
@@ -85,7 +77,7 @@ aes_gcm_enc_kernel:
|
||||
ldr q23, [x8, #80] // load rk5
|
||||
aese v1.16b, v19.16b
|
||||
aesmc v1.16b, v1.16b // AES block 1 - round 1
|
||||
ldr q14, [x3, #80] // load h3l | h3h
|
||||
ldr q14, [x6, #48] // load h3l | h3h
|
||||
ext v14.16b, v14.16b, v14.16b, #8
|
||||
aese v3.16b, v18.16b
|
||||
aesmc v3.16b, v3.16b // AES block 3 - round 0
|
||||
@@ -94,14 +86,14 @@ aes_gcm_enc_kernel:
|
||||
ldr q22, [x8, #64] // load rk4
|
||||
aese v1.16b, v20.16b
|
||||
aesmc v1.16b, v1.16b // AES block 1 - round 2
|
||||
ldr q13, [x3, #64] // load h2l | h2h
|
||||
ldr q13, [x6, #32] // load h2l | h2h
|
||||
ext v13.16b, v13.16b, v13.16b, #8
|
||||
aese v3.16b, v19.16b
|
||||
aesmc v3.16b, v3.16b // AES block 3 - round 1
|
||||
ldr q30, [x8, #192] // load rk12
|
||||
aese v2.16b, v20.16b
|
||||
aesmc v2.16b, v2.16b // AES block 2 - round 2
|
||||
ldr q15, [x3, #112] // load h4l | h4h
|
||||
ldr q15, [x6, #80] // load h4l | h4h
|
||||
ext v15.16b, v15.16b, v15.16b, #8
|
||||
aese v1.16b, v21.16b
|
||||
aesmc v1.16b, v1.16b // AES block 1 - round 3
|
||||
@@ -144,7 +136,7 @@ aes_gcm_enc_kernel:
|
||||
ldr q27, [x8, #144] // load rk9
|
||||
aese v0.16b, v24.16b
|
||||
aesmc v0.16b, v0.16b // AES block 0 - round 6
|
||||
ldr q12, [x3, #32] // load h1l | h1h
|
||||
ldr q12, [x6] // load h1l | h1h
|
||||
ext v12.16b, v12.16b, v12.16b, #8
|
||||
aese v2.16b, v24.16b
|
||||
aesmc v2.16b, v2.16b // AES block 2 - round 6
|
||||
@@ -845,15 +837,15 @@ aes_gcm_dec_kernel:
|
||||
ldr q19, [x8, #16] // load rk1
|
||||
aese v0.16b, v18.16b
|
||||
aesmc v0.16b, v0.16b // AES block 0 - round 0
|
||||
ldr q14, [x3, #80] // load h3l | h3h
|
||||
ldr q14, [x6, #48] // load h3l | h3h
|
||||
ext v14.16b, v14.16b, v14.16b, #8
|
||||
aese v3.16b, v18.16b
|
||||
aesmc v3.16b, v3.16b // AES block 3 - round 0
|
||||
ldr q15, [x3, #112] // load h4l | h4h
|
||||
ldr q15, [x6, #80] // load h4l | h4h
|
||||
ext v15.16b, v15.16b, v15.16b, #8
|
||||
aese v1.16b, v18.16b
|
||||
aesmc v1.16b, v1.16b // AES block 1 - round 0
|
||||
ldr q13, [x3, #64] // load h2l | h2h
|
||||
ldr q13, [x6, #32] // load h2l | h2h
|
||||
ext v13.16b, v13.16b, v13.16b, #8
|
||||
aese v2.16b, v18.16b
|
||||
aesmc v2.16b, v2.16b // AES block 2 - round 0
|
||||
@@ -873,7 +865,7 @@ aes_gcm_dec_kernel:
|
||||
ldr q30, [x8, #192] // load rk12
|
||||
aese v0.16b, v20.16b
|
||||
aesmc v0.16b, v0.16b // AES block 0 - round 2
|
||||
ldr q12, [x3, #32] // load h1l | h1h
|
||||
ldr q12, [x6] // load h1l | h1h
|
||||
ext v12.16b, v12.16b, v12.16b, #8
|
||||
aese v2.16b, v20.16b
|
||||
aesmc v2.16b, v2.16b // AES block 2 - round 2
|
||||
@@ -1562,11 +1554,7 @@ aes_gcm_dec_kernel:
|
||||
ret
|
||||
.size aes_gcm_dec_kernel,.-aes_gcm_dec_kernel
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(__AARCH64EL__) && defined(__ELF__)
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(OPENSSL_AARCH64) && defined(__ELF__)
|
||||
#endif // defined(__aarch64__) && defined(__linux__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,17 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if !defined(__has_feature)
|
||||
#define __has_feature(x) 0
|
||||
#endif
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__ARMEL__) && defined(__APPLE__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_ARM) && defined(__APPLE__)
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
|
||||
@ Silence ARMv8 deprecated IT instruction warnings. This file is used by both
|
||||
@@ -981,11 +973,7 @@ OPENSSL_armcap_P:
|
||||
.long 0
|
||||
.private_extern _OPENSSL_armcap_P
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(__ARMEL__) && defined(__APPLE__)
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(OPENSSL_ARM) && defined(__APPLE__)
|
||||
#endif // defined(__arm__) && defined(__APPLE__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,17 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if !defined(__has_feature)
|
||||
#define __has_feature(x) 0
|
||||
#endif
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__ARMEL__) && defined(__ELF__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_ARM) && defined(__ELF__)
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
|
||||
@ Silence ARMv8 deprecated IT instruction warnings. This file is used by both
|
||||
@@ -973,11 +965,7 @@ bn_mul8x_mont_neon:
|
||||
.comm OPENSSL_armcap_P,4,4
|
||||
.hidden OPENSSL_armcap_P
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(__ARMEL__) && defined(__ELF__)
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(OPENSSL_ARM) && defined(__ELF__)
|
||||
#endif // defined(__arm__) && defined(__linux__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,17 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if !defined(__has_feature)
|
||||
#define __has_feature(x) 0
|
||||
#endif
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__AARCH64EL__) && defined(__APPLE__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_AARCH64) && defined(__APPLE__)
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
|
||||
.text
|
||||
@@ -1432,11 +1424,7 @@ Lmul4x_done:
|
||||
.byte 77,111,110,116,103,111,109,101,114,121,32,77,117,108,116,105,112,108,105,99,97,116,105,111,110,32,102,111,114,32,65,82,77,118,56,44,32,67,82,89,80,84,79,71,65,77,83,32,98,121,32,60,97,112,112,114,111,64,111,112,101,110,115,115,108,46,111,114,103,62,0
|
||||
.align 2
|
||||
.align 4
|
||||
#endif // !OPENSSL_NO_ASM && defined(__AARCH64EL__) && defined(__APPLE__)
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(OPENSSL_AARCH64) && defined(__APPLE__)
|
||||
#endif // defined(__aarch64__) && defined(__APPLE__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,17 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if !defined(__has_feature)
|
||||
#define __has_feature(x) 0
|
||||
#endif
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__AARCH64EL__) && defined(__ELF__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_AARCH64) && defined(__ELF__)
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
|
||||
.text
|
||||
@@ -1432,11 +1424,7 @@ __bn_mul4x_mont:
|
||||
.byte 77,111,110,116,103,111,109,101,114,121,32,77,117,108,116,105,112,108,105,99,97,116,105,111,110,32,102,111,114,32,65,82,77,118,56,44,32,67,82,89,80,84,79,71,65,77,83,32,98,121,32,60,97,112,112,114,111,64,111,112,101,110,115,115,108,46,111,114,103,62,0
|
||||
.align 2
|
||||
.align 4
|
||||
#endif // !OPENSSL_NO_ASM && defined(__AARCH64EL__) && defined(__ELF__)
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(OPENSSL_AARCH64) && defined(__ELF__)
|
||||
#endif // defined(__aarch64__) && defined(__linux__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,16 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if defined(__has_feature)
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__i386__) && defined(__ELF__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86) && defined(__ELF__)
|
||||
.text
|
||||
.globl bn_mul_add_words
|
||||
.hidden bn_mul_add_words
|
||||
@@ -1001,11 +994,7 @@ bn_sub_words:
|
||||
popl %ebp
|
||||
ret
|
||||
.size bn_sub_words,.-.L_bn_sub_words_begin
|
||||
#endif // !defined(OPENSSL_NO_ASM) && defined(__i386__) && defined(__ELF__)
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86) && defined(__ELF__)
|
||||
#endif // defined(__i386__) && defined(__linux__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,17 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if !defined(__has_feature)
|
||||
#define __has_feature(x) 0
|
||||
#endif
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__AARCH64EL__) && defined(__APPLE__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_AARCH64) && defined(__APPLE__)
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
|
||||
.text
|
||||
@@ -96,11 +88,7 @@ Lsub_exit:
|
||||
cset x0, cc
|
||||
ret
|
||||
|
||||
#endif // !OPENSSL_NO_ASM && defined(__AARCH64EL__) && defined(__APPLE__)
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(OPENSSL_AARCH64) && defined(__APPLE__)
|
||||
#endif // defined(__aarch64__) && defined(__APPLE__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,17 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if !defined(__has_feature)
|
||||
#define __has_feature(x) 0
|
||||
#endif
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__AARCH64EL__) && defined(__ELF__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_AARCH64) && defined(__ELF__)
|
||||
#include <CCryptoBoringSSL_arm_arch.h>
|
||||
|
||||
.text
|
||||
@@ -96,11 +88,7 @@ bn_sub_words:
|
||||
cset x0, cc
|
||||
ret
|
||||
.size bn_sub_words,.-bn_sub_words
|
||||
#endif // !OPENSSL_NO_ASM && defined(__AARCH64EL__) && defined(__ELF__)
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(OPENSSL_AARCH64) && defined(__ELF__)
|
||||
#endif // defined(__aarch64__) && defined(__linux__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -711,15 +711,22 @@ int BN_mod_lshift(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m,
|
||||
|
||||
int bn_mod_lshift_consttime(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m,
|
||||
BN_CTX *ctx) {
|
||||
if (!BN_copy(r, a)) {
|
||||
if (!BN_copy(r, a) ||
|
||||
!bn_resize_words(r, m->width)) {
|
||||
return 0;
|
||||
}
|
||||
for (int i = 0; i < n; i++) {
|
||||
if (!bn_mod_lshift1_consttime(r, r, m, ctx)) {
|
||||
return 0;
|
||||
|
||||
BN_CTX_start(ctx);
|
||||
BIGNUM *tmp = bn_scratch_space_from_ctx(m->width, ctx);
|
||||
int ok = tmp != NULL;
|
||||
if (ok) {
|
||||
for (int i = 0; i < n; i++) {
|
||||
bn_mod_add_words(r->d, r->d, r->d, m->d, tmp->d, m->width);
|
||||
}
|
||||
r->neg = 0;
|
||||
}
|
||||
return 1;
|
||||
BN_CTX_end(ctx);
|
||||
return ok;
|
||||
}
|
||||
|
||||
int BN_mod_lshift_quick(BIGNUM *r, const BIGNUM *a, int n, const BIGNUM *m) {
|
||||
|
||||
@@ -263,15 +263,14 @@ int BN_mod_inverse_odd(BIGNUM *out, int *out_no_inverse, const BIGNUM *a,
|
||||
// Now Y*a == A (mod |n|).
|
||||
|
||||
// Y*a == 1 (mod |n|)
|
||||
if (!Y->neg && BN_ucmp(Y, n) < 0) {
|
||||
if (!BN_copy(R, Y)) {
|
||||
goto err;
|
||||
}
|
||||
} else {
|
||||
if (!BN_nnmod(R, Y, n, ctx)) {
|
||||
if (Y->neg || BN_ucmp(Y, n) >= 0) {
|
||||
if (!BN_nnmod(Y, Y, n, ctx)) {
|
||||
goto err;
|
||||
}
|
||||
}
|
||||
if (!BN_copy(R, Y)) {
|
||||
goto err;
|
||||
}
|
||||
|
||||
ret = 1;
|
||||
|
||||
|
||||
@@ -431,12 +431,11 @@ void bn_power5(BN_ULONG *rp, const BN_ULONG *ap, const BN_ULONG *table,
|
||||
|
||||
uint64_t bn_mont_n0(const BIGNUM *n);
|
||||
|
||||
// bn_mod_exp_base_2_consttime calculates r = 2**p (mod n). |p| must be larger
|
||||
// than log_2(n); i.e. 2**p must be larger than |n|. |n| must be positive and
|
||||
// odd. |p| and the bit width of |n| are assumed public, but |n| is otherwise
|
||||
// treated as secret.
|
||||
int bn_mod_exp_base_2_consttime(BIGNUM *r, unsigned p, const BIGNUM *n,
|
||||
BN_CTX *ctx);
|
||||
// bn_mont_ctx_set_RR_consttime initializes |mont->RR|. It returns one on
|
||||
// success and zero on error. |mont->N| and |mont->n0| must have been
|
||||
// initialized already. The bit width of |mont->N| is assumed public, but
|
||||
// |mont->N| is otherwise treated as secret.
|
||||
int bn_mont_ctx_set_RR_consttime(BN_MONT_CTX *mont, BN_CTX *ctx);
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#if defined(OPENSSL_X86_64)
|
||||
@@ -600,6 +599,13 @@ OPENSSL_EXPORT int bn_is_relatively_prime(int *out_relatively_prime,
|
||||
OPENSSL_EXPORT int bn_lcm_consttime(BIGNUM *r, const BIGNUM *a, const BIGNUM *b,
|
||||
BN_CTX *ctx);
|
||||
|
||||
// bn_mont_ctx_init zero-initialies |mont|.
|
||||
void bn_mont_ctx_init(BN_MONT_CTX *mont);
|
||||
|
||||
// bn_mont_ctx_cleanup releases memory associated with |mont|, without freeing
|
||||
// |mont| itself.
|
||||
void bn_mont_ctx_cleanup(BN_MONT_CTX *mont);
|
||||
|
||||
|
||||
// Constant-time modular arithmetic.
|
||||
//
|
||||
|
||||
@@ -121,17 +121,24 @@
|
||||
#include "../../internal.h"
|
||||
|
||||
|
||||
void bn_mont_ctx_init(BN_MONT_CTX *mont) {
|
||||
OPENSSL_memset(mont, 0, sizeof(BN_MONT_CTX));
|
||||
BN_init(&mont->RR);
|
||||
BN_init(&mont->N);
|
||||
}
|
||||
|
||||
void bn_mont_ctx_cleanup(BN_MONT_CTX *mont) {
|
||||
BN_free(&mont->RR);
|
||||
BN_free(&mont->N);
|
||||
}
|
||||
|
||||
BN_MONT_CTX *BN_MONT_CTX_new(void) {
|
||||
BN_MONT_CTX *ret = OPENSSL_malloc(sizeof(BN_MONT_CTX));
|
||||
|
||||
if (ret == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
OPENSSL_memset(ret, 0, sizeof(BN_MONT_CTX));
|
||||
BN_init(&ret->RR);
|
||||
BN_init(&ret->N);
|
||||
|
||||
bn_mont_ctx_init(ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@@ -140,8 +147,7 @@ void BN_MONT_CTX_free(BN_MONT_CTX *mont) {
|
||||
return;
|
||||
}
|
||||
|
||||
BN_free(&mont->RR);
|
||||
BN_free(&mont->N);
|
||||
bn_mont_ctx_cleanup(mont);
|
||||
OPENSSL_free(mont);
|
||||
}
|
||||
|
||||
@@ -248,19 +254,12 @@ BN_MONT_CTX *BN_MONT_CTX_new_for_modulus(const BIGNUM *mod, BN_CTX *ctx) {
|
||||
BN_MONT_CTX *BN_MONT_CTX_new_consttime(const BIGNUM *mod, BN_CTX *ctx) {
|
||||
BN_MONT_CTX *mont = BN_MONT_CTX_new();
|
||||
if (mont == NULL ||
|
||||
!bn_mont_ctx_set_N_and_n0(mont, mod)) {
|
||||
goto err;
|
||||
}
|
||||
unsigned lgBigR = mont->N.width * BN_BITS2;
|
||||
if (!bn_mod_exp_base_2_consttime(&mont->RR, lgBigR * 2, &mont->N, ctx) ||
|
||||
!bn_resize_words(&mont->RR, mont->N.width)) {
|
||||
goto err;
|
||||
!bn_mont_ctx_set_N_and_n0(mont, mod) ||
|
||||
!bn_mont_ctx_set_RR_consttime(mont, ctx)) {
|
||||
BN_MONT_CTX_free(mont);
|
||||
return NULL;
|
||||
}
|
||||
return mont;
|
||||
|
||||
err:
|
||||
BN_MONT_CTX_free(mont);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int BN_MONT_CTX_set_locked(BN_MONT_CTX **pmont, CRYPTO_MUTEX *lock,
|
||||
|
||||
@@ -159,27 +159,63 @@ static uint64_t bn_neg_inv_mod_r_u64(uint64_t n) {
|
||||
return v;
|
||||
}
|
||||
|
||||
int bn_mod_exp_base_2_consttime(BIGNUM *r, unsigned p, const BIGNUM *n,
|
||||
BN_CTX *ctx) {
|
||||
assert(!BN_is_zero(n));
|
||||
assert(!BN_is_negative(n));
|
||||
assert(BN_is_odd(n));
|
||||
int bn_mont_ctx_set_RR_consttime(BN_MONT_CTX *mont, BN_CTX *ctx) {
|
||||
assert(!BN_is_zero(&mont->N));
|
||||
assert(!BN_is_negative(&mont->N));
|
||||
assert(BN_is_odd(&mont->N));
|
||||
assert(bn_minimal_width(&mont->N) == mont->N.width);
|
||||
|
||||
BN_zero(r);
|
||||
|
||||
unsigned n_bits = BN_num_bits(n);
|
||||
unsigned n_bits = BN_num_bits(&mont->N);
|
||||
assert(n_bits != 0);
|
||||
assert(p > n_bits);
|
||||
if (n_bits == 1) {
|
||||
return 1;
|
||||
BN_zero(&mont->RR);
|
||||
return bn_resize_words(&mont->RR, mont->N.width);
|
||||
}
|
||||
|
||||
// Set |r| to the larger power of two smaller than |n|, then shift with
|
||||
// reductions the rest of the way.
|
||||
if (!BN_set_bit(r, n_bits - 1) ||
|
||||
!bn_mod_lshift_consttime(r, r, p - (n_bits - 1), n, ctx)) {
|
||||
unsigned lgBigR = mont->N.width * BN_BITS2;
|
||||
assert(lgBigR >= n_bits);
|
||||
|
||||
// RR is R, or 2^lgBigR, in the Montgomery domain. We can compute 2 in the
|
||||
// Montgomery domain, 2R or 2^(lgBigR+1), and then use Montgomery
|
||||
// square-and-multiply to exponentiate.
|
||||
//
|
||||
// The multiply steps take 2^n R to 2^(n+1) R. It is faster to double
|
||||
// the value instead. The square steps take 2^n R to 2^(2n) R. This is
|
||||
// equivalent to doubling n times. When n is below some threshold, doubling is
|
||||
// faster. When above, squaring is faster.
|
||||
//
|
||||
// We double to this threshold, then switch to Montgomery squaring. From
|
||||
// benchmarking various 32-bit and 64-bit architectures, the word count seems
|
||||
// to work well as a threshold. (Doubling scales linearly and Montgomery
|
||||
// reduction scales quadratically, so the threshold should scale roughly
|
||||
// linearly.)
|
||||
unsigned threshold = mont->N.width;
|
||||
unsigned iters;
|
||||
for (iters = 0; iters < sizeof(lgBigR) * 8; iters++) {
|
||||
if ((lgBigR >> iters) <= threshold) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Compute 2^(lgBigR >> iters) R, or 2^((lgBigR >> iters) + lgBigR), by
|
||||
// doubling. The first n_bits - 1 doubles can be skipped because we don't need
|
||||
// to reduce.
|
||||
if (!BN_set_bit(&mont->RR, n_bits - 1) ||
|
||||
!bn_mod_lshift_consttime(&mont->RR, &mont->RR,
|
||||
(lgBigR >> iters) + lgBigR - (n_bits - 1),
|
||||
&mont->N, ctx)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
for (unsigned i = iters - 1; i < iters; i--) {
|
||||
if (!BN_mod_mul_montgomery(&mont->RR, &mont->RR, &mont->RR, mont, ctx)) {
|
||||
return 0;
|
||||
}
|
||||
if ((lgBigR & (1u << i)) != 0 &&
|
||||
!bn_mod_lshift1_consttime(&mont->RR, &mont->RR, &mont->N, ctx)) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
return bn_resize_words(&mont->RR, mont->N.width);
|
||||
}
|
||||
@@ -24,13 +24,13 @@
|
||||
#include "../../internal.h"
|
||||
|
||||
|
||||
// one is 1 in RSAZ's representation.
|
||||
alignas(64) static const BN_ULONG one[40] = {
|
||||
// rsaz_one is 1 in RSAZ's representation.
|
||||
alignas(64) static const BN_ULONG rsaz_one[40] = {
|
||||
1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
|
||||
// two80 is 2^80 in RSAZ's representation. Note RSAZ uses base 2^29, so this is
|
||||
// rsaz_two80 is 2^80 in RSAZ's representation. Note RSAZ uses base 2^29, so this is
|
||||
// 2^(29*2 + 22) = 2^80, not 2^(64*2 + 22).
|
||||
alignas(64) static const BN_ULONG two80[40] = {
|
||||
alignas(64) static const BN_ULONG rsaz_two80[40] = {
|
||||
0, 0, 1 << 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
|
||||
|
||||
@@ -64,12 +64,12 @@ void RSAZ_1024_mod_exp_avx2(BN_ULONG result_norm[16],
|
||||
// giving R = 2^(36*29) = 2^1044.
|
||||
rsaz_1024_mul_avx2(R2, R2, R2, m, k0);
|
||||
// R2 = 2^2048 * 2^2048 / 2^1044 = 2^3052
|
||||
rsaz_1024_mul_avx2(R2, R2, two80, m, k0);
|
||||
rsaz_1024_mul_avx2(R2, R2, rsaz_two80, m, k0);
|
||||
// R2 = 2^3052 * 2^80 / 2^1044 = 2^2088 = (2^1044)^2
|
||||
|
||||
// table[0] = 1
|
||||
// table[1] = a_inv^1
|
||||
rsaz_1024_mul_avx2(result, R2, one, m, k0);
|
||||
rsaz_1024_mul_avx2(result, R2, rsaz_one, m, k0);
|
||||
rsaz_1024_mul_avx2(a_inv, a_inv, R2, m, k0);
|
||||
rsaz_1024_scatter5_avx2(table_s, result, 0);
|
||||
rsaz_1024_scatter5_avx2(table_s, a_inv, 1);
|
||||
@@ -125,7 +125,7 @@ void RSAZ_1024_mod_exp_avx2(BN_ULONG result_norm[16],
|
||||
rsaz_1024_mul_avx2(result, result, a_inv, m, k0);
|
||||
|
||||
// Convert from Montgomery.
|
||||
rsaz_1024_mul_avx2(result, result, one, m, k0);
|
||||
rsaz_1024_mul_avx2(result, result, rsaz_one, m, k0);
|
||||
|
||||
rsaz_1024_red2norm_avx2(result_norm, result);
|
||||
BN_ULONG scratch[16];
|
||||
|
||||
@@ -3,17 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if !defined(__has_feature)
|
||||
#define __has_feature(x) 0
|
||||
#endif
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__ARMEL__) && defined(__APPLE__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_ARM) && defined(__APPLE__)
|
||||
@ Copyright 2012-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
@
|
||||
@ Licensed under the OpenSSL license (the "License"). You may not use
|
||||
@@ -1535,11 +1527,7 @@ Lctr_enc_bzero:@ wipe key schedule [if any]
|
||||
@ out to retain a constant-time implementation.
|
||||
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(__ARMEL__) && defined(__APPLE__)
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(OPENSSL_ARM) && defined(__APPLE__)
|
||||
#endif // defined(__arm__) && defined(__APPLE__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,17 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if !defined(__has_feature)
|
||||
#define __has_feature(x) 0
|
||||
#endif
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__ARMEL__) && defined(__ELF__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_ARM) && defined(__ELF__)
|
||||
@ Copyright 2012-2016 The OpenSSL Project Authors. All Rights Reserved.
|
||||
@
|
||||
@ Licensed under the OpenSSL license (the "License"). You may not use
|
||||
@@ -1525,11 +1517,7 @@ bsaes_ctr32_encrypt_blocks:
|
||||
@ out to retain a constant-time implementation.
|
||||
.size bsaes_ctr32_encrypt_blocks,.-bsaes_ctr32_encrypt_blocks
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(__ARMEL__) && defined(__ELF__)
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // !OPENSSL_NO_ASM && defined(OPENSSL_ARM) && defined(__ELF__)
|
||||
#endif // defined(__arm__) && defined(__linux__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -3,16 +3,9 @@
|
||||
// This file is generated from a similarly-named Perl script in the BoringSSL
|
||||
// source tree. Do not edit by hand.
|
||||
|
||||
#if defined(__has_feature)
|
||||
#if __has_feature(memory_sanitizer) && !defined(OPENSSL_NO_ASM)
|
||||
#define OPENSSL_NO_ASM
|
||||
#endif
|
||||
#endif
|
||||
#include <CCryptoBoringSSL_asm_base.h>
|
||||
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(__i386__) && defined(__ELF__)
|
||||
#if defined(BORINGSSL_PREFIX)
|
||||
#include <CCryptoBoringSSL_boringssl_prefix_symbols_asm.h>
|
||||
#endif
|
||||
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86) && defined(__ELF__)
|
||||
.text
|
||||
.globl bn_mul_comba8
|
||||
.hidden bn_mul_comba8
|
||||
@@ -1270,11 +1263,7 @@ bn_sqr_comba4:
|
||||
popl %esi
|
||||
ret
|
||||
.size bn_sqr_comba4,.-.L_bn_sqr_comba4_begin
|
||||
#endif // !defined(OPENSSL_NO_ASM) && defined(__i386__) && defined(__ELF__)
|
||||
#if defined(__ELF__)
|
||||
// See https://www.airs.com/blog/archives/518.
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
#endif
|
||||
#endif // !defined(OPENSSL_NO_ASM) && defined(OPENSSL_X86) && defined(__ELF__)
|
||||
#endif // defined(__i386__) && defined(__linux__)
|
||||
#if defined(__linux__) && defined(__ELF__)
|
||||
.section .note.GNU-stack,"",%progbits
|
||||
|
||||
@@ -27,9 +27,8 @@
|
||||
type *name##_bss_get(void) __attribute__((const));
|
||||
// For FIPS builds we require that CRYPTO_ONCE_INIT be zero.
|
||||
#define DEFINE_STATIC_ONCE(name) DEFINE_BSS_GET(CRYPTO_once_t, name)
|
||||
// For FIPS builds we require that CRYPTO_STATIC_MUTEX_INIT be zero.
|
||||
#define DEFINE_STATIC_MUTEX(name) \
|
||||
DEFINE_BSS_GET(struct CRYPTO_STATIC_MUTEX, name)
|
||||
// For FIPS builds we require that CRYPTO_MUTEX_INIT be zero.
|
||||
#define DEFINE_STATIC_MUTEX(name) DEFINE_BSS_GET(CRYPTO_MUTEX, name)
|
||||
// For FIPS builds we require that CRYPTO_EX_DATA_CLASS_INIT be zero.
|
||||
#define DEFINE_STATIC_EX_DATA_CLASS(name) \
|
||||
DEFINE_BSS_GET(CRYPTO_EX_DATA_CLASS, name)
|
||||
@@ -40,9 +39,9 @@
|
||||
#define DEFINE_STATIC_ONCE(name) \
|
||||
static CRYPTO_once_t name = CRYPTO_ONCE_INIT; \
|
||||
static CRYPTO_once_t *name##_bss_get(void) { return &name; }
|
||||
#define DEFINE_STATIC_MUTEX(name) \
|
||||
static struct CRYPTO_STATIC_MUTEX name = CRYPTO_STATIC_MUTEX_INIT; \
|
||||
static struct CRYPTO_STATIC_MUTEX *name##_bss_get(void) { return &name; }
|
||||
#define DEFINE_STATIC_MUTEX(name) \
|
||||
static CRYPTO_MUTEX name = CRYPTO_MUTEX_INIT; \
|
||||
static CRYPTO_MUTEX *name##_bss_get(void) { return &name; }
|
||||
#define DEFINE_STATIC_EX_DATA_CLASS(name) \
|
||||
static CRYPTO_EX_DATA_CLASS name = CRYPTO_EX_DATA_CLASS_INIT; \
|
||||
static CRYPTO_EX_DATA_CLASS *name##_bss_get(void) { return &name; }
|
||||
|
||||
@@ -177,6 +177,9 @@ int DH_set0_pqg(DH *dh, BIGNUM *p, BIGNUM *q, BIGNUM *g) {
|
||||
dh->g = g;
|
||||
}
|
||||
|
||||
// Invalidate the cached Montgomery parameters.
|
||||
BN_MONT_CTX_free(dh->method_mont_p);
|
||||
dh->method_mont_p = NULL;
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
Loaded 100 of 413 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user