Compare commits

...
42 Commits
Author SHA1 Message Date
Rick Newton-Rogers a98e4be0dd Only apply standard swift settings on valid targets (#333)
Only apply standard swift settings on valid targets. The current check
ignores plugins but that is not comprehensive enough.
2025-03-07 15:05:19 +00:00
Gus CairoandCory Benfield f4c4efd424 Replace platforms from Package manifest with availability guards (#331)
Minimum deployment versions in package manifests can be problematic for
libraries, because changing them or adding them to an existing package
that doesn't already use them forces SemVer breaking majors.

Furthermore, depending on a new library that specifies minimum
deployment targets would force the adopting library to also have to add
these platforms to its manifest (which would in turn force a major).

This PR removes the platforms stanza from the package manifest and
replaces them with availability guards.
This will allow more packages to use swift-crypto, without forcing them
to mint new majors to support the appropriate platforms.

---------

Co-authored-by: Cory Benfield <lukasa@apple.com>
2025-03-04 15:15:32 +00:00
Rick Newton-Rogers 7ba43666c5 Rename nightly_6_1 params to nightly_next (#332)
Rename nightly_6_1 params to nightly_next; see
https://github.com/apple/swift-nio/pull/3122
2025-03-03 14:49:11 +00:00
Cory Benfield 45305d32cf Add missing availability on ARC types (#330)
Motivation

We should have proper availability annotations.

Modifications

Propagate the availability annotations we need.

Result

Compiles correctly on non-macOS platforms.
2025-02-17 18:37:06 +00:00
Chris McGee b6049c0b2e Fix CMakeLists.txt for Windows (#326)
This change prepares swift-crypto for use on Windows with CMake and also
the Package.swift for use in the Swift toolchain CI system.

### Checklist
- [X] I've run tests to see all new and existing tests pass
- [X] I've followed the code style of the rest of the project
- [X] I've read the [Contribution Guidelines](CONTRIBUTING.md)
- [X] I've updated the documentation if necessary

#### If you've made changes to `gyb` files
- [X] I've run `.script/generate_boilerplate_files_with_gyb` and
included updated generated files in a commit of this pull request

### Motivation:

Upgrading swift-crypto from an older version requires that Windows works
properly with CMake, and also SwiftPM.

### Modifications:

Modify the CMakeLists.txt files and the generator script so that it
conditionally adds assembly files for non-Windows platforms. Prepare the
Package.swift file for use in Swift CI pipelines, by consulting an
environment to either use the absolute URL, or a prepared version of the
swift-asn1 dependency.

### Result:

After this change it should be possible to build with the newest
swift-crypto in the Swift CI system.
2025-02-14 13:37:49 +00:00
Si Beaumont b81059d507 extras: Add API for Anonymous Rate-Limited Credentials, ARC(P-384) (#328)
## Motivation

We would like to provide support for ARCV1(P-384), as defined in [IETF
Internet Draft: Anonymous Rate-Limited
Credentials](https://datatracker.ietf.org/doc/draft-yun-cfrg-arc/).

## Modifications

- Add internal implementation, generic over the NIST curves.
- Add public API for ARC(P-384), under `P384._ARCV1`.

## Result

New API for current draft of ARC.

## Tests

- End to end tests of internal implementation and API surface.
- Test vector tests of internal implementation and API surface, from the
spec draft.
2025-02-14 10:49:59 +00:00
Chris McGee 06fc9b0a09 Add workaround for missing multi-threaded dll support on windows clang/ASM (#325)
When building using CMake with Windows, there is an error regarding
missing MultithreadedDLL support. Work around this by setting the
MSVC_RUNTIME_LIBRARY on that platform to a supported option.

### Checklist
- [X] I've run tests to see all new and existing tests pass
- [X] I've followed the code style of the rest of the project
- [X] I've read the [Contribution Guidelines](CONTRIBUTING.md)
- [X] I've updated the documentation if necessary

#### If you've made changes to `gyb` files
- [X] I've run `.script/generate_boilerplate_files_with_gyb` and
included updated generated files in a commit of this pull request

### Motivation:

I'm trying to build swift-crypto on Windows with CMake.

### Modifications:

I've modified the CMakelists.txt such that the clang can compile the
assembly files on Windows.

### Result:

Hopefully, Windows builds of swift-crypto are working.
2025-02-11 13:39:38 +00:00
Chris McGee 472de789e9 Fix macos build failures cmake (#324)
Remove the extra true values for the swift defines in the CryptoExtras
modules CMakeLists.txt file.

### Checklist
- [X] I've run tests to see all new and existing tests pass
- [X] I've followed the code style of the rest of the project
- [X] I've read the [Contribution Guidelines](CONTRIBUTING.md)
- [X] I've updated the documentation if necessary

#### If you've made changes to `gyb` files
- [X] I've run `.script/generate_boilerplate_files_with_gyb` and
included updated generated files in a commit of this pull request

### Motivation:

The defines don't take effect with a value. Remove the value "true" from
them.

### Modifications:

Modified the CMakeLists.txt file in the CryptoExtras module.

### Result:

After the change the swift defines will hopefully be defined correctly.
2025-02-11 12:21:43 +00:00
Chris McGee 75a3eca905 Add the necessary swift defines in CMake for Crypto module (#323)
### Checklist
- [X] I've run tests to see all new and existing tests pass
- [X] I've followed the code style of the rest of the project
- [X] I've read the [Contribution Guidelines](CONTRIBUTING.md)
- [X] I've updated the documentation if necessary

#### If you've made changes to `gyb` files
- [X] I've run `.script/generate_boilerplate_files_with_gyb` and
included updated generated files in a commit of this pull request

### Motivation:

When building SwiftPM with CMake and the swift-crypto package there are
errors being produced on macOS relating to missing imports provided by
the CryptoKit package.

### Modifications:

Modify the CMakeLists.txt file for the Crypto target so that the defines
are set like they are in the Package.swift.

### Result:

After the change, building SwiftPM with CMake on macOS should work.
2025-02-10 17:10:44 +00:00
Chris McGee b828ba476a Add missing assembly files to CMake and generator script (#322)
Update both the CMakeLists.txt for CCryptoBoringSSL and the
CMakeLists.txt generator so that it can add platform-independent
assembly files.

### Checklist
- [X] I've run tests to see all new and existing tests pass
- [X] I've followed the code style of the rest of the project
- [X] I've read the [Contribution Guidelines](CONTRIBUTING.md)
- [X] I've updated the documentation if necessary

#### If you've made changes to `gyb` files
- [X] I've run `./scripts/generate_boilerplate_files_with_gyb` and
included updated generated files in a commit of this pull request

### Motivation:

There are downstream linker failures due to missing symbols from certain
platform neutral assembly files.

### Modifications:

The `scripts/update-cmake-lists.sh` has an updated find expression to
discover platform-independent assembly files and includes them in the
`CMakeLists.txt` files.

### Result:

There will be more symbols included from third-parties such as
BoringSSL.
2025-02-10 09:06:08 +00:00
Rick Newton-Rogers f2f3774fd1 CI use 6.1 nightlies (#321)
CI use 6.1 nightlies now that Swift development is happening in the 6.1
branch
2025-01-30 09:45:03 +00:00
Franz Busch a84771015f Update release.yml (#316)
Update the release.yml file with the latest label changes
2024-12-18 13:10:17 +00:00
Rick Newton-Rogers 2934bb4cf8 Enable MemberImportVisibility check on all targets (#310)
Enable MemberImportVisibility check on all targets. Use a standard
string header and footer to bracket the new block for ease of updating
in the future with scripts.
2024-12-17 10:57:39 +00:00
Francesco Paolo SeverinoandCory Benfield 0bf9f479b8 Improve DocC landing pages (#313)
Improve DocC landing pages by mimicking Apple's CryptoKit docs

### Motivation:

Right now the DocC docs group all APIs by protocols, structures and
enums.
By adding a topics section in the landing page we can group them by type
("Ciphers", "Public key cryptography", etc.) exactly in the way Apple
does in [CryptoKit
docs](https://developer.apple.com/documentation/cryptokit/).

### Modifications:

- Fix DocC compilation errors in `_CryptoExtras`
- Add topics section in `_CryptoExtras` landing page
- Add topics section in `Crypto` landing page

### Result:

APIs will be grouped by type.

---------

Co-authored-by: Cory Benfield <lukasa@apple.com>
2024-12-16 12:52:12 +00:00
michael-yuji bce1725222 FreeBSD support (#315)
Fix FreeBSD support

### Checklist
- [x] I've run tests to see all new and existing tests pass
- [x] I've followed the code style of the rest of the project
- [x] I've read the [Contribution Guidelines](CONTRIBUTING.md)
- [x] I've updated the documentation if necessary

### Motivation:
To add FreeBSD support to Swift, we must ensure that swift crypto builds
on FreeBSD since it's a dependency of swiftpm and several essential
packages.

### Modifications:
- `Package.swift` - Ideally FreeBSD should use `.when(platforms:)` to
set the corresponding swift settings and dependencies. However,
`Platform.freebsd` is not yet available on swiftpm and therefore use
guard the settings behind a `isFreeBSD` boolean flag. This is chosen
because it minimize the diff and maintains the maximum readability.
- `cmake/modules/SwiftSupport.cmake` - add `amd64` arch support, maps to
`x86_64`.
- `**/CMakeLists.txt` - Use the Linux assembly files for FreeBSD. Both
Linux and FreeBSD uses SysV ABI, and there're no syscalls involved
(after all, they're supposed to be "pure") so there are no ABI
compatibility problem. After all, all the tests are passing on FreeBSD
with this PR.

### Result:
All the tests (via `swift test`) passed on x86_64 FreeBSD 14.1-p6, and
passed on aarch64 macOS.

Test log available here:
[swift-test-result.txt](https://github.com/user-attachments/files/18147920/swift-test-result.txt)
2024-12-16 12:26:11 +00:00
Cory Benfield 555b9f1dab Update BoringSSL to aefa5d24da34ef77ac797bdbe684734e5bd870f4 (#312)
Update BoringSSL to aefa5d24da34ef77ac797bdbe684734e5bd870f4, and modify
the vendoring script to reduce our warnings.
2024-12-13 14:07:54 +00:00
Tim Condon 600eda380a Fix DocC generation (#311)
Fix DocC generation. Force Linux build on SPI to get it to render the
Crypto docs

### Motivation:

Currently the Crypto docs are empty on SPI because they're built on
macOS where there are no symbols. CryptoExtras index page also doesn't
work because of a name mismatch

### Modifications:

Force Linux build on SPI, fix name for extras documentation

### Result:

Working Docs
2024-12-13 13:06:47 +00:00
Tim Condon 865068322c Add Intial DocC docs (#283)
Adds some additional documentation. I don't know how far you want me to
go with documenting everything so let me know. This should at least get
the current APIs rendered on SPI. As an aside I'm not a huge fan of
linking out to the CryptoKit docs since not everything is available
here, all the code is already documented here and most of the tutorials
and articles on developer.apple.com for CryptoKit refer to Apple
Platform specific stuff, like interacting with the keychain, that is not
applicable here.

Resolves #273 

### Checklist
- [x] I've run tests to see all new and existing tests pass
- [x] I've followed the code style of the rest of the project
- [x] I've read the [Contribution Guidelines](CONTRIBUTING.md)
- [x] I've updated the documentation if necessary

#### If you've made changes to `gyb` files
- [x] I've run `.script/generate_boilerplate_files_with_gyb` and
included updated generated files in a commit of this pull request

### Motivation:

Currently Swift Crypto has no documentation which is not great

### Modifications:

Adds additional DocC scaffolding to take advantage of the DocC comments
in Crypto and CryptoExtras. Adds an SPI config file for Swift Package
Index

### Result:

We will have some documentation
2024-12-12 16:38:42 +00:00
dc4c2c14e7 Enable swift-format in CI (#302)
## Motivation

As part of the Github Actions CI migration we held off enabling the
format check and moving to the same formatting rules as Swift NIO, but
we'd like to do that now.

## Modifications

- Add a script to generate (and update) the `.swiftformatignore` file
since this repo only wants to format a specific set of files matching a
pattern.
- Generate and commit the `.swiftformatignore` file.
- Run the fomatter and commit the results.
- Additional commits to satisfy the remaining linter rules that weren't
auto-fixed by swift-format.
- Enable the format check in CI.

## Result

- Code that's not shared is formatted with a style consistent with the
other repos this team maintain.
- CI is now checking code format again.

---------

Co-authored-by: Cory Benfield <lukasa@apple.com>
Co-authored-by: Rick Newton-Rogers <rnro@apple.com>
2024-11-28 14:46:23 +00:00
Franz Busch 0ec5ca1e3f Aligning semantic version label check name (#309) 2024-11-28 12:00:32 +00:00
Cory Benfield bd94260799 Update BoringSSL to fcef13a49852397a0d39c00be8d7bc2ba1ab6fb9 & include C++ files (#303)
* Update package vendoring script

* Update BoringSSL to fcef13a49852397a0d39c00be8d7bc2ba1ab6fb9

* Handle ERR_GET_ERR becoming a function

* Update CMake
2024-11-27 11:24:17 +00:00
Si Beaumont ff0f781cf7 extras: Add EC toolbox abstractions and OPRF(P-384, SHA-384) VOPRF API (#292)
## Motivation

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

## Modifications

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

## Results

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

## Tests

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

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

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

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

Importance:

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

Modifications:

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

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

Result:

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

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

* wrapper: Move EC types and random bytes into CryptoBoringWrapper

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

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

* address review + reset algorithm as well

* run update_cmakelists.sh

* attempt to fix the cmake build

* include FetchContent

* early return for non-PSS keys

* simplify code
2024-10-03 18:33:02 +01:00
Si Beaumont ffca28be3c crypto: Equatable and Hashable conformance for CryptoKitError and CryptoKitASN1Error (#266) 2024-10-02 09:59:06 +01:00
Si Beaumont 35703579f6 Drop support for Swift 5.8 (#259) 2024-09-19 13:55:18 +01:00
George Barnett a24950b8aa Only include privacy manifest on Darwin (#257)
Motivation:

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

Modifications:

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

Result:

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

Motivation:

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

Modifications:

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

Result:

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

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

Modifications:

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

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

Result:

New APIs to fetch the key primitives.

---------

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

No files matched your search

+8
View File
@@ -0,0 +1,8 @@
root = true
[*]
indent_style = space
indent_size = 4
end_of_line = lf
insert_final_newline = true
trim_trailing_whitespace = true
+1 -1
View File
@@ -9,7 +9,7 @@ about: If something isn't working as expected
### New Issue Checklist
- [ ] I'm using the latest version of Swift Crypto (`main` branch)
- [ ] I read the [Contribution Guidelines](https://github.com/apple/swift-crypto/blob/master/CONTRIBUTING.md)
- [ ] I read the [Contribution Guidelines](https://github.com/apple/swift-crypto/blob/main/CONTRIBUTING.md)
- [ ] I searched for [existing GitHub issues](https://github.com/apple/swift-crypto/issues)
### Expected behavior
+2 -2
View File
@@ -6,8 +6,8 @@ about: Not sure how something works or how to implement some functionality? Ask
### Question Checklist
- [ ] I'm using the latest version of Swift Crypto (master branch)
- [ ] I read the [Contribution Guidelines](https://github.com/apple/swift-crypto/blob/master/CONTRIBUTING.md)
- [ ] I'm using the latest version of Swift Crypto (main branch)
- [ ] I read the [Contribution Guidelines](https://github.com/apple/swift-crypto/blob/main/CONTRIBUTING.md)
- [ ] I searched for [existing GitHub issues](https://github.com/apple/swift-crypto/issues)
### Question Subject
+2 -2
View File
@@ -8,8 +8,8 @@ about: If a recent release broke a feature (Please make sure you know the last k
### New Regression Checklist
- [ ] I'm using the latest version of Swift Crypto (master branch)
- [ ] I read the [Contribution Guidelines](https://github.com/apple/swift-crypto/blob/master/CONTRIBUTING.md)
- [ ] I'm using the latest version of Swift Crypto (main branch)
- [ ] I read the [Contribution Guidelines](https://github.com/apple/swift-crypto/blob/main/CONTRIBUTING.md)
- [ ] I searched for [existing GitHub issues](https://github.com/apple/swift-crypto/issues)
### Regression Information
+2 -2
View File
@@ -5,10 +5,10 @@ changelog:
- ⚠️ semver/major
- title: SemVer Minor
labels:
- semver/minor
- 🆕 semver/minor
- title: SemVer Patch
labels:
- semver/patch
- 🔨 semver/patch
- title: Other Changes
labels:
- semver/none
+22
View File
@@ -0,0 +1,22 @@
name: Main
on:
push:
branches: [main]
schedule:
- cron: "0 8,20 * * *"
jobs:
unit-tests:
name: Unit tests
uses: apple/swift-nio/.github/workflows/unit_tests.yml@main
with:
linux_5_9_arguments_override: "--explicit-target-dependency-import-check error"
linux_5_10_arguments_override: "--explicit-target-dependency-import-check error"
linux_6_0_arguments_override: "--explicit-target-dependency-import-check error"
linux_nightly_next_arguments_override: "--explicit-target-dependency-import-check error"
linux_nightly_main_arguments_override: "--explicit-target-dependency-import-check error"
cxx-interop:
name: Cxx interop
uses: apple/swift-nio/.github/workflows/cxx_interop.yml@main
+40
View File
@@ -0,0 +1,40 @@
name: PR
on:
pull_request:
types: [opened, reopened, synchronize]
jobs:
soundness:
name: Soundness
uses: swiftlang/github-workflows/.github/workflows/soundness.yml@main
with:
license_header_check_project_name: "SwiftCrypto"
docs_check_enabled: false
cmake-lists:
name: Check cmake lists
uses: apple/swift-nio/.github/workflows/swift_matrix.yml@main
with:
name: "Check cmake lists"
matrix_linux_command: ./scripts/check-cmake-lists.sh
unit-tests:
name: Unit tests
uses: apple/swift-nio/.github/workflows/unit_tests.yml@main
with:
linux_5_9_arguments_override: "--explicit-target-dependency-import-check error"
linux_5_10_arguments_override: "--explicit-target-dependency-import-check error"
linux_6_0_arguments_override: "--explicit-target-dependency-import-check error"
linux_nightly_next_arguments_override: "--explicit-target-dependency-import-check error"
linux_nightly_main_arguments_override: "--explicit-target-dependency-import-check error"
windows_6_0_enabled: true
windows_nightly_next_enabled: true
windows_nightly_main_enabled: true
windows_6_0_arguments_override: "--explicit-target-dependency-import-check error"
windows_nightly_next_arguments_override: "--explicit-target-dependency-import-check error"
windows_nightly_main_arguments_override: "--explicit-target-dependency-import-check error"
cxx-interop:
name: Cxx interop
uses: apple/swift-nio/.github/workflows/cxx_interop.yml@main
+18
View File
@@ -0,0 +1,18 @@
name: PR label
on:
pull_request:
types: [labeled, unlabeled, opened, reopened, synchronize]
jobs:
semver-label-check:
name: Semantic version label check
runs-on: ubuntu-latest
timeout-minutes: 1
steps:
- name: Checkout repository
uses: actions/checkout@v4
with:
persist-credentials: false
- name: Check for Semantic Version label
uses: apple/swift-nio/.github/actions/pull_request_semver_label_checker@main
+49
View File
@@ -0,0 +1,49 @@
.gitignore
**/.gitignore
.licenseignore
.unacceptablelanguageignore
.swiftformatignore
.gitattributes
.git-blame-ignore-revs
.mailfilter
.mailmap
.spi.yml
.swift-format
.editorconfig
.github/*
*.md
*.txt
*.yml
*.yaml
*.json
Package.swift
**/Package.swift
Package@-*.swift
**/Package@-*.swift
Package.resolved
**/Package.resolved
Makefile
*.modulemap
**/*.modulemap
**/*.docc/*
*.xcprivacy
**/*.xcprivacy
*.symlink
**/*.symlink
Dockerfile
**/Dockerfile
Snippets/*
dev/git.commit.template
dev/update-benchmark-thresholds
*.crt
**/*.crt
*.pem
**/*.pem
*.der
**/*.der
.swiftformat
Sources/CCryptoBoringSSL/*
**/*.swift.gyb
scripts/*.patch
scripts/gyb
scripts/gyb.py
+5
View File
@@ -0,0 +1,5 @@
version: 1
builder:
configs:
- documentation_targets: [Crypto, _CryptoExtras]
platform: linux
+62
View File
@@ -0,0 +1,62 @@
{
"version" : 1,
"indentation" : {
"spaces" : 4
},
"tabWidth" : 4,
"fileScopedDeclarationPrivacy" : {
"accessLevel" : "private"
},
"spacesAroundRangeFormationOperators" : false,
"indentConditionalCompilationBlocks" : false,
"indentSwitchCaseLabels" : false,
"lineBreakAroundMultilineExpressionChainComponents" : false,
"lineBreakBeforeControlFlowKeywords" : false,
"lineBreakBeforeEachArgument" : true,
"lineBreakBeforeEachGenericRequirement" : true,
"lineLength" : 120,
"maximumBlankLines" : 1,
"respectsExistingLineBreaks" : true,
"prioritizeKeepingFunctionOutputTogether" : true,
"rules" : {
"AllPublicDeclarationsHaveDocumentation" : false,
"AlwaysUseLiteralForEmptyCollectionInit" : false,
"AlwaysUseLowerCamelCase" : false,
"AmbiguousTrailingClosureOverload" : true,
"BeginDocumentationCommentWithOneLineSummary" : false,
"DoNotUseSemicolons" : true,
"DontRepeatTypeInStaticProperties" : true,
"FileScopedDeclarationPrivacy" : true,
"FullyIndirectEnum" : true,
"GroupNumericLiterals" : true,
"IdentifiersMustBeASCII" : true,
"NeverForceUnwrap" : false,
"NeverUseForceTry" : false,
"NeverUseImplicitlyUnwrappedOptionals" : false,
"NoAccessLevelOnExtensionDeclaration" : true,
"NoAssignmentInExpressions" : true,
"NoBlockComments" : true,
"NoCasesWithOnlyFallthrough" : true,
"NoEmptyTrailingClosureParentheses" : true,
"NoLabelsInCasePatterns" : true,
"NoLeadingUnderscores" : false,
"NoParensAroundConditions" : true,
"NoVoidReturnOnFunctionSignature" : true,
"OmitExplicitReturns" : true,
"OneCasePerLine" : true,
"OneVariableDeclarationPerLine" : true,
"OnlyOneTrailingClosureArgument" : true,
"OrderedImports" : true,
"ReplaceForEachWithForLoop" : true,
"ReturnVoidInsteadOfEmptyTuple" : true,
"UseEarlyExits" : false,
"UseExplicitNilCheckInConditions" : false,
"UseLetInEveryBoundCaseVariable" : false,
"UseShorthandTypeNames" : true,
"UseSingleLinePropertyGetter" : false,
"UseSynthesizedInitializer" : false,
"UseTripleSlashForDocumentationComments" : true,
"UseWhereClausesInForLoops" : false,
"ValidateDocumentationComments" : false
}
}
-13
View File
@@ -1,13 +0,0 @@
# file options
--swiftversion 5.4
--exclude .build
# format options
--self insert
--patternlet inline
--stripunusedargs unnamed-only
--ifdef no-indent
# rules
+159
View File
@@ -0,0 +1,159 @@
Package.swift
Sources/Crypto/AEADs/AES/GCM/AES-GCM.swift
Sources/Crypto/AEADs/ChachaPoly/ChaChaPoly.swift
Sources/Crypto/AEADs/Cipher.swift
Sources/Crypto/AEADs/Nonces.swift
Sources/Crypto/ASN1/ASN1.swift
Sources/Crypto/ASN1/Basic ASN1 Types/ASN1Any.swift
Sources/Crypto/ASN1/Basic ASN1 Types/ASN1BitString.swift
Sources/Crypto/ASN1/Basic ASN1 Types/ASN1Boolean.swift
Sources/Crypto/ASN1/Basic ASN1 Types/ASN1Identifier.swift
Sources/Crypto/ASN1/Basic ASN1 Types/ASN1Integer.swift
Sources/Crypto/ASN1/Basic ASN1 Types/ASN1Null.swift
Sources/Crypto/ASN1/Basic ASN1 Types/ASN1OctetString.swift
Sources/Crypto/ASN1/Basic ASN1 Types/ASN1Strings.swift
Sources/Crypto/ASN1/Basic ASN1 Types/ArraySliceBigint.swift
Sources/Crypto/ASN1/Basic ASN1 Types/GeneralizedTime.swift
Sources/Crypto/ASN1/Basic ASN1 Types/ObjectIdentifier.swift
Sources/Crypto/ASN1/ECDSASignature.swift
Sources/Crypto/ASN1/PEMDocument.swift
Sources/Crypto/ASN1/PKCS8PrivateKey.swift
Sources/Crypto/ASN1/SEC1PrivateKey.swift
Sources/Crypto/ASN1/SubjectPublicKeyInfo.swift
Sources/Crypto/CryptoKitErrors.swift
Sources/Crypto/Digests/Digest.swift
Sources/Crypto/Digests/Digests.swift
Sources/Crypto/Digests/HashFunctions.swift
Sources/Crypto/Digests/HashFunctions_SHA2.swift
Sources/Crypto/HPKE/Ciphersuite/HPKE-AEAD.swift
Sources/Crypto/HPKE/Ciphersuite/HPKE-Ciphersuite.swift
Sources/Crypto/HPKE/Ciphersuite/HPKE-KDF.swift
Sources/Crypto/HPKE/Ciphersuite/HPKE-KexKeyDerivation.swift
Sources/Crypto/HPKE/Ciphersuite/HPKE-LabeledExtract.swift
Sources/Crypto/HPKE/Ciphersuite/HPKE-Utils.swift
Sources/Crypto/HPKE/Ciphersuite/KEM/Conformances/DHKEM.swift
Sources/Crypto/HPKE/Ciphersuite/KEM/Conformances/HPKE-KEM-Curve25519.swift
Sources/Crypto/HPKE/Ciphersuite/KEM/Conformances/HPKE-NIST-EC-KEMs.swift
Sources/Crypto/HPKE/Ciphersuite/KEM/HPKE-KEM.swift
Sources/Crypto/HPKE/HPKE-Errors.swift
Sources/Crypto/HPKE/HPKE.swift
Sources/Crypto/HPKE/Key Schedule/HPKE-Context.swift
Sources/Crypto/HPKE/Key Schedule/HPKE-KeySchedule.swift
Sources/Crypto/HPKE/Modes/HPKE-Modes.swift
Sources/Crypto/Insecure/Insecure.swift
Sources/Crypto/Insecure/Insecure_HashFunctions.swift
Sources/Crypto/KEM/KEM.swift
Sources/Crypto/Key Agreement/DH.swift
Sources/Crypto/Key Agreement/ECDH.swift
Sources/Crypto/Key Derivation/HKDF.swift
Sources/Crypto/Key Wrapping/AESWrap.swift
Sources/Crypto/Keys/EC/Curve25519.swift
Sources/Crypto/Keys/EC/Ed25519Keys.swift
Sources/Crypto/Keys/EC/NISTCurvesKeys.swift
Sources/Crypto/Keys/EC/X25519Keys.swift
Sources/Crypto/Keys/Symmetric/SymmetricKeys.swift
Sources/Crypto/Message Authentication Codes/HMAC/HMAC.swift
Sources/Crypto/Message Authentication Codes/MACFunctions.swift
Sources/Crypto/Message Authentication Codes/MessageAuthenticationCode.swift
Sources/Crypto/PRF/AES.swift
Sources/Crypto/Signatures/ECDSA.swift
Sources/Crypto/Signatures/Ed25519.swift
Sources/Crypto/Signatures/Signature.swift
Sources/Crypto/Util/PrettyBytes.swift
Sources/Crypto/Util/SafeCompare.swift
Sources/Crypto/Util/SecureBytes.swift
Sources/Crypto/Util/Zeroization.swift
Sources/_CryptoExtras/AES/AES_CBC.swift
Sources/_CryptoExtras/AES/AES_CFB.swift
Sources/_CryptoExtras/AES/AES_CTR.swift
Sources/_CryptoExtras/AES/AES_GCM_SIV.swift
Sources/_CryptoExtras/AES/Block Function.swift
Sources/_CryptoExtras/ARC/ARC+API.swift
Sources/_CryptoExtras/ARC/ARC.swift
Sources/_CryptoExtras/ARC/ARCCredential.swift
Sources/_CryptoExtras/ARC/ARCEncoding.swift
Sources/_CryptoExtras/ARC/ARCPrecredential.swift
Sources/_CryptoExtras/ARC/ARCPresentation.swift
Sources/_CryptoExtras/ARC/ARCRequest.swift
Sources/_CryptoExtras/ARC/ARCResponse.swift
Sources/_CryptoExtras/ARC/ARCServer.swift
Sources/_CryptoExtras/ZKPs/Prover.swift
Sources/_CryptoExtras/ZKPs/Verifier.swift
Sources/_CryptoExtras/ZKPs/ZKPToolbox.swift
Sources/_CryptoExtras/ChaCha20CTR/ChaCha20CTR.swift
Sources/_CryptoExtras/ECToolbox/ECToolbox.swift
Sources/_CryptoExtras/H2G/HashToField.swift
Sources/_CryptoExtras/Key Derivation/KDF.swift
Sources/_CryptoExtras/Key Derivation/PBKDF2/PBKDF2.swift
Sources/_CryptoExtras/Key Derivation/Scrypt/Scrypt.swift
Sources/_CryptoExtras/OPRFs/OPRF.swift
Sources/_CryptoExtras/OPRFs/OPRFClient.swift
Sources/_CryptoExtras/OPRFs/OPRFServer.swift
Sources/_CryptoExtras/OPRFs/VOPRF+API.swift
Sources/_CryptoExtras/OPRFs/VOPRFClient.swift
Sources/_CryptoExtras/OPRFs/VOPRFServer.swift
Sources/_CryptoExtras/RSA/RSA+BlindSigning.swift
Sources/_CryptoExtras/RSA/RSA.swift
Sources/_CryptoExtras/RSA/RSA_security.swift
Sources/_CryptoExtras/Util/BoringSSLHelpers.swift
Sources/_CryptoExtras/Util/DigestType.swift
Sources/_CryptoExtras/Util/Error.swift
Sources/_CryptoExtras/Util/I2OSP.swift
Sources/_CryptoExtras/Util/PEMDocument.swift
Sources/_CryptoExtras/Util/PrettyBytes.swift
Sources/_CryptoExtras/Util/SubjectPublicKeyInfo.swift
Sources/_CryptoExtras/ZKPs/DLEQ.swift
Sources/crypto-shasum/main.swift
Tests/CryptoTests/ASN1/ASN1Tests.swift
Tests/CryptoTests/ASN1/GeneralizedTimeTests.swift
Tests/CryptoTests/Authenticated Encryption/AES-GCM-Runner.swift
Tests/CryptoTests/Authenticated Encryption/ChaChaPoly-Runner.swift
Tests/CryptoTests/Digests/DigestsTests.swift
Tests/CryptoTests/ECDH/X25519-Runner.swift
Tests/CryptoTests/ECDH/secpECDH_Runner.swift
Tests/CryptoTests/Encodings/DERTests.swift
Tests/CryptoTests/Encodings/ECKeyEncodingsTests.swift
Tests/CryptoTests/HPKE/HPKETests-TestVectors.swift
Tests/CryptoTests/HPKE/HPKETests.swift
Tests/CryptoTests/Key Derivation/ECprivateKeysFromSeeds.swift
Tests/CryptoTests/Key Derivation/HKDFTests.swift
Tests/CryptoTests/Key Derivation/SharedSecretTests.swift
Tests/CryptoTests/Key Derivation/X963KDFTests.swift
Tests/CryptoTests/Key Wrapping/KeyWrapping.swift
Tests/CryptoTests/MAC/HMACTests.swift
Tests/CryptoTests/SecureBytes/SecureBytesTests.swift
Tests/CryptoTests/Signatures/ECDSA/ECDSASignatureTests.swift
Tests/CryptoTests/Signatures/ECDSA/RawECDSASignaturesTests.swift
Tests/CryptoTests/Signatures/EdDSA/Ed25519-Runner.swift
Tests/CryptoTests/Utils/PrettyBytes.swift
Tests/CryptoTests/Utils/RFCVector.swift
Tests/CryptoTests/Utils/SplitData.swift
Tests/CryptoTests/Utils/Wycheproof.swift
Tests/CryptoTests/Utils/XCTestUtils.swift
Tests/_CryptoExtrasTests/AES Block Function Tests.swift
Tests/_CryptoExtrasTests/AES-GCM-SIV-Runner.swift
Tests/_CryptoExtrasTests/AES_CBCTests.swift
Tests/_CryptoExtrasTests/AES_CFBTests.swift
Tests/_CryptoExtrasTests/AES_CTRTests.swift
Tests/_CryptoExtrasTests/ARC/ARCAPITests.swift
Tests/_CryptoExtrasTests/ARC/ARCEncodingTests.swift
Tests/_CryptoExtrasTests/ARC/ARCPublicAPITests.swift
Tests/_CryptoExtrasTests/ARC/ARCTestVectors.swift
Tests/_CryptoExtrasTests/ARC/ARCTests.swift
Tests/_CryptoExtrasTests/ChaCha20CTRTests.swift
Tests/_CryptoExtrasTests/ECToolbox/HashToCurveTests.swift
Tests/_CryptoExtrasTests/OPRFs/ECVOPRFTests.swift
Tests/_CryptoExtrasTests/OPRFs/VOPRFAPITests.swift
Tests/_CryptoExtrasTests/OPRFs/VOPRFPublicAPITests.swift
Tests/_CryptoExtrasTests/PBKDF2Tests.swift
Tests/_CryptoExtrasTests/ScryptTests.swift
Tests/_CryptoExtrasTests/TestRSABlindSigning.swift
Tests/_CryptoExtrasTests/TestRSABlindSigningAPI.swift
Tests/_CryptoExtrasTests/TestRSAEncryption.swift
Tests/_CryptoExtrasTests/TestRSASigning.swift
Tests/_CryptoExtrasTests/Utils/BytesUtil.swift
Tests/_CryptoExtrasTests/Utils/RFCVector.swift
Tests/_CryptoExtrasTests/Utils/SplitData.swift
Tests/_CryptoExtrasTests/Utils/Wycheproof.swift
Tests/_CryptoExtrasTests/Utils/XCTestUtils.swift
Tests/_CryptoExtrasTests/ZKPs/ZKPToolbox.swift
+1
View File
@@ -0,0 +1 @@
Sources/CCryptoBoringSSL/*
-5
View File
@@ -1,5 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<array/>
</plist>
+16 -2
View File
@@ -6,7 +6,7 @@
## Licensed under Apache License v2.0
##
## See LICENSE.txt for license information
## See CONTRIBUTORS.md for the list of SwiftCrypto project authors
## See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
##
## SPDX-License-Identifier: Apache-2.0
##
@@ -15,7 +15,7 @@
cmake_minimum_required(VERSION 3.15.1)
project(SwiftCrypto
LANGUAGES ASM C Swift)
LANGUAGES ASM C CXX Swift)
list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
@@ -31,6 +31,10 @@ endif()
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
set(CMAKE_Swift_MODULE_DIRECTORY ${CMAKE_BINARY_DIR}/swift)
set(SWIFT_CRYPTO_COMPILE_OPTIONS
-package-name com.apple.swift-crypto
)
option(BUILD_SHARED_LIBS "Build shared libraries by default" YES)
if(BUILD_SHARED_LIBS)
@@ -48,5 +52,15 @@ if(NOT CMAKE_SYSTEM_NAME STREQUAL Darwin)
find_package(Foundation CONFIG)
endif()
include(FetchContent)
find_package(SwiftASN1 CONFIG)
if(NOT SwiftASN1_FOUND)
message("-- Vending swift-asn1")
FetchContent_Declare(ASN1
GIT_REPOSITORY https://github.com/apple/swift-asn1
GIT_TAG 1.3.1)
FetchContent_MakeAvailable(ASN1)
endif()
add_subdirectory(Sources)
add_subdirectory(cmake/modules)
File renamed without changes.
+1 -1
View File
@@ -28,7 +28,7 @@ components that this product depends on.
This product contains test vectors from Google's wycheproof project.
* LICENSE (Apache License 2.0):
* https://github.com/google/wycheproof/blob/master/LICENSE
* https://github.com/C2SP/wycheproof/blob/31387e2cd596587c859c611027b6a44d2e2b65ff/LICENSE
* HOMEPAGE:
* https://github.com/google/wycheproof
+97 -45
View File
@@ -1,4 +1,4 @@
// swift-tools-version:5.8
// swift-tools-version:5.9
//===----------------------------------------------------------------------===//
//
// This source file is part of the SwiftCrypto open source project
@@ -7,7 +7,7 @@
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.md for the list of SwiftCrypto project authors
// See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
@@ -20,16 +20,27 @@
// Sources/CCryptoBoringSSL directory. The source repository is at
// https://boringssl.googlesource.com/boringssl.
//
// BoringSSL Commit: 6a2ccdcc2ed1d37a43a2183658d2ae61fd5ce208
// BoringSSL Commit: aefa5d24da34ef77ac797bdbe684734e5bd870f4
import PackageDescription
import class Foundation.ProcessInfo
// To develop this on Apple platforms, set this to true
let development = false
// Ideally, we should use `.when(platforms:)` to set `swiftSettings` and
// `dependencies` like on other platforms. However, `Platform.freebsd` is not
// yet available, and therefore we guard the settings behind this boolean.
#if os(FreeBSD)
let isFreeBSD = true
#else
let isFreeBSD = false
#endif
let swiftSettings: [SwiftSetting]
let dependencies: [Target.Dependency]
if development {
if development || isFreeBSD {
swiftSettings = [
.define("CRYPTO_IN_SWIFTPM"),
.define("CRYPTO_IN_SWIFTPM_FORCE_BUILD_API"),
@@ -37,7 +48,7 @@ if development {
dependencies = [
"CCryptoBoringSSL",
"CCryptoBoringSSLShims",
"CryptoBoringWrapper"
"CryptoBoringWrapper",
]
} else {
let platforms: [Platform] = [
@@ -53,18 +64,24 @@ if development {
dependencies = [
.target(name: "CCryptoBoringSSL", condition: .when(platforms: platforms)),
.target(name: "CCryptoBoringSSLShims", condition: .when(platforms: platforms)),
.target(name: "CryptoBoringWrapper", condition: .when(platforms: platforms))
.target(name: "CryptoBoringWrapper", condition: .when(platforms: platforms)),
]
}
// This doesn't work when cross-compiling: the privacy manifest will be included in the Bundle and
// Foundation will be linked. This is, however, strictly better than unconditionally adding the
// resource.
#if canImport(Darwin)
let privacyManifestExclude: [String] = []
let privacyManifestResource: [PackageDescription.Resource] = [.copy("PrivacyInfo.xcprivacy")]
#else
// Exclude on other platforms to avoid build warnings.
let privacyManifestExclude: [String] = ["PrivacyInfo.xcprivacy"]
let privacyManifestResource: [PackageDescription.Resource] = []
#endif
let package = Package(
name: "swift-crypto",
platforms: [
.macOS(.v10_15),
.iOS(.v13),
.watchOS(.v6),
.tvOS(.v13),
],
products: [
.library(name: "Crypto", targets: ["Crypto"]),
.library(name: "_CryptoExtras", targets: ["_CryptoExtras"]),
@@ -72,11 +89,13 @@ let package = Package(
.library(name: "CCryptoBoringSSL", type: .static, targets: ["CCryptoBoringSSL"]),
MANGLE_END */
],
dependencies: [],
dependencies: [
// Dependencies are added below so that they can be switched between local and absolute URLs
],
targets: [
.target(
name: "CCryptoBoringSSL",
exclude: [
exclude: privacyManifestExclude + [
"hash.txt",
"include/boringssl_prefix_symbols_nasm.inc",
"CMakeLists.txt",
@@ -84,13 +103,11 @@ let package = Package(
* These files are excluded to support WASI libc which doesn't provide <netdb.h>.
* This is safe for all platforms as we do not rely on networking features.
*/
"crypto/bio/connect.c",
"crypto/bio/socket_helper.c",
"crypto/bio/socket.c"
],
resources: [
.copy("PrivacyInfo.xcprivacy"),
"crypto/bio/connect.cc",
"crypto/bio/socket_helper.cc",
"crypto/bio/socket.cc",
],
resources: privacyManifestResource,
cSettings: [
// These defines come from BoringSSL's build system
.define("_HAS_EXCEPTIONS", to: "0", .when(platforms: [Platform.windows])),
@@ -100,34 +117,33 @@ let package = Package(
/*
* These defines are required on Wasm/WASI, to disable use of pthread.
*/
.define("OPENSSL_NO_THREADS_CORRUPT_MEMORY_AND_LEAK_SECRETS_IF_THREADED", .when(platforms: [Platform.wasi])),
.define(
"OPENSSL_NO_THREADS_CORRUPT_MEMORY_AND_LEAK_SECRETS_IF_THREADED",
.when(platforms: [Platform.wasi])
),
.define("OPENSSL_NO_ASM", .when(platforms: [Platform.wasi])),
]
),
.target(
name: "CCryptoBoringSSLShims",
dependencies: ["CCryptoBoringSSL"],
exclude: [
exclude: privacyManifestExclude + [
"CMakeLists.txt"
],
resources: [
.copy("PrivacyInfo.xcprivacy"),
]
resources: privacyManifestResource
),
.target(
name: "Crypto",
dependencies: dependencies,
exclude: [
exclude: privacyManifestExclude + [
"CMakeLists.txt",
"AEADs/Nonces.swift.gyb",
"Digests/Digests.swift.gyb",
"Key Agreement/ECDH.swift.gyb",
"Signatures/ECDSA.swift.gyb",
],
resources: [
.copy("PrivacyInfo.xcprivacy"),
],
swiftSettings: swiftSettings + [.define("MODULE_IS_CRYPTO")]
resources: privacyManifestResource,
swiftSettings: swiftSettings
),
.target(
name: "_CryptoExtras",
@@ -135,39 +151,75 @@ let package = Package(
"CCryptoBoringSSL",
"CCryptoBoringSSLShims",
"CryptoBoringWrapper",
"Crypto"
"Crypto",
.product(name: "SwiftASN1", package: "swift-asn1"),
],
exclude: [
"CMakeLists.txt",
],
resources: [
.copy("PrivacyInfo.xcprivacy"),
exclude: privacyManifestExclude + [
"CMakeLists.txt"
],
resources: privacyManifestResource,
swiftSettings: swiftSettings
),
.target(
name: "CryptoBoringWrapper",
dependencies: [
"CCryptoBoringSSL",
"CCryptoBoringSSLShims"
"CCryptoBoringSSLShims",
],
exclude: [
"CMakeLists.txt",
exclude: privacyManifestExclude + [
"CMakeLists.txt"
],
resources: [
.copy("PrivacyInfo.xcprivacy"),
]
resources: privacyManifestResource
),
.executableTarget(name: "crypto-shasum", dependencies: ["Crypto"]),
.testTarget(
name: "CryptoTests",
dependencies: ["Crypto"],
resources: [
.copy("HPKE/hpke-test-vectors.json"),
.copy("HPKE/hpke-test-vectors.json")
],
swiftSettings: swiftSettings
),
.testTarget(name: "_CryptoExtrasTests", dependencies: ["_CryptoExtras"]),
.testTarget(
name: "_CryptoExtrasTests",
dependencies: ["_CryptoExtras"],
resources: [
.copy("ECToolbox/H2CVectors/P256_XMD-SHA-256_SSWU_RO_.json"),
.copy("ECToolbox/H2CVectors/P384_XMD-SHA-384_SSWU_RO_.json"),
.copy("OPRFs/OPRFVectors/OPRFVectors-VOPRFDraft8.json"),
.copy("OPRFs/OPRFVectors/OPRFVectors-VOPRFDraft19.json"),
.copy("OPRFs/OPRFVectors/OPRFVectors-edgecases.json"),
],
swiftSettings: swiftSettings
),
.testTarget(name: "CryptoBoringWrapperTests", dependencies: ["CryptoBoringWrapper"]),
],
cxxLanguageStandard: .cxx11
cxxLanguageStandard: .cxx14
)
// Switch between local and remote dependencies depending on an environment variable
if ProcessInfo.processInfo.environment["SWIFTCI_USE_LOCAL_DEPS"] == nil {
package.dependencies += [
.package(url: "https://github.com/apple/swift-asn1.git", from: "1.2.0")
]
} else {
package.dependencies += [
.package(path: "../swift-asn1")
]
}
// --- STANDARD CROSS-REPO SETTINGS DO NOT EDIT --- //
for target in package.targets {
switch target.type {
case .regular, .test, .executable:
var settings = target.swiftSettings ?? []
// https://github.com/swiftlang/swift-evolution/blob/main/proposals/0444-member-import-visibility.md
settings.append(.enableUpcomingFeature("MemberImportVisibility"))
target.swiftSettings = settings
case .macro, .plugin, .system, .binary:
() // not applicable
@unknown default:
() // we don't know what to do here, do nothing
}
}
// --- END: STANDARD CROSS-REPO SETTINGS DO NOT EDIT --- //
+2 -1
View File
@@ -117,7 +117,8 @@ Swift Crypto | Minimum Swift Version
`2.2.0 ..< 2.4.2` | 5.5
`2.4.2 ..< 3.1.0` | 5.6
`3.1.0 ..< 3.3.0` | 5.7
`3.3.0 ...` | 5.8
`3.3.0 ..< 3.8.0` | 5.8
`3.8.0 ...` | 5.9
### Compatibility
+255 -244
View File
@@ -6,257 +6,263 @@
## Licensed under Apache License v2.0
##
## See LICENSE.txt for license information
## See CONTRIBUTORS.md for the list of SwiftCrypto project authors
## See CONTRIBUTORS.txt for the list of SwiftCrypto project authors
##
## SPDX-License-Identifier: Apache-2.0
##
##===----------------------------------------------------------------------===##
add_library(CCryptoBoringSSL STATIC
"crypto/asn1/a_bitstr.c"
"crypto/asn1/a_bool.c"
"crypto/asn1/a_d2i_fp.c"
"crypto/asn1/a_dup.c"
"crypto/asn1/a_gentm.c"
"crypto/asn1/a_i2d_fp.c"
"crypto/asn1/a_int.c"
"crypto/asn1/a_mbstr.c"
"crypto/asn1/a_object.c"
"crypto/asn1/a_octet.c"
"crypto/asn1/a_strex.c"
"crypto/asn1/a_strnid.c"
"crypto/asn1/a_time.c"
"crypto/asn1/a_type.c"
"crypto/asn1/a_utctm.c"
"crypto/asn1/asn1_lib.c"
"crypto/asn1/asn1_par.c"
"crypto/asn1/asn_pack.c"
"crypto/asn1/f_int.c"
"crypto/asn1/f_string.c"
"crypto/asn1/posix_time.c"
"crypto/asn1/tasn_dec.c"
"crypto/asn1/tasn_enc.c"
"crypto/asn1/tasn_fre.c"
"crypto/asn1/tasn_new.c"
"crypto/asn1/tasn_typ.c"
"crypto/asn1/tasn_utl.c"
"crypto/base64/base64.c"
"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"
"crypto/bio/pair.c"
"crypto/bio/printf.c"
"crypto/bio/socket.c"
"crypto/bio/socket_helper.c"
"crypto/blake2/blake2.c"
"crypto/bn_extra/bn_asn1.c"
"crypto/bn_extra/convert.c"
"crypto/buf/buf.c"
"crypto/bytestring/asn1_compat.c"
"crypto/bytestring/ber.c"
"crypto/bytestring/cbb.c"
"crypto/bytestring/cbs.c"
"crypto/bytestring/unicode.c"
"crypto/chacha/chacha.c"
"crypto/cipher_extra/cipher_extra.c"
"crypto/cipher_extra/derive_key.c"
"crypto/cipher_extra/e_aesctrhmac.c"
"crypto/cipher_extra/e_aesgcmsiv.c"
"crypto/cipher_extra/e_chacha20poly1305.c"
"crypto/cipher_extra/e_des.c"
"crypto/cipher_extra/e_null.c"
"crypto/cipher_extra/e_rc2.c"
"crypto/cipher_extra/e_rc4.c"
"crypto/cipher_extra/e_tls.c"
"crypto/cipher_extra/tls_cbc.c"
"crypto/conf/conf.c"
"crypto/cpu_aarch64_apple.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_freebsd.c"
"crypto/cpu_arm_linux.c"
"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"
"crypto/dh_extra/params.c"
"crypto/digest_extra/digest_extra.c"
"crypto/dilithium/dilithium.c"
"crypto/dsa/dsa.c"
"crypto/dsa/dsa_asn1.c"
"crypto/ec_extra/ec_asn1.c"
"crypto/ec_extra/ec_derive.c"
"crypto/ec_extra/hash_to_curve.c"
"crypto/ecdh_extra/ecdh_extra.c"
"crypto/ecdsa_extra/ecdsa_asn1.c"
"crypto/engine/engine.c"
"crypto/err/err.c"
"crypto/evp/evp.c"
"crypto/evp/evp_asn1.c"
"crypto/evp/evp_ctx.c"
"crypto/evp/p_dh.c"
"crypto/evp/p_dh_asn1.c"
"crypto/evp/p_dsa_asn1.c"
"crypto/evp/p_ec.c"
"crypto/evp/p_ec_asn1.c"
"crypto/evp/p_ed25519.c"
"crypto/evp/p_ed25519_asn1.c"
"crypto/evp/p_hkdf.c"
"crypto/evp/p_rsa.c"
"crypto/evp/p_rsa_asn1.c"
"crypto/evp/p_x25519.c"
"crypto/evp/p_x25519_asn1.c"
"crypto/evp/pbkdf.c"
"crypto/evp/print.c"
"crypto/evp/scrypt.c"
"crypto/evp/sign.c"
"crypto/ex_data.c"
"crypto/fipsmodule/bcm.c"
"crypto/fipsmodule/fips_shared_support.c"
"crypto/hpke/hpke.c"
"crypto/hrss/hrss.c"
"crypto/keccak/keccak.c"
"crypto/kyber/kyber.c"
"crypto/lhash/lhash.c"
"crypto/md4/md4.c"
"crypto/md5/md5.c"
"crypto/mem.c"
"crypto/mldsa/mldsa.c"
"crypto/obj/obj.c"
"crypto/obj/obj_xref.c"
"crypto/pem/pem_all.c"
"crypto/pem/pem_info.c"
"crypto/pem/pem_lib.c"
"crypto/pem/pem_oth.c"
"crypto/pem/pem_pk8.c"
"crypto/pem/pem_pkey.c"
"crypto/pem/pem_x509.c"
"crypto/pem/pem_xaux.c"
"crypto/pkcs7/pkcs7.c"
"crypto/pkcs7/pkcs7_x509.c"
"crypto/pkcs8/p5_pbev2.c"
"crypto/pkcs8/pkcs8.c"
"crypto/pkcs8/pkcs8_x509.c"
"crypto/poly1305/poly1305.c"
"crypto/poly1305/poly1305_arm.c"
"crypto/poly1305/poly1305_vec.c"
"crypto/pool/pool.c"
"crypto/rand_extra/deterministic.c"
"crypto/rand_extra/fork_detect.c"
"crypto/rand_extra/forkunsafe.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/urandom.c"
"crypto/rand_extra/windows.c"
"crypto/rc4/rc4.c"
"crypto/refcount.c"
"crypto/rsa_extra/rsa_asn1.c"
"crypto/rsa_extra/rsa_crypt.c"
"crypto/rsa_extra/rsa_print.c"
"crypto/sha/sha1.c"
"crypto/siphash/siphash.c"
"crypto/spx/spx.c"
"crypto/spx/spx_address.c"
"crypto/spx/spx_fors.c"
"crypto/spx/spx_merkle.c"
"crypto/spx/spx_thash.c"
"crypto/spx/spx_util.c"
"crypto/spx/spx_wots.c"
"crypto/stack/stack.c"
"crypto/thread.c"
"crypto/thread_none.c"
"crypto/thread_pthread.c"
"crypto/thread_win.c"
"crypto/trust_token/pmbtoken.c"
"crypto/trust_token/trust_token.c"
"crypto/trust_token/voprf.c"
"crypto/x509/a_digest.c"
"crypto/x509/a_sign.c"
"crypto/x509/a_verify.c"
"crypto/x509/algorithm.c"
"crypto/x509/asn1_gen.c"
"crypto/x509/by_dir.c"
"crypto/x509/by_file.c"
"crypto/x509/i2d_pr.c"
"crypto/x509/name_print.c"
"crypto/x509/policy.c"
"crypto/x509/rsa_pss.c"
"crypto/x509/t_crl.c"
"crypto/x509/t_req.c"
"crypto/x509/t_x509.c"
"crypto/x509/t_x509a.c"
"crypto/x509/v3_akey.c"
"crypto/x509/v3_akeya.c"
"crypto/x509/v3_alt.c"
"crypto/x509/v3_bcons.c"
"crypto/x509/v3_bitst.c"
"crypto/x509/v3_conf.c"
"crypto/x509/v3_cpols.c"
"crypto/x509/v3_crld.c"
"crypto/x509/v3_enum.c"
"crypto/x509/v3_extku.c"
"crypto/x509/v3_genn.c"
"crypto/x509/v3_ia5.c"
"crypto/x509/v3_info.c"
"crypto/x509/v3_int.c"
"crypto/x509/v3_lib.c"
"crypto/x509/v3_ncons.c"
"crypto/x509/v3_ocsp.c"
"crypto/x509/v3_pcons.c"
"crypto/x509/v3_pmaps.c"
"crypto/x509/v3_prn.c"
"crypto/x509/v3_purp.c"
"crypto/x509/v3_skey.c"
"crypto/x509/v3_utl.c"
"crypto/x509/x509.c"
"crypto/x509/x509_att.c"
"crypto/x509/x509_cmp.c"
"crypto/x509/x509_d2.c"
"crypto/x509/x509_def.c"
"crypto/x509/x509_ext.c"
"crypto/x509/x509_lu.c"
"crypto/x509/x509_obj.c"
"crypto/x509/x509_req.c"
"crypto/x509/x509_set.c"
"crypto/x509/x509_trs.c"
"crypto/x509/x509_txt.c"
"crypto/x509/x509_v3.c"
"crypto/x509/x509_vfy.c"
"crypto/x509/x509_vpm.c"
"crypto/x509/x509cset.c"
"crypto/x509/x509name.c"
"crypto/x509/x509rset.c"
"crypto/x509/x509spki.c"
"crypto/x509/x_algor.c"
"crypto/x509/x_all.c"
"crypto/x509/x_attrib.c"
"crypto/x509/x_crl.c"
"crypto/x509/x_exten.c"
"crypto/x509/x_name.c"
"crypto/x509/x_pubkey.c"
"crypto/x509/x_req.c"
"crypto/x509/x_sig.c"
"crypto/x509/x_spki.c"
"crypto/x509/x_val.c"
"crypto/x509/x_x509.c"
"crypto/x509/x_x509a.c"
"gen/crypto/err_data.c")
"crypto/asn1/a_bitstr.cc"
"crypto/asn1/a_bool.cc"
"crypto/asn1/a_d2i_fp.cc"
"crypto/asn1/a_dup.cc"
"crypto/asn1/a_gentm.cc"
"crypto/asn1/a_i2d_fp.cc"
"crypto/asn1/a_int.cc"
"crypto/asn1/a_mbstr.cc"
"crypto/asn1/a_object.cc"
"crypto/asn1/a_octet.cc"
"crypto/asn1/a_strex.cc"
"crypto/asn1/a_strnid.cc"
"crypto/asn1/a_time.cc"
"crypto/asn1/a_type.cc"
"crypto/asn1/a_utctm.cc"
"crypto/asn1/asn1_lib.cc"
"crypto/asn1/asn1_par.cc"
"crypto/asn1/asn_pack.cc"
"crypto/asn1/f_int.cc"
"crypto/asn1/f_string.cc"
"crypto/asn1/posix_time.cc"
"crypto/asn1/tasn_dec.cc"
"crypto/asn1/tasn_enc.cc"
"crypto/asn1/tasn_fre.cc"
"crypto/asn1/tasn_new.cc"
"crypto/asn1/tasn_typ.cc"
"crypto/asn1/tasn_utl.cc"
"crypto/base64/base64.cc"
"crypto/bio/bio.cc"
"crypto/bio/bio_mem.cc"
"crypto/bio/connect.cc"
"crypto/bio/errno.cc"
"crypto/bio/fd.cc"
"crypto/bio/file.cc"
"crypto/bio/hexdump.cc"
"crypto/bio/pair.cc"
"crypto/bio/printf.cc"
"crypto/bio/socket.cc"
"crypto/bio/socket_helper.cc"
"crypto/blake2/blake2.cc"
"crypto/bn_extra/bn_asn1.cc"
"crypto/bn_extra/convert.cc"
"crypto/buf/buf.cc"
"crypto/bytestring/asn1_compat.cc"
"crypto/bytestring/ber.cc"
"crypto/bytestring/cbb.cc"
"crypto/bytestring/cbs.cc"
"crypto/bytestring/unicode.cc"
"crypto/chacha/chacha.cc"
"crypto/cipher_extra/cipher_extra.cc"
"crypto/cipher_extra/derive_key.cc"
"crypto/cipher_extra/e_aesctrhmac.cc"
"crypto/cipher_extra/e_aesgcmsiv.cc"
"crypto/cipher_extra/e_chacha20poly1305.cc"
"crypto/cipher_extra/e_des.cc"
"crypto/cipher_extra/e_null.cc"
"crypto/cipher_extra/e_rc2.cc"
"crypto/cipher_extra/e_rc4.cc"
"crypto/cipher_extra/e_tls.cc"
"crypto/cipher_extra/tls_cbc.cc"
"crypto/conf/conf.cc"
"crypto/cpu_aarch64_apple.cc"
"crypto/cpu_aarch64_fuchsia.cc"
"crypto/cpu_aarch64_linux.cc"
"crypto/cpu_aarch64_openbsd.cc"
"crypto/cpu_aarch64_sysreg.cc"
"crypto/cpu_aarch64_win.cc"
"crypto/cpu_arm_freebsd.cc"
"crypto/cpu_arm_linux.cc"
"crypto/cpu_intel.cc"
"crypto/crypto.cc"
"crypto/curve25519/curve25519.cc"
"crypto/curve25519/curve25519_64_adx.cc"
"crypto/curve25519/spake25519.cc"
"crypto/des/des.cc"
"crypto/dh_extra/dh_asn1.cc"
"crypto/dh_extra/params.cc"
"crypto/digest_extra/digest_extra.cc"
"crypto/dsa/dsa.cc"
"crypto/dsa/dsa_asn1.cc"
"crypto/ec_extra/ec_asn1.cc"
"crypto/ec_extra/ec_derive.cc"
"crypto/ec_extra/hash_to_curve.cc"
"crypto/ecdh_extra/ecdh_extra.cc"
"crypto/ecdsa_extra/ecdsa_asn1.cc"
"crypto/engine/engine.cc"
"crypto/err/err.cc"
"crypto/evp/evp.cc"
"crypto/evp/evp_asn1.cc"
"crypto/evp/evp_ctx.cc"
"crypto/evp/p_dh.cc"
"crypto/evp/p_dh_asn1.cc"
"crypto/evp/p_dsa_asn1.cc"
"crypto/evp/p_ec.cc"
"crypto/evp/p_ec_asn1.cc"
"crypto/evp/p_ed25519.cc"
"crypto/evp/p_ed25519_asn1.cc"
"crypto/evp/p_hkdf.cc"
"crypto/evp/p_rsa.cc"
"crypto/evp/p_rsa_asn1.cc"
"crypto/evp/p_x25519.cc"
"crypto/evp/p_x25519_asn1.cc"
"crypto/evp/pbkdf.cc"
"crypto/evp/print.cc"
"crypto/evp/scrypt.cc"
"crypto/evp/sign.cc"
"crypto/ex_data.cc"
"crypto/fipsmodule/bcm.cc"
"crypto/fipsmodule/fips_shared_support.cc"
"crypto/hpke/hpke.cc"
"crypto/hrss/hrss.cc"
"crypto/kyber/kyber.cc"
"crypto/lhash/lhash.cc"
"crypto/md4/md4.cc"
"crypto/md5/md5.cc"
"crypto/mem.cc"
"crypto/mldsa/mldsa.cc"
"crypto/mlkem/mlkem.cc"
"crypto/obj/obj.cc"
"crypto/obj/obj_xref.cc"
"crypto/pem/pem_all.cc"
"crypto/pem/pem_info.cc"
"crypto/pem/pem_lib.cc"
"crypto/pem/pem_oth.cc"
"crypto/pem/pem_pk8.cc"
"crypto/pem/pem_pkey.cc"
"crypto/pem/pem_x509.cc"
"crypto/pem/pem_xaux.cc"
"crypto/pkcs7/pkcs7.cc"
"crypto/pkcs7/pkcs7_x509.cc"
"crypto/pkcs8/p5_pbev2.cc"
"crypto/pkcs8/pkcs8.cc"
"crypto/pkcs8/pkcs8_x509.cc"
"crypto/poly1305/poly1305.cc"
"crypto/poly1305/poly1305_arm.cc"
"crypto/poly1305/poly1305_vec.cc"
"crypto/pool/pool.cc"
"crypto/rand_extra/deterministic.cc"
"crypto/rand_extra/fork_detect.cc"
"crypto/rand_extra/forkunsafe.cc"
"crypto/rand_extra/getentropy.cc"
"crypto/rand_extra/ios.cc"
"crypto/rand_extra/passive.cc"
"crypto/rand_extra/rand_extra.cc"
"crypto/rand_extra/trusty.cc"
"crypto/rand_extra/urandom.cc"
"crypto/rand_extra/windows.cc"
"crypto/rc4/rc4.cc"
"crypto/refcount.cc"
"crypto/rsa_extra/rsa_asn1.cc"
"crypto/rsa_extra/rsa_crypt.cc"
"crypto/rsa_extra/rsa_extra.cc"
"crypto/rsa_extra/rsa_print.cc"
"crypto/sha/sha1.cc"
"crypto/sha/sha256.cc"
"crypto/sha/sha512.cc"
"crypto/siphash/siphash.cc"
"crypto/slhdsa/fors.cc"
"crypto/slhdsa/merkle.cc"
"crypto/slhdsa/slhdsa.cc"
"crypto/slhdsa/thash.cc"
"crypto/slhdsa/wots.cc"
"crypto/stack/stack.cc"
"crypto/thread.cc"
"crypto/thread_none.cc"
"crypto/thread_pthread.cc"
"crypto/thread_win.cc"
"crypto/trust_token/pmbtoken.cc"
"crypto/trust_token/trust_token.cc"
"crypto/trust_token/voprf.cc"
"crypto/x509/a_digest.cc"
"crypto/x509/a_sign.cc"
"crypto/x509/a_verify.cc"
"crypto/x509/algorithm.cc"
"crypto/x509/asn1_gen.cc"
"crypto/x509/by_dir.cc"
"crypto/x509/by_file.cc"
"crypto/x509/i2d_pr.cc"
"crypto/x509/name_print.cc"
"crypto/x509/policy.cc"
"crypto/x509/rsa_pss.cc"
"crypto/x509/t_crl.cc"
"crypto/x509/t_req.cc"
"crypto/x509/t_x509.cc"
"crypto/x509/t_x509a.cc"
"crypto/x509/v3_akey.cc"
"crypto/x509/v3_akeya.cc"
"crypto/x509/v3_alt.cc"
"crypto/x509/v3_bcons.cc"
"crypto/x509/v3_bitst.cc"
"crypto/x509/v3_conf.cc"
"crypto/x509/v3_cpols.cc"
"crypto/x509/v3_crld.cc"
"crypto/x509/v3_enum.cc"
"crypto/x509/v3_extku.cc"
"crypto/x509/v3_genn.cc"
"crypto/x509/v3_ia5.cc"
"crypto/x509/v3_info.cc"
"crypto/x509/v3_int.cc"
"crypto/x509/v3_lib.cc"
"crypto/x509/v3_ncons.cc"
"crypto/x509/v3_ocsp.cc"
"crypto/x509/v3_pcons.cc"
"crypto/x509/v3_pmaps.cc"
"crypto/x509/v3_prn.cc"
"crypto/x509/v3_purp.cc"
"crypto/x509/v3_skey.cc"
"crypto/x509/v3_utl.cc"
"crypto/x509/x509.cc"
"crypto/x509/x509_att.cc"
"crypto/x509/x509_cmp.cc"
"crypto/x509/x509_d2.cc"
"crypto/x509/x509_def.cc"
"crypto/x509/x509_ext.cc"
"crypto/x509/x509_lu.cc"
"crypto/x509/x509_obj.cc"
"crypto/x509/x509_req.cc"
"crypto/x509/x509_set.cc"
"crypto/x509/x509_trs.cc"
"crypto/x509/x509_txt.cc"
"crypto/x509/x509_v3.cc"
"crypto/x509/x509_vfy.cc"
"crypto/x509/x509_vpm.cc"
"crypto/x509/x509cset.cc"
"crypto/x509/x509name.cc"
"crypto/x509/x509rset.cc"
"crypto/x509/x509spki.cc"
"crypto/x509/x_algor.cc"
"crypto/x509/x_all.cc"
"crypto/x509/x_attrib.cc"
"crypto/x509/x_crl.cc"
"crypto/x509/x_exten.cc"
"crypto/x509/x_name.cc"
"crypto/x509/x_pubkey.cc"
"crypto/x509/x_req.cc"
"crypto/x509/x_sig.cc"
"crypto/x509/x_spki.cc"
"crypto/x509/x_val.cc"
"crypto/x509/x_x509.cc"
"crypto/x509/x_x509a.cc"
"gen/crypto/err_data.cc"
"$<$<NOT:$<PLATFORM_ID:Windows>>:crypto/hrss/asm/poly_rq_mul.S>"
"$<$<NOT:$<PLATFORM_ID:Windows>>:third_party/fiat/asm/fiat_curve25519_adx_mul.S>"
"$<$<NOT:$<PLATFORM_ID:Windows>>:third_party/fiat/asm/fiat_curve25519_adx_square.S>"
"$<$<NOT:$<PLATFORM_ID:Windows>>:third_party/fiat/asm/fiat_p256_adx_mul.S>"
"$<$<NOT:$<PLATFORM_ID:Windows>>:third_party/fiat/asm/fiat_p256_adx_sqr.S>")
if(CMAKE_SYSTEM_NAME STREQUAL Darwin AND CMAKE_SYSTEM_PROCESSOR MATCHES "amd64|x86_64")
target_sources(CCryptoBoringSSL PRIVATE
gen/bcm/aes-gcm-avx10-x86_64-apple.S
gen/bcm/aesni-gcm-x86_64-apple.S
gen/bcm/aesni-x86_64-apple.S
gen/bcm/ghash-ssse3-x86_64-apple.S
@@ -275,8 +281,9 @@ if(CMAKE_SYSTEM_NAME STREQUAL Darwin AND CMAKE_SYSTEM_PROCESSOR MATCHES "amd64|x
gen/crypto/chacha-x86_64-apple.S
gen/crypto/chacha20_poly1305_x86_64-apple.S
gen/crypto/md5-x86_64-apple.S)
elseif(CMAKE_SYSTEM_NAME MATCHES "Linux|Android" AND CMAKE_SYSTEM_PROCESSOR MATCHES "amd64|x86_64")
elseif(CMAKE_SYSTEM_NAME MATCHES "Linux|Android|FreeBSD" AND CMAKE_SYSTEM_PROCESSOR MATCHES "amd64|x86_64")
target_sources(CCryptoBoringSSL PRIVATE
gen/bcm/aes-gcm-avx10-x86_64-linux.S
gen/bcm/aesni-gcm-x86_64-linux.S
gen/bcm/aesni-x86_64-linux.S
gen/bcm/ghash-ssse3-x86_64-linux.S
@@ -311,7 +318,7 @@ elseif(CMAKE_SYSTEM_NAME STREQUAL Darwin AND CMAKE_SYSTEM_PROCESSOR MATCHES "arm
gen/bcm/vpaes-armv8-apple.S
gen/crypto/chacha-armv8-apple.S
gen/crypto/chacha20_poly1305_armv8-apple.S)
elseif(CMAKE_SYSTEM_NAME MATCHES "Linux|Android" AND CMAKE_SYSTEM_PROCESSOR MATCHES "arm64|aarch64")
elseif(CMAKE_SYSTEM_NAME MATCHES "Linux|Android|FreeBSD" AND CMAKE_SYSTEM_PROCESSOR MATCHES "arm64|aarch64")
target_sources(CCryptoBoringSSL PRIVATE
gen/bcm/aesv8-armv8-linux.S
gen/bcm/aesv8-gcm-armv8-linux.S
@@ -334,6 +341,10 @@ target_include_directories(CCryptoBoringSSL PUBLIC
target_compile_definitions(CCryptoBoringSSL PRIVATE
$<$<PLATFORM_ID:Windows>:WIN32_LEAN_AND_MEAN>)
target_link_libraries(CCryptoBoringSSL PUBLIC
$<$<NOT:$<PLATFORM_ID:Darwin>>:dispatch>
$<$<NOT:$<PLATFORM_ID:Darwin>>:Foundation>
SwiftASN1)
set_target_properties(CCryptoBoringSSL PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_SOURCE_DIR}/include;${CMAKE_Swift_MODULE_DIRECTORY}")
@@ -142,6 +142,7 @@ ASN1_BIT_STRING *c2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a,
const unsigned char *p;
unsigned char *s;
int padding;
uint8_t padding_mask;
if (len < 1) {
OPENSSL_PUT_ERROR(ASN1, ASN1_R_STRING_TOO_SHORT);
@@ -170,7 +171,7 @@ ASN1_BIT_STRING *c2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a,
}
// Unused bits in a BIT STRING must be zero.
uint8_t padding_mask = (1 << padding) - 1;
padding_mask = (1 << padding) - 1;
if (padding != 0 && (len < 1 || (p[len - 1] & padding_mask) != 0)) {
OPENSSL_PUT_ERROR(ASN1, ASN1_R_INVALID_BIT_STRING_PADDING);
goto err;
@@ -182,7 +183,7 @@ ASN1_BIT_STRING *c2i_ASN1_BIT_STRING(ASN1_BIT_STRING **a,
ret->flags |= (ASN1_STRING_FLAG_BITS_LEFT | padding); // set
if (len > 0) {
s = OPENSSL_memdup(p, len);
s = reinterpret_cast<uint8_t *>(OPENSSL_memdup(p, len));
if (s == NULL) {
goto err;
}
@@ -72,7 +72,7 @@ void *ASN1_item_d2i_bio(const ASN1_ITEM *it, BIO *in, void *x) {
return NULL;
}
const uint8_t *ptr = data;
void *ret = ASN1_item_d2i(x, &ptr, len, it);
void *ret = ASN1_item_d2i(reinterpret_cast<ASN1_VALUE **>(x), &ptr, len, it);
OPENSSL_free(data);
return ret;
}
@@ -73,7 +73,7 @@ void *ASN1_item_dup(const ASN1_ITEM *it, void *x) {
return NULL;
}
i = ASN1_item_i2d(x, &b, it);
i = ASN1_item_i2d(reinterpret_cast<ASN1_VALUE *>(x), &b, it);
if (b == NULL) {
return NULL;
}
@@ -74,7 +74,7 @@ int ASN1_item_i2d_fp(const ASN1_ITEM *it, FILE *out, void *x) {
int ASN1_item_i2d_bio(const ASN1_ITEM *it, BIO *out, void *x) {
unsigned char *b = NULL;
int n = ASN1_item_i2d(x, &b, it);
int n = ASN1_item_i2d(reinterpret_cast<ASN1_VALUE *>(x), &b, it);
if (b == NULL) {
return 0;
}
@@ -408,6 +408,7 @@ static ASN1_STRING *bn_to_asn1_string(const BIGNUM *bn, ASN1_STRING *ai,
} else {
ret = ai;
}
int len;
if (ret == NULL) {
OPENSSL_PUT_ERROR(ASN1, ASN1_R_NESTED_ASN1_ERROR);
goto err;
@@ -419,7 +420,7 @@ static ASN1_STRING *bn_to_asn1_string(const BIGNUM *bn, ASN1_STRING *ai,
ret->type = type;
}
int len = BN_num_bytes(bn);
len = BN_num_bytes(bn);
if (!ASN1_STRING_set(ret, NULL, len) ||
!BN_bn2bin_padded(ret->data, len, bn)) {
goto err;
@@ -226,6 +226,8 @@ int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in,
CBB cbb;
CBB_zero(&cbb);
// If both the same type just copy across
uint8_t *data = NULL;
size_t data_len = 0;
if (inform == outform) {
if (!ASN1_STRING_set(dest, in, len)) {
goto err;
@@ -245,12 +247,12 @@ int ASN1_mbstring_ncopy(ASN1_STRING **out, const unsigned char *in,
goto err;
}
}
uint8_t *data = NULL;
size_t data_len;
if (// OpenSSL historically NUL-terminated this value with a single byte,
// even for |MBSTRING_BMP| and |MBSTRING_UNIV|.
!CBB_add_u8(&cbb, 0) || !CBB_finish(&cbb, &data, &data_len) ||
data_len < 1 || data_len > INT_MAX) {
if (/* OpenSSL historically NUL-terminated this value with a single byte,
* even for |MBSTRING_BMP| and |MBSTRING_UNIV|. */
!CBB_add_u8(&cbb, 0) || //
!CBB_finish(&cbb, &data, &data_len) || //
data_len < 1 || //
data_len > INT_MAX) {
OPENSSL_PUT_ERROR(ASN1, ERR_R_INTERNAL_ERROR);
OPENSSL_free(data);
goto err;
@@ -272,7 +274,7 @@ int asn1_is_printable(uint32_t value) {
if (value > 0x7f) {
return 0;
}
return OPENSSL_isalnum(value) || //
return OPENSSL_isalnum(value) || //
value == ' ' || value == '\'' || value == '(' || value == ')' ||
value == '+' || value == ',' || value == '-' || value == '.' ||
value == '/' || value == ':' || value == '=' || value == '?';
@@ -114,7 +114,7 @@ int i2a_ASN1_OBJECT(BIO *bp, const ASN1_OBJECT *a) {
int len = i2t_ASN1_OBJECT(buf, sizeof(buf), a);
if (len > (int)sizeof(buf) - 1) {
// The input was truncated. Allocate a buffer that fits.
allocated = OPENSSL_malloc(len + 1);
allocated = reinterpret_cast<char *>(OPENSSL_malloc(len + 1));
if (allocated == NULL) {
return -1;
}
@@ -159,7 +159,8 @@ static int table_cmp(const ASN1_STRING_TABLE *a, const ASN1_STRING_TABLE *b) {
}
static int table_cmp_void(const void *a, const void *b) {
return table_cmp(a, b);
return table_cmp(reinterpret_cast<const ASN1_STRING_TABLE *>(a),
reinterpret_cast<const ASN1_STRING_TABLE *>(b));
}
static uint32_t table_hash(const ASN1_STRING_TABLE *tbl) {
@@ -169,9 +170,9 @@ static uint32_t table_hash(const ASN1_STRING_TABLE *tbl) {
static const ASN1_STRING_TABLE *asn1_string_table_get(int nid) {
ASN1_STRING_TABLE key;
key.nid = nid;
const ASN1_STRING_TABLE *tbl =
const ASN1_STRING_TABLE *tbl = reinterpret_cast<ASN1_STRING_TABLE *>(
bsearch(&key, tbl_standard, OPENSSL_ARRAY_SIZE(tbl_standard),
sizeof(ASN1_STRING_TABLE), table_cmp_void);
sizeof(ASN1_STRING_TABLE), table_cmp_void));
if (tbl != NULL) {
return tbl;
}
@@ -198,6 +199,7 @@ int ASN1_STRING_TABLE_add(int nid, long minsize, long maxsize,
int ret = 0;
CRYPTO_MUTEX_lock_write(&string_tables_lock);
ASN1_STRING_TABLE *tbl = NULL;
if (string_tables == NULL) {
string_tables = lh_ASN1_STRING_TABLE_new(table_hash, table_cmp);
if (string_tables == NULL) {
@@ -214,7 +216,8 @@ int ASN1_STRING_TABLE_add(int nid, long minsize, long maxsize,
}
}
ASN1_STRING_TABLE *tbl = OPENSSL_malloc(sizeof(ASN1_STRING_TABLE));
tbl = reinterpret_cast<ASN1_STRING_TABLE *>(
OPENSSL_malloc(sizeof(ASN1_STRING_TABLE)));
if (tbl == NULL) {
goto err;
}
@@ -137,10 +137,10 @@ void ASN1_TYPE_set(ASN1_TYPE *a, int type, void *value) {
a->value.boolean = value ? ASN1_BOOLEAN_TRUE : ASN1_BOOLEAN_FALSE;
break;
case V_ASN1_OBJECT:
a->value.object = value;
a->value.object = reinterpret_cast<ASN1_OBJECT *>(value);
break;
default:
a->value.asn1_string = value;
a->value.asn1_string = reinterpret_cast<ASN1_STRING *>(value);
break;
}
}
@@ -151,14 +151,14 @@ int ASN1_TYPE_set1(ASN1_TYPE *a, int type, const void *value) {
ASN1_TYPE_set(a, type, p);
} else if (type == V_ASN1_OBJECT) {
ASN1_OBJECT *odup;
odup = OBJ_dup(value);
odup = OBJ_dup(reinterpret_cast<const ASN1_OBJECT *>(value));
if (!odup) {
return 0;
}
ASN1_TYPE_set(a, type, odup);
} else {
ASN1_STRING *sdup;
sdup = ASN1_STRING_dup(value);
sdup = ASN1_STRING_dup(reinterpret_cast<const ASN1_STRING *>(value));
if (!sdup) {
return 0;
}
@@ -271,7 +271,7 @@ ASN1_STRING *ASN1_STRING_dup(const ASN1_STRING *str) {
}
int ASN1_STRING_set(ASN1_STRING *str, const void *_data, ossl_ssize_t len_s) {
const char *data = _data;
const char *data = reinterpret_cast<const char *>(_data);
size_t len;
if (len_s < 0) {
if (data == NULL) {
@@ -291,9 +291,9 @@ int ASN1_STRING_set(ASN1_STRING *str, const void *_data, ossl_ssize_t len_s) {
if (str->length <= (int)len || str->data == NULL) {
unsigned char *c = str->data;
if (c == NULL) {
str->data = OPENSSL_malloc(len + 1);
str->data = reinterpret_cast<uint8_t *>(OPENSSL_malloc(len + 1));
} else {
str->data = OPENSSL_realloc(c, len + 1);
str->data = reinterpret_cast<uint8_t *>(OPENSSL_realloc(c, len + 1));
}
if (str->data == NULL) {
@@ -315,7 +315,7 @@ int ASN1_STRING_set(ASN1_STRING *str, const void *_data, ossl_ssize_t len_s) {
void ASN1_STRING_set0(ASN1_STRING *str, void *data, int len) {
OPENSSL_free(str->data);
str->data = data;
str->data = reinterpret_cast<uint8_t *>(data);
str->length = len;
}
@@ -62,7 +62,7 @@
ASN1_STRING *ASN1_item_pack(void *obj, const ASN1_ITEM *it, ASN1_STRING **out) {
uint8_t *new_data = NULL;
int len = ASN1_item_i2d(obj, &new_data, it);
int len = ASN1_item_i2d(reinterpret_cast<ASN1_VALUE *>(obj), &new_data, it);
if (len <= 0) {
OPENSSL_PUT_ERROR(ASN1, ASN1_R_ENCODE_ERROR);
return NULL;
@@ -91,7 +91,7 @@ void *ASN1_item_unpack(const ASN1_STRING *oct, const ASN1_ITEM *it) {
void *ret = ASN1_item_d2i(NULL, &p, oct->length, it);
if (ret == NULL || p != oct->data + oct->length) {
OPENSSL_PUT_ERROR(ASN1, ASN1_R_DECODE_ERROR);
ASN1_item_free(ret, it);
ASN1_item_free(reinterpret_cast<ASN1_VALUE *>(ret), it);
return NULL;
}
return ret;
@@ -1,4 +1,4 @@
/* Copyright (c) 2022, Google Inc.
/* Copyright 2022 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -154,7 +154,7 @@ int OPENSSL_tm_to_posix(const struct tm *tm, int64_t *out) {
}
int OPENSSL_posix_to_tm(int64_t time, struct tm *out_tm) {
struct tm tmp_tm = {0};
struct tm tmp_tm = {};
if (!utc_from_posix_time(time, &tmp_tm.tm_year, &tmp_tm.tm_mon,
&tmp_tm.tm_mday, &tmp_tm.tm_hour, &tmp_tm.tm_min,
&tmp_tm.tm_sec)) {
@@ -282,7 +282,8 @@ static int asn1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in,
OPENSSL_PUT_ERROR(ASN1, ASN1_R_BAD_TEMPLATE);
goto err;
}
const ASN1_EXTERN_FUNCS *ef = it->funcs;
const ASN1_EXTERN_FUNCS *ef =
reinterpret_cast<const ASN1_EXTERN_FUNCS *>(it->funcs);
return ef->asn1_ex_d2i(pval, in, len, it, opt, NULL);
}
@@ -294,7 +295,7 @@ static int asn1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in,
goto err;
}
const ASN1_AUX *aux = it->funcs;
const ASN1_AUX *aux = reinterpret_cast<const ASN1_AUX *>(it->funcs);
ASN1_aux_cb *asn1_cb = aux != NULL ? aux->asn1_cb : NULL;
if (asn1_cb && !asn1_cb(ASN1_OP_D2I_PRE, pval, it, NULL)) {
goto auxerr;
@@ -379,7 +380,7 @@ static int asn1_item_ex_d2i(ASN1_VALUE **pval, const unsigned char **in,
goto err;
}
const ASN1_AUX *aux = it->funcs;
const ASN1_AUX *aux = reinterpret_cast<const ASN1_AUX *>(it->funcs);
ASN1_aux_cb *asn1_cb = aux != NULL ? aux->asn1_cb : NULL;
if (asn1_cb && !asn1_cb(ASN1_OP_D2I_PRE, pval, it, NULL)) {
goto auxerr;
@@ -90,7 +90,7 @@ int ASN1_item_i2d(ASN1_VALUE *val, unsigned char **out, const ASN1_ITEM *it) {
if (len <= 0) {
return len;
}
buf = OPENSSL_malloc(len);
buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(len));
if (!buf) {
return -1;
}
@@ -191,7 +191,8 @@ int asn1_item_ex_i2d_opt(ASN1_VALUE **pval, unsigned char **out,
OPENSSL_PUT_ERROR(ASN1, ASN1_R_BAD_TEMPLATE);
return -1;
}
const ASN1_EXTERN_FUNCS *ef = it->funcs;
const ASN1_EXTERN_FUNCS *ef =
reinterpret_cast<const ASN1_EXTERN_FUNCS *>(it->funcs);
int ret = ef->asn1_ex_i2d(pval, out, it);
if (ret == 0) {
// |asn1_ex_i2d| should never return zero. We have already checked
@@ -424,7 +425,8 @@ typedef struct {
} DER_ENC;
static int der_cmp(const void *a, const void *b) {
const DER_ENC *d1 = a, *d2 = b;
const DER_ENC *d1 = reinterpret_cast<const DER_ENC *>(a),
*d2 = reinterpret_cast<const DER_ENC *>(b);
int cmplen, i;
cmplen = (d1->length < d2->length) ? d1->length : d2->length;
i = OPENSSL_memcmp(d1->data, d2->data, cmplen);
@@ -453,14 +455,15 @@ static int asn1_set_seq_out(STACK_OF(ASN1_VALUE) *sk, unsigned char **out,
}
int ret = 0;
unsigned char *const buf = OPENSSL_malloc(skcontlen);
DER_ENC *encoded = OPENSSL_calloc(sk_ASN1_VALUE_num(sk), sizeof(*encoded));
uint8_t *const buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(skcontlen));
DER_ENC *encoded = reinterpret_cast<DER_ENC *>(
OPENSSL_calloc(sk_ASN1_VALUE_num(sk), sizeof(*encoded)));
uint8_t *p = buf;
if (encoded == NULL || buf == NULL) {
goto err;
}
// Encode all the elements into |buf| and populate |encoded|.
unsigned char *p = buf;
for (size_t i = 0; i < sk_ASN1_VALUE_num(sk); i++) {
ASN1_VALUE *skitem = sk_ASN1_VALUE_value(sk, i);
encoded[i].data = p;
@@ -70,9 +70,6 @@ void ASN1_item_free(ASN1_VALUE *val, const ASN1_ITEM *it) {
}
void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it) {
const ASN1_TEMPLATE *tt = NULL, *seqtt;
const ASN1_EXTERN_FUNCS *ef;
int i;
if (!pval) {
return;
}
@@ -94,19 +91,17 @@ void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it) {
break;
case ASN1_ITYPE_CHOICE: {
const ASN1_AUX *aux = it->funcs;
const ASN1_AUX *aux = reinterpret_cast<const ASN1_AUX *>(it->funcs);
ASN1_aux_cb *asn1_cb = aux != NULL ? aux->asn1_cb : NULL;
if (asn1_cb) {
i = asn1_cb(ASN1_OP_FREE_PRE, pval, it, NULL);
if (i == 2) {
if (asn1_cb(ASN1_OP_FREE_PRE, pval, it, NULL) == 2) {
return;
}
}
i = asn1_get_choice_selector(pval, it);
int i = asn1_get_choice_selector(pval, it);
if ((i >= 0) && (i < it->tcount)) {
ASN1_VALUE **pchval;
tt = it->templates + i;
pchval = asn1_get_field_ptr(pval, tt);
const ASN1_TEMPLATE *tt = it->templates + i;
ASN1_VALUE **pchval = asn1_get_field_ptr(pval, tt);
ASN1_template_free(pchval, tt);
}
if (asn1_cb) {
@@ -117,22 +112,23 @@ void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it) {
break;
}
case ASN1_ITYPE_EXTERN:
ef = it->funcs;
case ASN1_ITYPE_EXTERN: {
const ASN1_EXTERN_FUNCS *ef =
reinterpret_cast<const ASN1_EXTERN_FUNCS *>(it->funcs);
if (ef && ef->asn1_ex_free) {
ef->asn1_ex_free(pval, it);
}
break;
}
case ASN1_ITYPE_SEQUENCE: {
if (!asn1_refcount_dec_and_test_zero(pval, it)) {
return;
}
const ASN1_AUX *aux = it->funcs;
const ASN1_AUX *aux = reinterpret_cast<const ASN1_AUX *>(it->funcs);
ASN1_aux_cb *asn1_cb = aux != NULL ? aux->asn1_cb : NULL;
if (asn1_cb) {
i = asn1_cb(ASN1_OP_FREE_PRE, pval, it, NULL);
if (i == 2) {
if (asn1_cb(ASN1_OP_FREE_PRE, pval, it, NULL) == 2) {
return;
}
}
@@ -140,14 +136,12 @@ void ASN1_item_ex_free(ASN1_VALUE **pval, const ASN1_ITEM *it) {
// If we free up as normal we will invalidate any ANY DEFINED BY
// field and we wont be able to determine the type of the field it
// defines. So free up in reverse order.
tt = it->templates + it->tcount - 1;
for (i = 0; i < it->tcount; tt--, i++) {
ASN1_VALUE **pseqval;
seqtt = asn1_do_adb(pval, tt, 0);
for (int i = it->tcount - 1; i >= 0; i--) {
const ASN1_TEMPLATE *seqtt = asn1_do_adb(pval, &it->templates[i], 0);
if (!seqtt) {
continue;
}
pseqval = asn1_get_field_ptr(pval, seqtt);
ASN1_VALUE **pseqval = asn1_get_field_ptr(pval, seqtt);
ASN1_template_free(pseqval, seqtt);
}
if (asn1_cb) {
@@ -91,7 +91,7 @@ int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it) {
switch (it->itype) {
case ASN1_ITYPE_EXTERN:
ef = it->funcs;
ef = reinterpret_cast<const ASN1_EXTERN_FUNCS *>(it->funcs);
if (ef && ef->asn1_ex_new) {
if (!ef->asn1_ex_new(pval, it)) {
goto memerr;
@@ -116,7 +116,7 @@ int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it) {
break;
case ASN1_ITYPE_CHOICE: {
const ASN1_AUX *aux = it->funcs;
const ASN1_AUX *aux = reinterpret_cast<const ASN1_AUX *>(it->funcs);
ASN1_aux_cb *asn1_cb = aux != NULL ? aux->asn1_cb : NULL;
if (asn1_cb) {
i = asn1_cb(ASN1_OP_NEW_PRE, pval, it, NULL);
@@ -127,7 +127,7 @@ int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it) {
return 1;
}
}
*pval = OPENSSL_zalloc(it->size);
*pval = reinterpret_cast<ASN1_VALUE *>(OPENSSL_zalloc(it->size));
if (!*pval) {
goto memerr;
}
@@ -139,7 +139,7 @@ int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it) {
}
case ASN1_ITYPE_SEQUENCE: {
const ASN1_AUX *aux = it->funcs;
const ASN1_AUX *aux = reinterpret_cast<const ASN1_AUX *>(it->funcs);
ASN1_aux_cb *asn1_cb = aux != NULL ? aux->asn1_cb : NULL;
if (asn1_cb) {
i = asn1_cb(ASN1_OP_NEW_PRE, pval, it, NULL);
@@ -150,7 +150,7 @@ int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it) {
return 1;
}
}
*pval = OPENSSL_zalloc(it->size);
*pval = reinterpret_cast<ASN1_VALUE *>(OPENSSL_zalloc(it->size));
if (!*pval) {
goto memerr;
}
@@ -279,7 +279,8 @@ static int ASN1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it) {
return 1;
case V_ASN1_ANY: {
ASN1_TYPE *typ = OPENSSL_malloc(sizeof(ASN1_TYPE));
ASN1_TYPE *typ =
reinterpret_cast<ASN1_TYPE *>(OPENSSL_malloc(sizeof(ASN1_TYPE)));
if (!typ) {
return 0;
}
@@ -77,7 +77,7 @@
// Given an ASN1_ITEM CHOICE type return the selector value
int asn1_get_choice_selector(ASN1_VALUE **pval, const ASN1_ITEM *it) {
int *sel = offset2ptr(*pval, it->utype);
int *sel = reinterpret_cast<int *>(offset2ptr(*pval, it->utype));
return *sel;
}
@@ -85,7 +85,7 @@ int asn1_get_choice_selector(ASN1_VALUE **pval, const ASN1_ITEM *it) {
int asn1_set_choice_selector(ASN1_VALUE **pval, int value,
const ASN1_ITEM *it) {
int *sel, ret;
sel = offset2ptr(*pval, it->utype);
sel = reinterpret_cast<int *>(offset2ptr(*pval, it->utype));
ret = *sel;
*sel = value;
return ret;
@@ -96,11 +96,12 @@ static CRYPTO_refcount_t *asn1_get_references(ASN1_VALUE **pval,
if (it->itype != ASN1_ITYPE_SEQUENCE) {
return NULL;
}
const ASN1_AUX *aux = it->funcs;
const ASN1_AUX *aux = reinterpret_cast<const ASN1_AUX *>(it->funcs);
if (!aux || !(aux->flags & ASN1_AFLG_REFCOUNT)) {
return NULL;
}
return offset2ptr(*pval, aux->ref_offset);
return reinterpret_cast<CRYPTO_refcount_t *>(
offset2ptr(*pval, aux->ref_offset));
}
void asn1_refcount_set_one(ASN1_VALUE **pval, const ASN1_ITEM *it) {
@@ -124,11 +125,11 @@ static ASN1_ENCODING *asn1_get_enc_ptr(ASN1_VALUE **pval, const ASN1_ITEM *it) {
if (!pval || !*pval) {
return NULL;
}
aux = it->funcs;
aux = reinterpret_cast<const ASN1_AUX *>(it->funcs);
if (!aux || !(aux->flags & ASN1_AFLG_ENCODING)) {
return NULL;
}
return offset2ptr(*pval, aux->enc_offset);
return reinterpret_cast<ASN1_ENCODING *>(offset2ptr(*pval, aux->enc_offset));
}
void asn1_enc_init(ASN1_VALUE **pval, const ASN1_ITEM *it) {
@@ -163,7 +164,7 @@ int asn1_enc_save(ASN1_VALUE **pval, const uint8_t *in, size_t in_len,
enc->buf = buf;
enc->enc = (uint8_t *)in;
} else {
enc->enc = OPENSSL_memdup(in, in_len);
enc->enc = reinterpret_cast<uint8_t *>(OPENSSL_memdup(in, in_len));
if (!enc->enc) {
return 0;
}
@@ -202,7 +203,8 @@ int asn1_enc_restore(int *len, unsigned char **out, ASN1_VALUE **pval,
// Given an ASN1_TEMPLATE get a pointer to a field
ASN1_VALUE **asn1_get_field_ptr(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt) {
ASN1_VALUE **pvaltmp = offset2ptr(*pval, tt->offset);
ASN1_VALUE **pvaltmp =
reinterpret_cast<ASN1_VALUE **>(offset2ptr(*pval, tt->offset));
// NOTE for BOOLEAN types the field is just a plain int so we can't return
// int **, so settle for (int *).
return pvaltmp;
@@ -224,9 +226,10 @@ const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt,
adb = ASN1_ADB_ptr(tt->item);
// Get the selector field
sfld = offset2ptr(*pval, adb->offset);
sfld = reinterpret_cast<ASN1_VALUE **>(offset2ptr(*pval, adb->offset));
// Check if NULL
int selector;
if (*sfld == NULL) {
if (!adb->null_tt) {
goto err;
@@ -238,7 +241,7 @@ const ASN1_TEMPLATE *asn1_do_adb(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt,
// NB: don't check for NID_undef here because it
// might be a legitimate value in the table
assert(tt->flags & ASN1_TFLG_ADB_OID);
int selector = OBJ_obj2nid((ASN1_OBJECT *)*sfld);
selector = OBJ_obj2nid((ASN1_OBJECT *)*sfld);
// Try to find matching entry in table Maybe should check application types
// first to allow application override? Might also be useful to have a flag
@@ -121,12 +121,11 @@ int EVP_EncodedLength(size_t *out_len, size_t len) {
}
EVP_ENCODE_CTX *EVP_ENCODE_CTX_new(void) {
return OPENSSL_zalloc(sizeof(EVP_ENCODE_CTX));
return reinterpret_cast<EVP_ENCODE_CTX *>(
OPENSSL_zalloc(sizeof(EVP_ENCODE_CTX)));
}
void EVP_ENCODE_CTX_free(EVP_ENCODE_CTX *ctx) {
OPENSSL_free(ctx);
}
void EVP_ENCODE_CTX_free(EVP_ENCODE_CTX *ctx) { OPENSSL_free(ctx); }
void EVP_EncodeInit(EVP_ENCODE_CTX *ctx) {
OPENSSL_memset(ctx, 0, sizeof(EVP_ENCODE_CTX));
@@ -302,9 +301,9 @@ static int base64_decode_quad(uint8_t *out, size_t *out_num_bytes,
const uint32_t v = ((uint32_t)a) << 18 | ((uint32_t)b) << 12 |
((uint32_t)c) << 6 | (uint32_t)d;
const unsigned padding_pattern = (in[0] == '=') << 3 |
(in[1] == '=') << 2 |
(in[2] == '=') << 1 |
const unsigned padding_pattern = (in[0] == '=') << 3 | //
(in[1] == '=') << 2 | //
(in[2] == '=') << 1 | //
(in[3] == '=');
// In presence of padding, the lowest bits of v are unused. Canonical encoding
@@ -412,8 +411,7 @@ int EVP_DecodeBase64(uint8_t *out, size_t *out_len, size_t max_out,
}
size_t max_len;
if (!EVP_DecodedLength(&max_len, in_len) ||
max_out < max_len) {
if (!EVP_DecodedLength(&max_len, in_len) || max_out < max_len) {
return 0;
}
@@ -449,7 +447,7 @@ int EVP_DecodeBlock(uint8_t *dst, const uint8_t *src, size_t src_len) {
// Trim newlines, spaces and tabs from the end of the line.
while (src_len > 0) {
switch (src[src_len-1]) {
switch (src[src_len - 1]) {
case ' ':
case '\t':
case '\r':
@@ -462,8 +460,7 @@ int EVP_DecodeBlock(uint8_t *dst, const uint8_t *src, size_t src_len) {
}
size_t dst_len;
if (!EVP_DecodedLength(&dst_len, src_len) ||
dst_len > INT_MAX ||
if (!EVP_DecodedLength(&dst_len, src_len) || dst_len > INT_MAX ||
!EVP_DecodeBase64(dst, &dst_len, dst_len, src, src_len)) {
return -1;
}
@@ -1,4 +1,4 @@
/* Copyright (c) 2024, Google Inc.
/* Copyright 2024 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -17,6 +17,8 @@
#include <CCryptoBoringSSL_base.h>
#include <stdio.h>
// Provided by libcrypto, called from BCM
#if defined(__cplusplus)
@@ -105,6 +107,10 @@ OPENSSL_EXPORT uint64_t CRYPTO_get_fork_generation(void);
OPENSSL_EXPORT void CRYPTO_fork_detect_force_madv_wipeonfork_for_testing(
int on);
// CRYPTO_get_stderr returns stderr. This function exists to avoid BCM needing
// a data dependency on libc.
FILE *CRYPTO_get_stderr(void);
#if defined(__cplusplus)
} // extern C
@@ -73,7 +73,7 @@ static CRYPTO_EX_DATA_CLASS g_ex_data_class =
CRYPTO_EX_DATA_CLASS_INIT_WITH_APP_DATA;
BIO *BIO_new(const BIO_METHOD *method) {
BIO *ret = OPENSSL_zalloc(sizeof(BIO));
BIO *ret = reinterpret_cast<BIO *>(OPENSSL_zalloc(sizeof(BIO)));
if (ret == NULL) {
return NULL;
}
@@ -116,13 +116,9 @@ int BIO_up_ref(BIO *bio) {
return 1;
}
void BIO_vfree(BIO *bio) {
BIO_free(bio);
}
void BIO_vfree(BIO *bio) { BIO_free(bio); }
void BIO_free_all(BIO *bio) {
BIO_free(bio);
}
void BIO_free_all(BIO *bio) { BIO_free(bio); }
int BIO_read(BIO *bio, void *buf, int len) {
if (bio == NULL || bio->method == NULL || bio->method->bread == NULL) {
@@ -136,7 +132,7 @@ int BIO_read(BIO *bio, void *buf, int len) {
if (len <= 0) {
return 0;
}
int ret = bio->method->bread(bio, buf, len);
int ret = bio->method->bread(bio, reinterpret_cast<char *>(buf), len);
if (ret > 0) {
bio->num_read += ret;
}
@@ -174,7 +170,7 @@ int BIO_write(BIO *bio, const void *in, int inl) {
if (inl <= 0) {
return 0;
}
int ret = bio->method->bwrite(bio, in, inl);
int ret = bio->method->bwrite(bio, reinterpret_cast<const char *>(in), inl);
if (ret > 0) {
bio->num_write += ret;
}
@@ -182,7 +178,7 @@ int BIO_write(BIO *bio, const void *in, int inl) {
}
int BIO_write_all(BIO *bio, const void *data, size_t len) {
const uint8_t *data_u8 = data;
const uint8_t *data_u8 = reinterpret_cast<const uint8_t *>(data);
while (len > 0) {
int ret = BIO_write(bio, data_u8, len > INT_MAX ? INT_MAX : (int)len);
if (ret <= 0) {
@@ -204,9 +200,7 @@ int BIO_puts(BIO *bio, const char *in) {
return BIO_write(bio, in, (int)len);
}
int BIO_flush(BIO *bio) {
return (int)BIO_ctrl(bio, BIO_CTRL_FLUSH, 0, NULL);
}
int BIO_flush(BIO *bio) { return (int)BIO_ctrl(bio, BIO_CTRL_FLUSH, 0, NULL); }
long BIO_ctrl(BIO *bio, int cmd, long larg, void *parg) {
if (bio == NULL) {
@@ -237,21 +231,13 @@ long BIO_int_ctrl(BIO *b, int cmd, long larg, int iarg) {
return BIO_ctrl(b, cmd, larg, (void *)&i);
}
int BIO_reset(BIO *bio) {
return (int)BIO_ctrl(bio, BIO_CTRL_RESET, 0, NULL);
}
int BIO_reset(BIO *bio) { return (int)BIO_ctrl(bio, BIO_CTRL_RESET, 0, NULL); }
int BIO_eof(BIO *bio) {
return (int)BIO_ctrl(bio, BIO_CTRL_EOF, 0, NULL);
}
int BIO_eof(BIO *bio) { return (int)BIO_ctrl(bio, BIO_CTRL_EOF, 0, NULL); }
void BIO_set_flags(BIO *bio, int flags) {
bio->flags |= flags;
}
void BIO_set_flags(BIO *bio, int flags) { bio->flags |= flags; }
int BIO_test_flags(const BIO *bio, int flags) {
return bio->flags & flags;
}
int BIO_test_flags(const BIO *bio, int flags) { return bio->flags & flags; }
int BIO_should_read(const BIO *bio) {
return BIO_test_flags(bio, BIO_FLAGS_READ);
@@ -273,9 +259,7 @@ int BIO_get_retry_reason(const BIO *bio) { return bio->retry_reason; }
void BIO_set_retry_reason(BIO *bio, int reason) { bio->retry_reason = reason; }
void BIO_clear_flags(BIO *bio, int flags) {
bio->flags &= ~flags;
}
void BIO_clear_flags(BIO *bio, int flags) { bio->flags &= ~flags; }
void BIO_set_retry_read(BIO *bio) {
bio->flags |= BIO_FLAGS_READ | BIO_FLAGS_SHOULD_RETRY;
@@ -287,9 +271,7 @@ void BIO_set_retry_write(BIO *bio) {
static const int kRetryFlags = BIO_FLAGS_RWS | BIO_FLAGS_SHOULD_RETRY;
int BIO_get_retry_flags(BIO *bio) {
return bio->flags & kRetryFlags;
}
int BIO_get_retry_flags(BIO *bio) { return bio->flags & kRetryFlags; }
void BIO_clear_retry_flags(BIO *bio) {
bio->flags &= ~kRetryFlags;
@@ -318,7 +300,7 @@ long BIO_callback_ctrl(BIO *bio, int cmd, bio_info_cb fp) {
}
size_t BIO_pending(const BIO *bio) {
const long r = BIO_ctrl((BIO *) bio, BIO_CTRL_PENDING, 0, NULL);
const long r = BIO_ctrl((BIO *)bio, BIO_CTRL_PENDING, 0, NULL);
assert(r >= 0);
if (r < 0) {
@@ -327,12 +309,10 @@ size_t BIO_pending(const BIO *bio) {
return r;
}
size_t BIO_ctrl_pending(const BIO *bio) {
return BIO_pending(bio);
}
size_t BIO_ctrl_pending(const BIO *bio) { return BIO_pending(bio); }
size_t BIO_wpending(const BIO *bio) {
const long r = BIO_ctrl((BIO *) bio, BIO_CTRL_WPENDING, 0, NULL);
const long r = BIO_ctrl((BIO *)bio, BIO_CTRL_WPENDING, 0, NULL);
assert(r >= 0);
if (r < 0) {
@@ -430,9 +410,7 @@ static int print_bio(const char *str, size_t len, void *bio) {
return BIO_write_all((BIO *)bio, str, len);
}
void ERR_print_errors(BIO *bio) {
ERR_print_errors_cb(print_bio, bio);
}
void ERR_print_errors(BIO *bio) { ERR_print_errors_cb(print_bio, bio); }
// bio_read_all reads everything from |bio| and prepends |prefix| to it. On
// success, |*out| is set to an allocated buffer (which should be freed with
@@ -454,7 +432,7 @@ static int bio_read_all(BIO *bio, uint8_t **out, size_t *out_len,
if (len < prefix_len) {
return 0;
}
*out = OPENSSL_malloc(len);
*out = reinterpret_cast<uint8_t *>(OPENSSL_malloc(len));
if (*out == NULL) {
return 0;
}
@@ -485,7 +463,8 @@ static int bio_read_all(BIO *bio, uint8_t **out, size_t *out_len,
if (len < kChunkSize || len > max_len) {
len = max_len;
}
uint8_t *new_buf = OPENSSL_realloc(*out, len);
uint8_t *new_buf =
reinterpret_cast<uint8_t *>(OPENSSL_realloc(*out, len));
if (new_buf == NULL) {
OPENSSL_free(*out);
return 0;
@@ -594,7 +573,7 @@ int BIO_read_asn1(BIO *bio, uint8_t **out, size_t *out_len, size_t max_len) {
return 0;
}
if ((len32 >> ((num_bytes-1)*8)) == 0) {
if ((len32 >> ((num_bytes - 1) * 8)) == 0) {
// Length should have been at least one byte shorter.
OPENSSL_PUT_ERROR(ASN1, ASN1_R_DECODE_ERROR);
return 0;
@@ -603,16 +582,14 @@ int BIO_read_asn1(BIO *bio, uint8_t **out, size_t *out_len, size_t max_len) {
len = len32;
}
if (len + header_len < len ||
len + header_len > max_len ||
len > INT_MAX) {
if (len + header_len < len || len + header_len > max_len || len > INT_MAX) {
OPENSSL_PUT_ERROR(ASN1, ASN1_R_TOO_LONG);
return 0;
}
len += header_len;
*out_len = len;
*out = OPENSSL_malloc(len);
*out = reinterpret_cast<uint8_t *>(OPENSSL_malloc(len));
if (*out == NULL) {
return 0;
}
@@ -644,7 +621,8 @@ int BIO_get_new_index(void) {
}
BIO_METHOD *BIO_meth_new(int type, const char *name) {
BIO_METHOD *method = OPENSSL_zalloc(sizeof(BIO_METHOD));
BIO_METHOD *method =
reinterpret_cast<BIO_METHOD *>(OPENSSL_zalloc(sizeof(BIO_METHOD)));
if (method == NULL) {
return NULL;
}
@@ -653,18 +631,14 @@ BIO_METHOD *BIO_meth_new(int type, const char *name) {
return method;
}
void BIO_meth_free(BIO_METHOD *method) {
OPENSSL_free(method);
}
void BIO_meth_free(BIO_METHOD *method) { OPENSSL_free(method); }
int BIO_meth_set_create(BIO_METHOD *method,
int (*create_func)(BIO *)) {
int BIO_meth_set_create(BIO_METHOD *method, int (*create_func)(BIO *)) {
method->create = create_func;
return 1;
}
int BIO_meth_set_destroy(BIO_METHOD *method,
int (*destroy_func)(BIO *)) {
int BIO_meth_set_destroy(BIO_METHOD *method, int (*destroy_func)(BIO *)) {
method->destroy = destroy_func;
return 1;
}
@@ -710,10 +684,10 @@ int BIO_meth_set_puts(BIO_METHOD *method, int (*puts)(BIO *, const char *)) {
return 1;
}
int BIO_get_ex_new_index(long argl, void *argp,
CRYPTO_EX_unused *unused,
CRYPTO_EX_dup *dup_unused,
CRYPTO_EX_free *free_func) {
int BIO_get_ex_new_index(long argl, void *argp, //
CRYPTO_EX_unused *unused, //
CRYPTO_EX_dup *dup_unused, //
CRYPTO_EX_free *free_func) {
return CRYPTO_get_ex_new_index_ex(&g_ex_data_class, argl, argp, free_func);
}
@@ -83,7 +83,7 @@ BIO *BIO_new_mem_buf(const void *buf, ossl_ssize_t len) {
b = (BUF_MEM *)ret->ptr;
// BIO_FLAGS_MEM_RDONLY ensures |b->data| is not written to.
b->data = (void *)buf;
b->data = reinterpret_cast<char *>(const_cast<void *>(buf));
b->length = size;
b->max = size;
@@ -135,7 +135,7 @@ static int mem_read(BIO *bio, char *out, int outl) {
return 0;
}
BUF_MEM *b = bio->ptr;
BUF_MEM *b = reinterpret_cast<BUF_MEM *>(bio->ptr);
int ret = outl;
if ((size_t)ret > b->length) {
ret = (int)b->length;
@@ -169,7 +169,7 @@ static int mem_write(BIO *bio, const char *in, int inl) {
return -1;
}
BUF_MEM *b = bio->ptr;
BUF_MEM *b = reinterpret_cast<BUF_MEM *>(bio->ptr);
if (!BUF_MEM_append(b, in, inl)) {
return -1;
}
@@ -185,14 +185,15 @@ static int mem_gets(BIO *bio, char *buf, int size) {
// The buffer size includes space for the trailing NUL, so we can read at most
// one fewer byte.
BUF_MEM *b = bio->ptr;
BUF_MEM *b = reinterpret_cast<BUF_MEM *>(bio->ptr);
int ret = size - 1;
if ((size_t)ret > b->length) {
ret = (int)b->length;
}
// Stop at the first newline.
const char *newline = OPENSSL_memchr(b->data, '\n', ret);
const char *newline =
reinterpret_cast<char *>(OPENSSL_memchr(b->data, '\n', ret));
if (newline != NULL) {
ret = (int)(newline - b->data + 1);
}
@@ -231,7 +232,7 @@ static long mem_ctrl(BIO *bio, int cmd, long num, void *ptr) {
case BIO_CTRL_INFO:
ret = (long)b->length;
if (ptr != NULL) {
char **pptr = ptr;
char **pptr = reinterpret_cast<char **>(ptr);
*pptr = b->data;
}
break;
@@ -242,7 +243,7 @@ static long mem_ctrl(BIO *bio, int cmd, long num, void *ptr) {
break;
case BIO_C_GET_BUF_MEM_PTR:
if (ptr != NULL) {
BUF_MEM **pptr = ptr;
BUF_MEM **pptr = reinterpret_cast<BUF_MEM **>(ptr);
*pptr = b;
}
break;
@@ -63,9 +63,9 @@
#include <string.h>
#if !defined(OPENSSL_WINDOWS)
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <unistd.h>
#else
OPENSSL_MSVC_PRAGMA(warning(push, 3))
@@ -77,8 +77,8 @@ OPENSSL_MSVC_PRAGMA(warning(pop))
#include <CCryptoBoringSSL_err.h>
#include <CCryptoBoringSSL_mem.h>
#include "internal.h"
#include "../internal.h"
#include "internal.h"
enum {
@@ -109,9 +109,7 @@ typedef struct bio_connect_st {
} BIO_CONNECT;
#if !defined(OPENSSL_WINDOWS)
static int closesocket(int sock) {
return close(sock);
}
static int closesocket(int sock) { return close(sock); }
#endif
// split_host_and_port sets |*out_host| and |*out_port| to the host and port
@@ -231,7 +229,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);
ret = connect(bio->num, (struct sockaddr *)&c->them, c->them_length);
if (ret < 0) {
if (bio_socket_should_retry(ret)) {
BIO_set_flags(bio, (BIO_FLAGS_IO_SPECIAL | BIO_FLAGS_SHOULD_RETRY));
@@ -261,7 +259,8 @@ static int conn_state(BIO *bio, BIO_CONNECT *c) {
BIO_clear_retry_flags(bio);
OPENSSL_PUT_SYSTEM_ERROR();
OPENSSL_PUT_ERROR(BIO, BIO_R_NBIO_CONNECT_ERROR);
ERR_add_error_data(4, "host=", c->param_hostname, ":", c->param_port);
ERR_add_error_data(4, "host=", c->param_hostname, ":",
c->param_port);
ret = 0;
}
goto exit_loop;
@@ -296,7 +295,8 @@ end:
}
static BIO_CONNECT *BIO_CONNECT_new(void) {
BIO_CONNECT *ret = OPENSSL_zalloc(sizeof(BIO_CONNECT));
BIO_CONNECT *ret =
reinterpret_cast<BIO_CONNECT *>(OPENSSL_zalloc(sizeof(BIO_CONNECT)));
if (ret == NULL) {
return NULL;
}
@@ -323,7 +323,7 @@ static int conn_new(BIO *bio) {
}
static void conn_close_socket(BIO *bio) {
BIO_CONNECT *c = (BIO_CONNECT *) bio->ptr;
BIO_CONNECT *c = (BIO_CONNECT *)bio->ptr;
if (bio->num == -1) {
return;
@@ -342,7 +342,7 @@ static int conn_free(BIO *bio) {
conn_close_socket(bio);
}
BIO_CONNECT_free((BIO_CONNECT*) bio->ptr);
BIO_CONNECT_free((BIO_CONNECT *)bio->ptr);
return 1;
}
@@ -422,13 +422,15 @@ static long conn_ctrl(BIO *bio, int cmd, long num, void *ptr) {
bio->init = 1;
if (num == 0) {
OPENSSL_free(data->param_hostname);
data->param_hostname = OPENSSL_strdup(ptr);
data->param_hostname =
OPENSSL_strdup(reinterpret_cast<const char *>(ptr));
if (data->param_hostname == NULL) {
ret = 0;
}
} else if (num == 1) {
OPENSSL_free(data->param_port);
data->param_port = OPENSSL_strdup(ptr);
data->param_port =
OPENSSL_strdup(reinterpret_cast<const char *>(ptr));
if (data->param_port == NULL) {
ret = 0;
}
@@ -464,7 +466,8 @@ static long conn_ctrl(BIO *bio, int cmd, long num, void *ptr) {
case BIO_CTRL_FLUSH:
break;
case BIO_CTRL_GET_CALLBACK: {
int (**fptr)(const BIO *bio, int state, int xret) = ptr;
int (**fptr)(const BIO *bio, int state, int xret);
fptr = reinterpret_cast<decltype(fptr)>(ptr);
*fptr = data->info_callback;
} break;
default:
@@ -487,7 +490,12 @@ static long conn_callback_ctrl(BIO *bio, int cmd, bio_info_cb fp) {
// convention.
OPENSSL_MSVC_PRAGMA(warning(push))
OPENSSL_MSVC_PRAGMA(warning(disable : 4191))
OPENSSL_CLANG_PRAGMA("clang diagnostic push")
OPENSSL_CLANG_PRAGMA(
"clang diagnostic ignored \"-Wunknown-warning-option\"")
OPENSSL_CLANG_PRAGMA("clang diagnostic ignored \"-Wcast-function-type\"")
data->info_callback = (int (*)(const struct bio_st *, int, int))fp;
OPENSSL_CLANG_PRAGMA("clang diagnostic pop")
OPENSSL_MSVC_PRAGMA(warning(pop))
break;
default:
@@ -520,11 +528,11 @@ static const BIO_METHOD methods_connectp = {
const BIO_METHOD *BIO_s_connect(void) { return &methods_connectp; }
int BIO_set_conn_hostname(BIO *bio, const char *name) {
return (int)BIO_ctrl(bio, BIO_C_SET_CONNECT, 0, (void*) name);
return (int)BIO_ctrl(bio, BIO_C_SET_CONNECT, 0, (void *)name);
}
int BIO_set_conn_port(BIO *bio, const char *port_str) {
return (int)BIO_ctrl(bio, BIO_C_SET_CONNECT, 1, (void*) port_str);
return (int)BIO_ctrl(bio, BIO_C_SET_CONNECT, 1, (void *)port_str);
}
int BIO_set_conn_int_port(BIO *bio, const int *port) {
@@ -143,7 +143,7 @@ static int file_free(BIO *bio) {
}
if (bio->init && bio->ptr != NULL) {
fclose(bio->ptr);
fclose(reinterpret_cast<FILE *>(bio->ptr));
bio->ptr = NULL;
}
bio->init = 0;
@@ -208,7 +208,7 @@ static long file_ctrl(BIO *b, int cmd, long num, void *ptr) {
// tested under POSIX will inadvertently change the state of |FILE|
// objects when wrapping them in a |BIO|.
if (num & BIO_FP_TEXT) {
_setmode(_fileno(ptr), _O_TEXT);
_setmode(_fileno(reinterpret_cast<FILE *>(ptr)), _O_TEXT);
}
#endif
b->shutdown = (int)num & BIO_CLOSE;
@@ -236,7 +236,7 @@ static long file_ctrl(BIO *b, int cmd, long num, void *ptr) {
ret = 0;
break;
}
fp = fopen_if_available(ptr, mode);
fp = fopen_if_available(reinterpret_cast<const char *>(ptr), mode);
if (fp == NULL) {
OPENSSL_PUT_SYSTEM_ERROR();
ERR_add_error_data(5, "fopen('", ptr, "','", mode, "')");
@@ -81,7 +81,8 @@ struct bio_bio_st {
};
static int bio_new(BIO *bio) {
struct bio_bio_st *b = OPENSSL_zalloc(sizeof *b);
struct bio_bio_st *b =
reinterpret_cast<bio_bio_st *>(OPENSSL_zalloc(sizeof *b));
if (b == NULL) {
return 0;
}
@@ -92,7 +93,7 @@ static int bio_new(BIO *bio) {
}
static void bio_destroy_pair(BIO *bio) {
struct bio_bio_st *b = bio->ptr;
struct bio_bio_st *b = reinterpret_cast<bio_bio_st *>(bio->ptr);
BIO *peer_bio;
struct bio_bio_st *peer_b;
@@ -105,7 +106,7 @@ static void bio_destroy_pair(BIO *bio) {
return;
}
peer_b = peer_bio->ptr;
peer_b = reinterpret_cast<bio_bio_st *>(peer_bio->ptr);
assert(peer_b != NULL);
assert(peer_b->peer == bio);
@@ -124,7 +125,7 @@ static void bio_destroy_pair(BIO *bio) {
}
static int bio_free(BIO *bio) {
struct bio_bio_st *b = bio->ptr;
struct bio_bio_st *b = reinterpret_cast<bio_bio_st *>(bio->ptr);
assert(b != NULL);
@@ -149,10 +150,10 @@ static int bio_read(BIO *bio, char *buf, int size_) {
return 0;
}
b = bio->ptr;
b = reinterpret_cast<bio_bio_st *>(bio->ptr);
assert(b != NULL);
assert(b->peer != NULL);
peer_b = b->peer->ptr;
peer_b = reinterpret_cast<bio_bio_st *>(b->peer->ptr);
assert(peer_b != NULL);
assert(peer_b->buf != NULL);
@@ -233,7 +234,7 @@ static int bio_write(BIO *bio, const char *buf, int num_) {
return 0;
}
b = bio->ptr;
b = reinterpret_cast<bio_bio_st *>(bio->ptr);
assert(b != NULL);
assert(b->peer != NULL);
assert(b->buf != NULL);
@@ -302,8 +303,8 @@ static int bio_make_pair(BIO *bio1, BIO *bio2, size_t writebuf1_len,
assert(bio1 != NULL);
assert(bio2 != NULL);
b1 = bio1->ptr;
b2 = bio2->ptr;
b1 = reinterpret_cast<bio_bio_st *>(bio1->ptr);
b2 = reinterpret_cast<bio_bio_st *>(bio2->ptr);
if (b1->peer != NULL || b2->peer != NULL) {
OPENSSL_PUT_ERROR(BIO, BIO_R_IN_USE);
@@ -314,7 +315,7 @@ static int bio_make_pair(BIO *bio1, BIO *bio2, size_t writebuf1_len,
if (writebuf1_len) {
b1->size = writebuf1_len;
}
b1->buf = OPENSSL_malloc(b1->size);
b1->buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(b1->size));
if (b1->buf == NULL) {
return 0;
}
@@ -326,7 +327,7 @@ static int bio_make_pair(BIO *bio1, BIO *bio2, size_t writebuf1_len,
if (writebuf2_len) {
b2->size = writebuf2_len;
}
b2->buf = OPENSSL_malloc(b2->size);
b2->buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(b2->size));
if (b2->buf == NULL) {
return 0;
}
@@ -349,13 +350,12 @@ static int bio_make_pair(BIO *bio1, BIO *bio2, size_t writebuf1_len,
static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr) {
long ret;
struct bio_bio_st *b = bio->ptr;
struct bio_bio_st *b = reinterpret_cast<bio_bio_st *>(bio->ptr);
assert(b != NULL);
switch (cmd) {
// specific CTRL codes
// Specific control codes first:
case BIO_C_GET_WRITE_BUF_SIZE:
ret = (long)b->size;
break;
@@ -392,8 +392,8 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr) {
ret = 1;
break;
// standard CTRL codes follow
// Standard control codes:
case BIO_CTRL_GET_CLOSE:
ret = bio->shutdown;
break;
@@ -405,7 +405,8 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr) {
case BIO_CTRL_PENDING:
if (b->peer != NULL) {
struct bio_bio_st *peer_b = b->peer->ptr;
struct bio_bio_st *peer_b =
reinterpret_cast<bio_bio_st *>(b->peer->ptr);
ret = (long)peer_b->len;
} else {
ret = 0;
@@ -424,10 +425,11 @@ static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr) {
break;
case BIO_CTRL_EOF: {
BIO *other_bio = ptr;
BIO *other_bio = reinterpret_cast<BIO *>(ptr);
if (other_bio) {
struct bio_bio_st *other_b = other_bio->ptr;
struct bio_bio_st *other_b =
reinterpret_cast<bio_bio_st *>(other_bio->ptr);
assert(other_b != NULL);
ret = other_b->len == 0 && other_b->closed;
} else {
@@ -449,8 +451,8 @@ static const BIO_METHOD methods_biop = {
static const BIO_METHOD *bio_s_bio(void) { return &methods_biop; }
int BIO_new_bio_pair(BIO** bio1_p, size_t writebuf1_len,
BIO** bio2_p, size_t writebuf2_len) {
int BIO_new_bio_pair(BIO **bio1_p, size_t writebuf1_len, BIO **bio2_p,
size_t writebuf2_len) {
BIO *bio1 = BIO_new(bio_s_bio());
BIO *bio2 = BIO_new(bio_s_bio());
if (bio1 == NULL || bio2 == NULL ||
@@ -75,12 +75,12 @@ int BIO_printf(BIO *bio, const char *format, ...) {
return -1;
}
if ((size_t) out_len >= sizeof(buf)) {
if ((size_t)out_len >= sizeof(buf)) {
const int requested_len = out_len;
// The output was truncated. Note that vsnprintf's return value
// does not include a trailing NUL, but the buffer must be sized
// for it.
out = OPENSSL_malloc(requested_len + 1);
out = reinterpret_cast<char *>(OPENSSL_malloc(requested_len + 1));
out_malloced = 1;
if (out == NULL) {
return -1;
@@ -1,4 +1,4 @@
/* Copyright (c) 2014, Google Inc.
/* Copyright 2014 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -1,4 +1,4 @@
/* Copyright (c) 2021, Google Inc.
/* Copyright 2021 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -121,7 +121,7 @@ void BLAKE2B256_Update(BLAKE2B_CTX *b2b, const void *in_data, size_t len) {
return;
}
const uint8_t *data = in_data;
const uint8_t *data = reinterpret_cast<const uint8_t *>(in_data);
size_t todo = sizeof(b2b->block) - b2b->block_used;
if (todo > len) {
todo = len;
@@ -1,4 +1,4 @@
/* Copyright (c) 2015, Google Inc.
/* Copyright 2015 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -78,8 +78,9 @@ static const char hextable[] = "0123456789abcdef";
char *BN_bn2hex(const BIGNUM *bn) {
int width = bn_minimal_width(bn);
char *buf = OPENSSL_malloc(1 /* leading '-' */ + 1 /* zero is non-empty */ +
width * BN_BYTES * 2 + 1 /* trailing NUL */);
char *buf = reinterpret_cast<char *>(
OPENSSL_malloc(1 /* leading '-' */ + 1 /* zero is non-empty */ +
width * BN_BYTES * 2 + 1 /* trailing NUL */));
if (buf == NULL) {
return NULL;
}
@@ -112,7 +113,7 @@ char *BN_bn2hex(const BIGNUM *bn) {
// decode_hex decodes |in_len| bytes of hex data from |in| and updates |bn|.
static int decode_hex(BIGNUM *bn, const char *in, int in_len) {
if (in_len > INT_MAX/4) {
if (in_len > INT_MAX / 4) {
OPENSSL_PUT_ERROR(BN, BN_R_BIGNUM_TOO_LONG);
return 0;
}
@@ -163,8 +164,7 @@ static int decode_dec(BIGNUM *bn, const char *in, int in_len) {
l *= 10;
l += in[i] - '0';
if (++j == BN_DEC_NUM) {
if (!BN_mul_word(bn, BN_DEC_CONV) ||
!BN_add_word(bn, l)) {
if (!BN_mul_word(bn, BN_DEC_CONV) || !BN_add_word(bn, l)) {
return 0;
}
l = 0;
@@ -174,10 +174,11 @@ static int decode_dec(BIGNUM *bn, const char *in, int in_len) {
return 1;
}
typedef int (*decode_func) (BIGNUM *bn, const char *in, int in_len);
typedef int (*char_test_func) (int c);
typedef int (*decode_func)(BIGNUM *bn, const char *in, int in_len);
typedef int (*char_test_func)(int c);
static int bn_x2bn(BIGNUM **outp, const char *in, decode_func decode, char_test_func want_char) {
static int bn_x2bn(BIGNUM **outp, const char *in, decode_func decode,
char_test_func want_char) {
BIGNUM *ret = NULL;
int neg = 0, i;
int num;
@@ -191,7 +192,8 @@ static int bn_x2bn(BIGNUM **outp, const char *in, decode_func decode, char_test_
in++;
}
for (i = 0; want_char((unsigned char)in[i]) && i + neg < INT_MAX; i++) {}
for (i = 0; want_char((unsigned char)in[i]) && i + neg < INT_MAX; i++) {
}
num = i + neg;
if (outp == NULL) {
@@ -238,7 +240,7 @@ char *BN_bn2dec(const BIGNUM *a) {
// and fix at the end.
BIGNUM *copy = NULL;
CBB cbb;
if (!CBB_init(&cbb, 16) ||
if (!CBB_init(&cbb, 16) || //
!CBB_add_u8(&cbb, 0 /* trailing NUL */)) {
goto err;
}
@@ -270,7 +272,7 @@ char *BN_bn2dec(const BIGNUM *a) {
}
}
if (BN_is_negative(a) &&
if (BN_is_negative(a) && //
!CBB_add_u8(&cbb, '-')) {
goto err;
}
@@ -282,7 +284,7 @@ char *BN_bn2dec(const BIGNUM *a) {
}
// Reverse the buffer.
for (size_t i = 0; i < len/2; i++) {
for (size_t i = 0; i < len / 2; i++) {
uint8_t tmp = data[i];
data[i] = data[len - 1 - i];
data[len - 1 - i] = tmp;
@@ -308,7 +310,7 @@ int BN_asc2bn(BIGNUM **outp, const char *in) {
}
if (in[0] == '0' && (in[1] == 'X' || in[1] == 'x')) {
if (!BN_hex2bn(outp, in+2)) {
if (!BN_hex2bn(outp, in + 2)) {
return 0;
}
} else {
@@ -377,9 +379,7 @@ size_t BN_bn2mpi(const BIGNUM *in, uint8_t *out) {
}
const size_t len = bytes + extend;
if (len < bytes ||
4 + len < len ||
(len & 0xffffffff) != len) {
if (len < bytes || 4 + len < len || (len & 0xffffffff) != len) {
// If we cannot represent the number then we emit zero as the interface
// doesn't allow an error to be signalled.
if (out) {
@@ -411,9 +411,9 @@ BIGNUM *BN_mpi2bn(const uint8_t *in, size_t len, BIGNUM *out) {
OPENSSL_PUT_ERROR(BN, BN_R_BAD_ENCODING);
return NULL;
}
const size_t in_len = ((size_t)in[0] << 24) |
((size_t)in[1] << 16) |
((size_t)in[2] << 8) |
const size_t in_len = ((size_t)in[0] << 24) | //
((size_t)in[1] << 16) | //
((size_t)in[2] << 8) | //
((size_t)in[3]);
if (in_len != len - 4) {
OPENSSL_PUT_ERROR(BN, BN_R_BAD_ENCODING);
@@ -449,7 +449,7 @@ BIGNUM *BN_mpi2bn(const uint8_t *in, size_t len, BIGNUM *out) {
}
int BN_bn2binpad(const BIGNUM *in, uint8_t *out, int len) {
if (len < 0 ||
if (len < 0 || //
!BN_bn2bin_padded(out, (size_t)len, in)) {
return -1;
}
@@ -457,7 +457,7 @@ int BN_bn2binpad(const BIGNUM *in, uint8_t *out, int len) {
}
int BN_bn2lebinpad(const BIGNUM *in, uint8_t *out, int len) {
if (len < 0 ||
if (len < 0 || //
!BN_bn2le_padded(out, (size_t)len, in)) {
return -1;
}
@@ -58,13 +58,15 @@
#include <string.h>
#include <CCryptoBoringSSL_mem.h>
#include <CCryptoBoringSSL_err.h>
#include <CCryptoBoringSSL_mem.h>
#include "../internal.h"
BUF_MEM *BUF_MEM_new(void) { return OPENSSL_zalloc(sizeof(BUF_MEM)); }
BUF_MEM *BUF_MEM_new(void) {
return reinterpret_cast<BUF_MEM *>(OPENSSL_zalloc(sizeof(BUF_MEM)));
}
void BUF_MEM_free(BUF_MEM *buf) {
if (buf == NULL) {
@@ -92,7 +94,8 @@ int BUF_MEM_reserve(BUF_MEM *buf, size_t cap) {
return 0;
}
char *new_buf = OPENSSL_realloc(buf->data, alloc_size);
char *new_buf =
reinterpret_cast<char *>(OPENSSL_realloc(buf->data, alloc_size));
if (new_buf == NULL) {
return 0;
}
@@ -1,4 +1,4 @@
/* Copyright (c) 2016, Google Inc.
/* Copyright 2016 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -1,4 +1,4 @@
/* Copyright (c) 2014, Google Inc.
/* Copyright 2014 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -1,4 +1,4 @@
/* Copyright (c) 2014, Google Inc.
/* Copyright 2014 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -18,15 +18,13 @@
#include <limits.h>
#include <string.h>
#include <CCryptoBoringSSL_mem.h>
#include <CCryptoBoringSSL_err.h>
#include <CCryptoBoringSSL_mem.h>
#include "../internal.h"
void CBB_zero(CBB *cbb) {
OPENSSL_memset(cbb, 0, sizeof(CBB));
}
void CBB_zero(CBB *cbb) { OPENSSL_memset(cbb, 0, sizeof(CBB)); }
static void cbb_init(CBB *cbb, uint8_t *buf, size_t cap, int can_resize) {
cbb->is_child = 0;
@@ -41,7 +39,7 @@ static void cbb_init(CBB *cbb, uint8_t *buf, size_t cap, int can_resize) {
int CBB_init(CBB *cbb, size_t initial_capacity) {
CBB_zero(cbb);
uint8_t *buf = OPENSSL_malloc(initial_capacity);
uint8_t *buf = reinterpret_cast<uint8_t *>(OPENSSL_malloc(initial_capacity));
if (initial_capacity > 0 && buf == NULL) {
return 0;
}
@@ -92,7 +90,8 @@ static int cbb_buffer_reserve(struct cbb_buffer_st *base, uint8_t **out,
if (newcap < base->cap || newcap < newlen) {
newcap = newlen;
}
uint8_t *newbuf = OPENSSL_realloc(base->buf, newcap);
uint8_t *newbuf =
reinterpret_cast<uint8_t *>(OPENSSL_realloc(base->buf, newcap));
if (newbuf == NULL) {
goto err;
}
@@ -200,13 +199,13 @@ int CBB_flush(CBB *cbb) {
assert(child->base == base);
size_t child_start = child->offset + child->pending_len_len;
if (!CBB_flush(cbb->child) ||
child_start < child->offset ||
size_t len;
if (!CBB_flush(cbb->child) || child_start < child->offset ||
base->len < child_start) {
goto err;
}
size_t len = base->len - child_start;
len = base->len - child_start;
if (child->pending_is_asn1) {
// For ASN.1 we assume that we'll only need a single byte for the length.
@@ -215,7 +214,7 @@ int CBB_flush(CBB *cbb) {
uint8_t len_len;
uint8_t initial_length_byte;
assert (child->pending_len_len == 1);
assert(child->pending_len_len == 1);
if (len > 0xfffffffe) {
OPENSSL_PUT_ERROR(CRYPTO, ERR_R_OVERFLOW);
@@ -403,8 +402,7 @@ int CBB_add_zeros(CBB *cbb, size_t len) {
}
int CBB_add_space(CBB *cbb, uint8_t **out_data, size_t len) {
if (!CBB_flush(cbb) ||
!cbb_buffer_add(cbb_get_base(cbb), out_data, len)) {
if (!CBB_flush(cbb) || !cbb_buffer_add(cbb_get_base(cbb), out_data, len)) {
return 0;
}
return 1;
@@ -421,9 +419,7 @@ int CBB_reserve(CBB *cbb, uint8_t **out_data, size_t len) {
int CBB_did_write(CBB *cbb, size_t len) {
struct cbb_buffer_st *base = cbb_get_base(cbb);
size_t newlen = base->len + len;
if (cbb->child != NULL ||
newlen < base->len ||
newlen > base->cap) {
if (cbb->child != NULL || newlen < base->len || newlen > base->cap) {
return 0;
}
base->len = newlen;
@@ -450,33 +446,23 @@ static int cbb_add_u(CBB *cbb, uint64_t v, size_t len_len) {
return 1;
}
int CBB_add_u8(CBB *cbb, uint8_t value) {
return cbb_add_u(cbb, value, 1);
}
int CBB_add_u8(CBB *cbb, uint8_t value) { return cbb_add_u(cbb, value, 1); }
int CBB_add_u16(CBB *cbb, uint16_t value) {
return cbb_add_u(cbb, value, 2);
}
int CBB_add_u16(CBB *cbb, uint16_t value) { return cbb_add_u(cbb, value, 2); }
int CBB_add_u16le(CBB *cbb, uint16_t value) {
return CBB_add_u16(cbb, CRYPTO_bswap2(value));
}
int CBB_add_u24(CBB *cbb, uint32_t value) {
return cbb_add_u(cbb, value, 3);
}
int CBB_add_u24(CBB *cbb, uint32_t value) { return cbb_add_u(cbb, value, 3); }
int CBB_add_u32(CBB *cbb, uint32_t value) {
return cbb_add_u(cbb, value, 4);
}
int CBB_add_u32(CBB *cbb, uint32_t value) { return cbb_add_u(cbb, value, 4); }
int CBB_add_u32le(CBB *cbb, uint32_t value) {
return CBB_add_u32(cbb, CRYPTO_bswap4(value));
}
int CBB_add_u64(CBB *cbb, uint64_t value) {
return cbb_add_u(cbb, value, 8);
}
int CBB_add_u64(CBB *cbb, uint64_t value) { return cbb_add_u(cbb, value, 8); }
int CBB_add_u64le(CBB *cbb, uint64_t value) {
return CBB_add_u64(cbb, CRYPTO_bswap8(value));
@@ -501,13 +487,13 @@ int CBB_add_asn1_uint64(CBB *cbb, uint64_t value) {
int CBB_add_asn1_uint64_with_tag(CBB *cbb, uint64_t value, CBS_ASN1_TAG tag) {
CBB child;
int started = 0;
if (!CBB_add_asn1(cbb, &child, tag)) {
goto err;
}
int started = 0;
for (size_t i = 0; i < 8; i++) {
uint8_t byte = (value >> 8*(7-i)) & 0xff;
uint8_t byte = (value >> 8 * (7 - i)) & 0xff;
if (!started) {
if (byte == 0) {
// Don't encode leading zeros.
@@ -573,8 +559,7 @@ err:
int CBB_add_asn1_octet_string(CBB *cbb, const uint8_t *data, size_t data_len) {
CBB child;
if (!CBB_add_asn1(cbb, &child, CBS_ASN1_OCTETSTRING) ||
!CBB_add_bytes(&child, data, data_len) ||
!CBB_flush(cbb)) {
!CBB_add_bytes(&child, data, data_len) || !CBB_flush(cbb)) {
cbb_on_error(cbb);
return 0;
}
@@ -585,8 +570,7 @@ int CBB_add_asn1_octet_string(CBB *cbb, const uint8_t *data, size_t data_len) {
int CBB_add_asn1_bool(CBB *cbb, int value) {
CBB child;
if (!CBB_add_asn1(cbb, &child, CBS_ASN1_BOOLEAN) ||
!CBB_add_u8(&child, value != 0 ? 0xff : 0) ||
!CBB_flush(cbb)) {
!CBB_add_u8(&child, value != 0 ? 0xff : 0) || !CBB_flush(cbb)) {
cbb_on_error(cbb);
return 0;
}
@@ -620,24 +604,20 @@ int CBB_add_asn1_oid_from_text(CBB *cbb, const char *text, size_t len) {
// OIDs must have at least two components.
uint64_t a, b;
if (!parse_dotted_decimal(&cbs, &a) ||
!parse_dotted_decimal(&cbs, &b)) {
if (!parse_dotted_decimal(&cbs, &a) || !parse_dotted_decimal(&cbs, &b)) {
return 0;
}
// The first component is encoded as 40 * |a| + |b|. This assumes that |a| is
// 0, 1, or 2 and that, when it is 0 or 1, |b| is at most 39.
if (a > 2 ||
(a < 2 && b > 39) ||
b > UINT64_MAX - 80 ||
if (a > 2 || (a < 2 && b > 39) || b > UINT64_MAX - 80 ||
!add_base128_integer(cbb, 40u * a + b)) {
return 0;
}
// The remaining components are encoded unmodified.
while (CBS_len(&cbs) > 0) {
if (!parse_dotted_decimal(&cbs, &a) ||
!add_base128_integer(cbb, a)) {
if (!parse_dotted_decimal(&cbs, &a) || !add_base128_integer(cbb, a)) {
return 0;
}
}
@@ -648,7 +628,8 @@ int CBB_add_asn1_oid_from_text(CBB *cbb, const char *text, size_t len) {
static int compare_set_of_element(const void *a_ptr, const void *b_ptr) {
// See X.690, section 11.6 for the ordering. They are sorted in ascending
// order by their DER encoding.
const CBS *a = a_ptr, *b = b_ptr;
const CBS *a = reinterpret_cast<const CBS *>(a_ptr),
*b = reinterpret_cast<const CBS *>(b_ptr);
size_t a_len = CBS_len(a), b_len = CBS_len(b);
size_t min_len = a_len < b_len ? a_len : b_len;
int ret = OPENSSL_memcmp(CBS_data(a), CBS_data(b), min_len);
@@ -687,8 +668,12 @@ int CBB_flush_asn1_set_of(CBB *cbb) {
// remain valid as we rewrite |cbb|.
int ret = 0;
size_t buf_len = CBB_len(cbb);
uint8_t *buf = OPENSSL_memdup(CBB_data(cbb), buf_len);
CBS *children = OPENSSL_calloc(num_children, sizeof(CBS));
uint8_t *buf =
reinterpret_cast<uint8_t *>(OPENSSL_memdup(CBB_data(cbb), buf_len));
CBS *children =
reinterpret_cast<CBS *>(OPENSSL_calloc(num_children, sizeof(CBS)));
uint8_t *out;
size_t offset = 0;
if (buf == NULL || children == NULL) {
goto err;
}
@@ -701,8 +686,7 @@ int CBB_flush_asn1_set_of(CBB *cbb) {
qsort(children, num_children, sizeof(CBS), compare_set_of_element);
// Write the contents back in the new order.
uint8_t *out = (uint8_t *)CBB_data(cbb);
size_t offset = 0;
out = (uint8_t *)CBB_data(cbb);
for (size_t i = 0; i < num_children; i++) {
OPENSSL_memcpy(out + offset, CBS_data(&children[i]), CBS_len(&children[i]));
offset += CBS_len(&children[i]);
@@ -1,4 +1,4 @@
/* Copyright (c) 2014, Google Inc.
/* Copyright 2014 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -50,7 +50,7 @@ int CBS_stow(const CBS *cbs, uint8_t **out_ptr, size_t *out_len) {
if (cbs->len == 0) {
return 1;
}
*out_ptr = OPENSSL_memdup(cbs->data, cbs->len);
*out_ptr = reinterpret_cast<uint8_t *>(OPENSSL_memdup(cbs->data, cbs->len));
if (*out_ptr == NULL) {
return 0;
}
@@ -62,7 +62,7 @@ int CBS_strdup(const CBS *cbs, char **out_ptr) {
if (*out_ptr != NULL) {
OPENSSL_free(*out_ptr);
}
*out_ptr = OPENSSL_strndup((const char*)cbs->data, cbs->len);
*out_ptr = OPENSSL_strndup((const char *)cbs->data, cbs->len);
return (*out_ptr != NULL);
}
@@ -144,9 +144,7 @@ int CBS_get_u32le(CBS *cbs, uint32_t *out) {
return 1;
}
int CBS_get_u64(CBS *cbs, uint64_t *out) {
return cbs_get_u(cbs, out, 8);
}
int CBS_get_u64(CBS *cbs, uint64_t *out) { return cbs_get_u(cbs, out, 8); }
int CBS_get_u64le(CBS *cbs, uint64_t *out) {
if (!cbs_get_u(cbs, out, 8)) {
@@ -207,7 +205,8 @@ int CBS_get_u24_length_prefixed(CBS *cbs, CBS *out) {
}
int CBS_get_until_first(CBS *cbs, CBS *out, uint8_t c) {
const uint8_t *split = OPENSSL_memchr(CBS_data(cbs), c, CBS_len(cbs));
const uint8_t *split = reinterpret_cast<const uint8_t *>(
OPENSSL_memchr(CBS_data(cbs), c, CBS_len(cbs)));
if (split == NULL) {
return 0;
}
@@ -223,7 +222,7 @@ int CBS_get_u64_decimal(CBS *cbs, uint64_t *out) {
break;
}
CBS_skip(cbs, 1);
if (// Forbid stray leading zeros.
if (/* Forbid stray leading zeros */
(v == 0 && seen_digit) ||
// Check for overflow.
v > UINT64_MAX / 10 || //
@@ -341,7 +340,7 @@ static int cbs_get_any_asn1_element(CBS *cbs, CBS *out, CBS_ASN1_TAG *out_tag,
// 8.1.3.
if ((length_byte & 0x80) == 0) {
// Short form length.
len = ((size_t) length_byte) + header_len;
len = ((size_t)length_byte) + header_len;
if (out_header_len != NULL) {
*out_header_len = header_len;
}
@@ -420,7 +419,7 @@ int CBS_get_any_asn1(CBS *cbs, CBS *out, CBS_ASN1_TAG *out_tag) {
}
int CBS_get_any_asn1_element(CBS *cbs, CBS *out, CBS_ASN1_TAG *out_tag,
size_t *out_header_len) {
size_t *out_header_len) {
return cbs_get_any_asn1_element(cbs, out, out_tag, out_header_len, NULL, NULL,
/*ber_ok=*/0);
}
@@ -515,8 +514,7 @@ int CBS_get_asn1_int64(CBS *cbs, int64_t *out) {
int CBS_get_asn1_bool(CBS *cbs, int *out) {
CBS bytes;
if (!CBS_get_asn1(cbs, &bytes, CBS_ASN1_BOOLEAN) ||
CBS_len(&bytes) != 1) {
if (!CBS_get_asn1(cbs, &bytes, CBS_ASN1_BOOLEAN) || CBS_len(&bytes) != 1) {
return 0;
}
@@ -529,7 +527,8 @@ int CBS_get_asn1_bool(CBS *cbs, int *out) {
return 1;
}
int CBS_get_optional_asn1(CBS *cbs, CBS *out, int *out_present, CBS_ASN1_TAG tag) {
int CBS_get_optional_asn1(CBS *cbs, CBS *out, int *out_present,
CBS_ASN1_TAG tag) {
int present = 0;
if (CBS_peek_asn1_tag(cbs, tag)) {
@@ -576,8 +575,7 @@ int CBS_get_optional_asn1_uint64(CBS *cbs, uint64_t *out, CBS_ASN1_TAG tag,
return 0;
}
if (present) {
if (!CBS_get_asn1_uint64(&child, out) ||
CBS_len(&child) != 0) {
if (!CBS_get_asn1_uint64(&child, out) || CBS_len(&child) != 0) {
return 0;
}
} else {
@@ -597,8 +595,7 @@ int CBS_get_optional_asn1_bool(CBS *cbs, int *out, CBS_ASN1_TAG tag,
uint8_t boolean;
if (!CBS_get_asn1(&child, &child2, CBS_ASN1_BOOLEAN) ||
CBS_len(&child2) != 1 ||
CBS_len(&child) != 0) {
CBS_len(&child2) != 1 || CBS_len(&child) != 0) {
return 0;
}
@@ -619,8 +616,7 @@ int CBS_get_optional_asn1_bool(CBS *cbs, int *out, CBS_ASN1_TAG tag,
int CBS_is_valid_asn1_bitstring(const CBS *cbs) {
CBS in = *cbs;
uint8_t num_unused_bits;
if (!CBS_get_u8(&in, &num_unused_bits) ||
num_unused_bits > 7) {
if (!CBS_get_u8(&in, &num_unused_bits) || num_unused_bits > 7) {
return 0;
}
@@ -707,12 +703,12 @@ int CBS_is_valid_asn1_oid(const CBS *cbs) {
}
char *CBS_asn1_oid_to_text(const CBS *cbs) {
CBS copy = *cbs;
CBB cbb;
if (!CBB_init(&cbb, 32)) {
goto err;
}
CBS copy = *cbs;
// The first component is 40 * value1 + value2, where value1 is 0, 1, or 2.
uint64_t v;
if (!parse_base128_integer(&copy, &v)) {
@@ -724,15 +720,13 @@ char *CBS_asn1_oid_to_text(const CBS *cbs) {
!add_decimal(&cbb, v - 80)) {
goto err;
}
} else if (!add_decimal(&cbb, v / 40) ||
!CBB_add_u8(&cbb, '.') ||
} else if (!add_decimal(&cbb, v / 40) || !CBB_add_u8(&cbb, '.') ||
!add_decimal(&cbb, v % 40)) {
goto err;
}
while (CBS_len(&copy) != 0) {
if (!parse_base128_integer(&copy, &v) ||
!CBB_add_u8(&cbb, '.') ||
if (!parse_base128_integer(&copy, &v) || !CBB_add_u8(&cbb, '.') ||
!add_decimal(&cbb, v)) {
goto err;
}
@@ -740,8 +734,7 @@ char *CBS_asn1_oid_to_text(const CBS *cbs) {
uint8_t *txt;
size_t txt_len;
if (!CBB_add_u8(&cbb, '\0') ||
!CBB_finish(&cbb, &txt, &txt_len)) {
if (!CBB_add_u8(&cbb, '\0') || !CBB_finish(&cbb, &txt, &txt_len)) {
goto err;
}
@@ -814,7 +807,7 @@ static int CBS_parse_rfc5280_time_internal(const CBS *cbs, int is_gentime,
if (!cbs_get_two_digits(&copy, &tmp)) {
return 0;
}
year += tmp;
year += tmp;
} else {
year = 1900;
if (!cbs_get_two_digits(&copy, &tmp)) {
@@ -1,4 +1,4 @@
/* Copyright (c) 2014, Google Inc.
/* Copyright 2014 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -1,4 +1,4 @@
/* Copyright (c) 2018, Google Inc.
/* Copyright 2018 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -1,4 +1,4 @@
/* Copyright (c) 2014, Google Inc.
/* Copyright 2014 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -1,4 +1,4 @@
/* Copyright (c) 2018, Google Inc.
/* Copyright 2018 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -1,4 +1,4 @@
/* Copyright (c) 2017, Google Inc.
/* Copyright 2017 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -1,4 +1,4 @@
/* Copyright (c) 2017, Google Inc.
/* Copyright 2017 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -36,7 +36,7 @@
// Optimised AES-GCM-SIV
struct aead_aes_gcm_siv_asm_ctx {
alignas(16) uint8_t key[16*15];
alignas(16) uint8_t key[16 * 15];
int is_128_bit;
};
@@ -57,15 +57,17 @@ static struct aead_aes_gcm_siv_asm_ctx *asm_ctx_from_ctx(
return (struct aead_aes_gcm_siv_asm_ctx *)(&ctx->state.opaque[offset]);
}
extern "C" {
// aes128gcmsiv_aes_ks writes an AES-128 key schedule for |key| to
// |out_expanded_key|.
extern void aes128gcmsiv_aes_ks(
const uint8_t key[16], uint8_t out_expanded_key[16*15]);
extern void aes128gcmsiv_aes_ks(const uint8_t key[16],
uint8_t out_expanded_key[16 * 15]);
// aes256gcmsiv_aes_ks writes an AES-256 key schedule for |key| to
// |out_expanded_key|.
extern void aes256gcmsiv_aes_ks(
const uint8_t key[32], uint8_t out_expanded_key[16*15]);
extern void aes256gcmsiv_aes_ks(const uint8_t key[32],
uint8_t out_expanded_key[16 * 15]);
}
static int aead_aes_gcm_siv_asm_init(EVP_AEAD_CTX *ctx, const uint8_t *key,
size_t key_len, size_t tag_len) {
@@ -103,6 +105,7 @@ static int aead_aes_gcm_siv_asm_init(EVP_AEAD_CTX *ctx, const uint8_t *key,
static void aead_aes_gcm_siv_asm_cleanup(EVP_AEAD_CTX *ctx) {}
extern "C" {
// aesgcmsiv_polyval_horner updates the POLYVAL value in |in_out_poly| to
// include a number (|in_blocks|) of 16-byte blocks of data from |in|, given
// the POLYVAL key in |key|.
@@ -217,6 +220,7 @@ extern void aes256gcmsiv_enc_msg_x8(const uint8_t *in, uint8_t *out,
const uint8_t *tag,
const struct aead_aes_gcm_siv_asm_ctx *key,
size_t in_len);
}
// gcm_siv_asm_polyval evaluates POLYVAL at |auth_key| on the given plaintext
// and AD. The result is written to |out_tag|.
@@ -228,7 +232,7 @@ static void gcm_siv_asm_polyval(uint8_t out_tag[16], const uint8_t *in,
const size_t ad_blocks = ad_len / 16;
const size_t in_blocks = in_len / 16;
int htable_init = 0;
alignas(16) uint8_t htable[16*8];
alignas(16) uint8_t htable[16 * 8];
if (ad_blocks > 8 || in_blocks > 8) {
htable_init = 1;
@@ -335,8 +339,7 @@ static int aead_aes_gcm_siv_asm_seal_scatter(
const uint64_t in_len_64 = in_len;
const uint64_t ad_len_64 = ad_len;
if (in_len_64 > (UINT64_C(1) << 36) ||
ad_len_64 >= (UINT64_C(1) << 61)) {
if (in_len_64 > (UINT64_C(1) << 36) || ad_len_64 >= (UINT64_C(1) << 61)) {
OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_TOO_LARGE);
return 0;
}
@@ -424,9 +427,9 @@ static int aead_aes_gcm_siv_asm_open_gather(
struct aead_aes_gcm_siv_asm_ctx expanded_key;
if (gcm_siv_ctx->is_128_bit) {
aes128gcmsiv_aes_ks((const uint8_t *) record_enc_key, &expanded_key.key[0]);
aes128gcmsiv_aes_ks((const uint8_t *)record_enc_key, &expanded_key.key[0]);
} else {
aes256gcmsiv_aes_ks((const uint8_t *) record_enc_key, &expanded_key.key[0]);
aes256gcmsiv_aes_ks((const uint8_t *)record_enc_key, &expanded_key.key[0]);
}
// calculated_tag is 16*8 bytes, rather than 16 bytes, because
// aes[128|256]gcmsiv_dec uses the extra as scratch space.
@@ -535,7 +538,7 @@ struct aead_aes_gcm_siv_ctx {
AES_KEY ks;
} ks;
block128_f kgk_block;
unsigned is_256:1;
unsigned is_256 : 1;
};
static_assert(sizeof(((EVP_AEAD_CTX *)NULL)->state) >=
@@ -635,8 +638,8 @@ static void gcm_siv_polyval(
}
uint8_t length_block[16];
CRYPTO_store_u64_le(length_block, ((uint64_t) ad_len) * 8);
CRYPTO_store_u64_le(length_block + 8, ((uint64_t) in_len) * 8);
CRYPTO_store_u64_le(length_block, ((uint64_t)ad_len) * 8);
CRYPTO_store_u64_le(length_block + 8, ((uint64_t)in_len) * 8);
CRYPTO_POLYVAL_update_blocks(&polyval_ctx, length_block,
sizeof(length_block));
@@ -659,10 +662,9 @@ struct gcm_siv_record_keys {
// gcm_siv_keys calculates the keys for a specific GCM-SIV record with the
// given nonce and writes them to |*out_keys|.
static void gcm_siv_keys(
const struct aead_aes_gcm_siv_ctx *gcm_siv_ctx,
struct gcm_siv_record_keys *out_keys,
const uint8_t nonce[EVP_AEAD_AES_GCM_SIV_NONCE_LEN]) {
static void gcm_siv_keys(const struct aead_aes_gcm_siv_ctx *gcm_siv_ctx,
struct gcm_siv_record_keys *out_keys,
const uint8_t nonce[EVP_AEAD_AES_GCM_SIV_NONCE_LEN]) {
const AES_KEY *const key = &gcm_siv_ctx->ks.ks;
uint8_t key_material[(128 /* POLYVAL key */ + 256 /* max AES key */) / 8];
const size_t blocks_needed = gcm_siv_ctx->is_256 ? 6 : 4;
@@ -703,8 +705,7 @@ static int aead_aes_gcm_siv_seal_scatter(
const uint64_t ad_len_64 = ad_len;
if (in_len + EVP_AEAD_AES_GCM_SIV_TAG_LEN < in_len ||
in_len_64 > (UINT64_C(1) << 36) ||
ad_len_64 >= (UINT64_C(1) << 61)) {
in_len_64 > (UINT64_C(1) << 36) || ad_len_64 >= (UINT64_C(1) << 61)) {
OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_TOO_LARGE);
return 0;
}
@@ -830,12 +831,8 @@ const EVP_AEAD *EVP_aead_aes_256_gcm_siv(void) {
#else
const EVP_AEAD *EVP_aead_aes_128_gcm_siv(void) {
return &aead_aes_128_gcm_siv;
}
const EVP_AEAD *EVP_aead_aes_128_gcm_siv(void) { return &aead_aes_128_gcm_siv; }
const EVP_AEAD *EVP_aead_aes_256_gcm_siv(void) {
return &aead_aes_256_gcm_siv;
}
const EVP_AEAD *EVP_aead_aes_256_gcm_siv(void) { return &aead_aes_256_gcm_siv; }
#endif // AES_GCM_SIV_ASM
@@ -1,4 +1,4 @@
/* Copyright (c) 2014, Google Inc.
/* Copyright 2014 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -85,14 +85,16 @@ static int des_cbc_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out, const uint8_t *in,
}
static const EVP_CIPHER evp_des_cbc = {
.nid = NID_des_cbc,
.block_size = 8,
.key_len = 8,
.iv_len = 8,
.ctx_size = sizeof(EVP_DES_KEY),
.flags = EVP_CIPH_CBC_MODE,
.init = des_init_key,
.cipher = des_cbc_cipher,
/*nid=*/NID_des_cbc,
/*block_size=*/8,
/*key_len=*/8,
/*iv_len=*/8,
/*ctx_size=*/sizeof(EVP_DES_KEY),
/*flags=*/EVP_CIPH_CBC_MODE,
/*init=*/des_init_key,
/*cipher=*/des_cbc_cipher,
/*cleanup=*/nullptr,
/*ctrl=*/nullptr,
};
const EVP_CIPHER *EVP_des_cbc(void) { return &evp_des_cbc; }
@@ -112,14 +114,16 @@ static int des_ecb_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out, const uint8_t *in,
}
static const EVP_CIPHER evp_des_ecb = {
.nid = NID_des_ecb,
.block_size = 8,
.key_len = 8,
.iv_len = 0,
.ctx_size = sizeof(EVP_DES_KEY),
.flags = EVP_CIPH_ECB_MODE,
.init = des_init_key,
.cipher = des_ecb_cipher,
/*nid=*/NID_des_ecb,
/*block_size=*/8,
/*key_len=*/8,
/*iv_len=*/0,
/*ctx_size=*/sizeof(EVP_DES_KEY),
/*flags=*/EVP_CIPH_ECB_MODE,
/*init=*/des_init_key,
/*cipher=*/des_ecb_cipher,
/*cleanup=*/nullptr,
/*ctrl=*/nullptr,
};
const EVP_CIPHER *EVP_des_ecb(void) { return &evp_des_ecb; }
@@ -149,14 +153,16 @@ static int des_ede3_cbc_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out,
}
static const EVP_CIPHER evp_des_ede3_cbc = {
.nid = NID_des_ede3_cbc,
.block_size = 8,
.key_len = 24,
.iv_len = 8,
.ctx_size = sizeof(DES_EDE_KEY),
.flags = EVP_CIPH_CBC_MODE,
.init = des_ede3_init_key,
.cipher = des_ede3_cbc_cipher,
/*nid=*/NID_des_ede3_cbc,
/*block_size=*/8,
/*key_len=*/24,
/*iv_len=*/8,
/*ctx_size=*/sizeof(DES_EDE_KEY),
/*flags=*/EVP_CIPH_CBC_MODE,
/*init=*/des_ede3_init_key,
/*cipher=*/des_ede3_cbc_cipher,
/*cleanup=*/nullptr,
/*ctrl=*/nullptr,
};
const EVP_CIPHER *EVP_des_ede3_cbc(void) { return &evp_des_ede3_cbc; }
@@ -172,14 +178,16 @@ static int des_ede_init_key(EVP_CIPHER_CTX *ctx, const uint8_t *key,
}
static const EVP_CIPHER evp_des_ede_cbc = {
.nid = NID_des_ede_cbc,
.block_size = 8,
.key_len = 16,
.iv_len = 8,
.ctx_size = sizeof(DES_EDE_KEY),
.flags = EVP_CIPH_CBC_MODE,
.init = des_ede_init_key,
.cipher = des_ede3_cbc_cipher,
/*nid=*/NID_des_ede_cbc,
/*block_size=*/8,
/*key_len=*/16,
/*iv_len=*/8,
/*ctx_size=*/sizeof(DES_EDE_KEY),
/*flags=*/EVP_CIPH_CBC_MODE,
/*init=*/des_ede_init_key,
/*cipher=*/des_ede3_cbc_cipher,
/*cleanup=*/nullptr,
/*ctrl=*/nullptr,
};
const EVP_CIPHER *EVP_des_ede_cbc(void) { return &evp_des_ede_cbc; }
@@ -191,7 +199,7 @@ static int des_ede_ecb_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out,
}
in_len -= ctx->cipher->block_size;
DES_EDE_KEY *dat = (DES_EDE_KEY *) ctx->cipher_data;
DES_EDE_KEY *dat = (DES_EDE_KEY *)ctx->cipher_data;
for (size_t i = 0; i <= in_len; i += ctx->cipher->block_size) {
DES_ecb3_encrypt_ex(in + i, out + i, &dat->ks.ks[0], &dat->ks.ks[1],
&dat->ks.ks[2], ctx->encrypt);
@@ -200,27 +208,31 @@ static int des_ede_ecb_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out,
}
static const EVP_CIPHER evp_des_ede = {
.nid = NID_des_ede_ecb,
.block_size = 8,
.key_len = 16,
.iv_len = 0,
.ctx_size = sizeof(DES_EDE_KEY),
.flags = EVP_CIPH_ECB_MODE,
.init = des_ede_init_key,
.cipher = des_ede_ecb_cipher,
/*nid=*/NID_des_ede_ecb,
/*block_size=*/8,
/*key_len=*/16,
/*iv_len=*/0,
/*ctx_size=*/sizeof(DES_EDE_KEY),
/*flags=*/EVP_CIPH_ECB_MODE,
/*init=*/des_ede_init_key,
/*cipher=*/des_ede_ecb_cipher,
/*cleanup=*/nullptr,
/*ctrl=*/nullptr,
};
const EVP_CIPHER *EVP_des_ede(void) { return &evp_des_ede; }
static const EVP_CIPHER evp_des_ede3 = {
.nid = NID_des_ede3_ecb,
.block_size = 8,
.key_len = 24,
.iv_len = 0,
.ctx_size = sizeof(DES_EDE_KEY),
.flags = EVP_CIPH_ECB_MODE,
.init = des_ede3_init_key,
.cipher = des_ede_ecb_cipher,
/*nid=*/NID_des_ede3_ecb,
/*block_size=*/8,
/*key_len=*/24,
/*iv_len=*/0,
/*ctx_size=*/sizeof(DES_EDE_KEY),
/*flags=*/EVP_CIPH_ECB_MODE,
/*init=*/des_ede3_init_key,
/*cipher=*/des_ede_ecb_cipher,
/*cleanup=*/nullptr,
/*ctrl=*/nullptr,
};
const EVP_CIPHER *EVP_des_ede3(void) { return &evp_des_ede3; }
@@ -69,8 +69,8 @@ static int null_init_key(EVP_CIPHER_CTX *ctx, const uint8_t *key,
return 1;
}
static int null_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out,
const uint8_t *in, size_t in_len) {
static int null_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out, const uint8_t *in,
size_t in_len) {
if (in != out) {
OPENSSL_memcpy(out, in, in_len);
}
@@ -78,13 +78,16 @@ static int null_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out,
}
static const EVP_CIPHER n_cipher = {
.nid = NID_undef,
.block_size = 1,
.key_len = 0,
.iv_len = 0,
.ctx_size = 0,
.init = null_init_key,
.cipher = null_cipher,
/*nid=*/NID_undef,
/*block_size=*/1,
/*key_len=*/0,
/*iv_len=*/0,
/*ctx_size=*/0,
/*flags=*/0,
/*init=*/null_init_key,
/*cipher=*/null_cipher,
/*cleanup=*/nullptr,
/*ctrl=*/nullptr,
};
const EVP_CIPHER *EVP_enc_null(void) { return &n_cipher; }
@@ -138,7 +138,9 @@
} \
} while (0)
typedef struct rc2_key_st { uint16_t data[64]; } RC2_KEY;
typedef struct rc2_key_st {
uint16_t data[64];
} RC2_KEY;
static void RC2_encrypt(uint32_t *d, RC2_KEY *key) {
int i, n;
@@ -427,29 +429,31 @@ static int rc2_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) {
}
static const EVP_CIPHER rc2_40_cbc = {
.nid = NID_rc2_40_cbc,
.block_size = 8,
.key_len = 5 /* 40 bit */,
.iv_len = 8,
.ctx_size = sizeof(EVP_RC2_KEY),
.flags = EVP_CIPH_CBC_MODE | EVP_CIPH_VARIABLE_LENGTH | EVP_CIPH_CTRL_INIT,
.init = rc2_init_key,
.cipher = rc2_cbc_cipher,
.ctrl = rc2_ctrl,
/*nid=*/NID_rc2_40_cbc,
/*block_size=*/8,
/*key_len=*/5 /* 40 bit */,
/*iv_len=*/8,
/*ctx_size=*/sizeof(EVP_RC2_KEY),
/*flags=*/EVP_CIPH_CBC_MODE | EVP_CIPH_VARIABLE_LENGTH | EVP_CIPH_CTRL_INIT,
/*init=*/rc2_init_key,
/*cipher=*/rc2_cbc_cipher,
/*cleanup=*/nullptr,
/*ctrl=*/rc2_ctrl,
};
const EVP_CIPHER *EVP_rc2_40_cbc(void) { return &rc2_40_cbc; }
static const EVP_CIPHER rc2_cbc = {
.nid = NID_rc2_cbc,
.block_size = 8,
.key_len = 16 /* 128 bit */,
.iv_len = 8,
.ctx_size = sizeof(EVP_RC2_KEY),
.flags = EVP_CIPH_CBC_MODE | EVP_CIPH_VARIABLE_LENGTH | EVP_CIPH_CTRL_INIT,
.init = rc2_init_key,
.cipher = rc2_cbc_cipher,
.ctrl = rc2_ctrl,
/*nid=*/NID_rc2_cbc,
/*block_size=*/8,
/*key_len=*/16 /* 128 bit */,
/*iv_len=*/8,
/*ctx_size=*/sizeof(EVP_RC2_KEY),
/*flags=*/EVP_CIPH_CBC_MODE | EVP_CIPH_VARIABLE_LENGTH | EVP_CIPH_CTRL_INIT,
/*init=*/rc2_init_key,
/*cipher=*/rc2_cbc_cipher,
/*cleanup=*/nullptr,
/*ctrl=*/rc2_ctrl,
};
const EVP_CIPHER *EVP_rc2_cbc(void) { return &rc2_cbc; }
@@ -81,14 +81,16 @@ static int rc4_cipher(EVP_CIPHER_CTX *ctx, uint8_t *out, const uint8_t *in,
}
static const EVP_CIPHER rc4 = {
.nid = NID_rc4,
.block_size = 1,
.key_len = 16,
.iv_len = 0,
.ctx_size = sizeof(RC4_KEY),
.flags = EVP_CIPH_VARIABLE_LENGTH,
.init = rc4_init_key,
.cipher = rc4_cipher,
/*nid=*/NID_rc4,
/*block_size=*/1,
/*key_len=*/16,
/*iv_len=*/0,
/*ctx_size=*/sizeof(RC4_KEY),
/*flags=*/EVP_CIPH_VARIABLE_LENGTH,
/*init=*/rc4_init_key,
/*cipher=*/rc4_cipher,
/*cleanup=*/nullptr,
/*ctrl=*/nullptr,
};
const EVP_CIPHER *EVP_rc4(void) { return &rc4; }
@@ -1,4 +1,4 @@
/* Copyright (c) 2014, Google Inc.
/* Copyright 2014 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -442,6 +442,7 @@ static int aead_tls_get_iv(const EVP_AEAD_CTX *ctx, const uint8_t **out_iv,
const AEAD_TLS_CTX *tls_ctx = (AEAD_TLS_CTX *)&ctx->state;
const size_t iv_len = EVP_CIPHER_CTX_iv_length(&tls_ctx->cipher_ctx);
if (iv_len <= 1) {
OPENSSL_PUT_ERROR(CIPHER, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
return 0;
}
@@ -57,8 +57,8 @@
#include <CCryptoBoringSSL_conf.h>
#include <assert.h>
#include <string.h>
#include <ctype.h>
#include <string.h>
#include <CCryptoBoringSSL_bio.h>
#include <CCryptoBoringSSL_buf.h>
@@ -66,8 +66,8 @@
#include <CCryptoBoringSSL_lhash.h>
#include <CCryptoBoringSSL_mem.h>
#include "internal.h"
#include "../internal.h"
#include "internal.h"
struct conf_section_st {
@@ -106,7 +106,7 @@ CONF *NCONF_new(void *method) {
return NULL;
}
CONF *conf = OPENSSL_malloc(sizeof(CONF));
CONF *conf = reinterpret_cast<CONF *>(OPENSSL_malloc(sizeof(CONF)));
if (conf == NULL) {
return NULL;
}
@@ -121,7 +121,9 @@ CONF *NCONF_new(void *method) {
return conf;
}
CONF_VALUE *CONF_VALUE_new(void) { return OPENSSL_zalloc(sizeof(CONF_VALUE)); }
CONF_VALUE *CONF_VALUE_new(void) {
return reinterpret_cast<CONF_VALUE *>(OPENSSL_zalloc(sizeof(CONF_VALUE)));
}
static void value_free(CONF_VALUE *value) {
if (value == NULL) {
@@ -161,7 +163,8 @@ void NCONF_free(CONF *conf) {
}
static CONF_SECTION *NCONF_new_section(const CONF *conf, const char *section) {
CONF_SECTION *s = OPENSSL_malloc(sizeof(CONF_SECTION));
CONF_SECTION *s =
reinterpret_cast<CONF_SECTION *>(OPENSSL_malloc(sizeof(CONF_SECTION)));
if (!s) {
return NULL;
}
@@ -275,10 +278,10 @@ err:
}
static CONF_SECTION *get_section(const CONF *conf, const char *section) {
CONF_SECTION template;
OPENSSL_memset(&template, 0, sizeof(template));
template.name = (char *) section;
return lh_CONF_SECTION_retrieve(conf->sections, &template);
CONF_SECTION templ;
OPENSSL_memset(&templ, 0, sizeof(templ));
templ.name = (char *)section;
return lh_CONF_SECTION_retrieve(conf->sections, &templ);
}
const STACK_OF(CONF_VALUE) *NCONF_get_section(const CONF *conf,
@@ -292,16 +295,16 @@ const STACK_OF(CONF_VALUE) *NCONF_get_section(const CONF *conf,
const char *NCONF_get_string(const CONF *conf, const char *section,
const char *name) {
CONF_VALUE template, *value;
CONF_VALUE templ, *value;
if (section == NULL) {
section = kDefaultSectionName;
}
OPENSSL_memset(&template, 0, sizeof(template));
template.section = (char *)section;
template.name = (char *)name;
value = lh_CONF_VALUE_retrieve(conf->values, &template);
OPENSSL_memset(&templ, 0, sizeof(templ));
templ.section = (char *)section;
templ.name = (char *)name;
value = lh_CONF_VALUE_retrieve(conf->values, &templ);
if (value == NULL) {
return NULL;
}
@@ -1,4 +1,4 @@
/* Copyright (c) 2015, Google Inc.
/* Copyright 2015 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -1,4 +1,4 @@
/* Copyright (c) 2021, Google Inc.
/* Copyright 2021 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -1,4 +1,4 @@
/* Copyright (c) 2018, Google Inc.
/* Copyright 2018 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -1,4 +1,4 @@
/* Copyright (c) 2016, Google Inc.
/* Copyright 2016 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -1,4 +1,4 @@
/* Copyright (c) 2023, Google Inc.
/* Copyright 2023 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -1,4 +1,4 @@
/* Copyright (c) 2018, Google Inc.
/* Copyright 2018 The BoringSSL Authors
* Copyright (c) 2020, Arm Ltd.
*
* Permission to use, copy, modify, and/or distribute this software for any
@@ -1,4 +1,4 @@
/* Copyright (c) 2022, Google Inc.
/* Copyright 2022 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -14,8 +14,8 @@
#include "internal.h"
#if defined(OPENSSL_ARM) && defined(OPENSSL_FREEBSD) && \
!defined(OPENSSL_STATIC_ARMCAP)
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_ARM) && \
defined(OPENSSL_FREEBSD) && !defined(OPENSSL_STATIC_ARMCAP)
#include <sys/auxv.h>
#include <sys/types.h>
@@ -1,4 +1,4 @@
/* Copyright (c) 2016, Google Inc.
/* Copyright 2016 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -14,8 +14,8 @@
#include "internal.h"
#if defined(OPENSSL_ARM) && defined(OPENSSL_LINUX) && \
!defined(OPENSSL_STATIC_ARMCAP)
#if !defined(OPENSSL_NO_ASM) && defined(OPENSSL_ARM) && \
defined(OPENSSL_LINUX) && !defined(OPENSSL_STATIC_ARMCAP)
#include <errno.h>
#include <fcntl.h>
#include <sys/auxv.h>
@@ -55,7 +55,7 @@ static int read_file(char **out_ptr, size_t *out_len, const char *path) {
static const size_t kReadSize = 1024;
int ret = 0;
size_t cap = kReadSize, len = 0;
char *buf = OPENSSL_malloc(cap);
char *buf = reinterpret_cast<char *>(OPENSSL_malloc(cap));
if (buf == NULL) {
goto err;
}
@@ -66,7 +66,7 @@ static int read_file(char **out_ptr, size_t *out_len, const char *path) {
if (new_cap < cap) {
goto err;
}
char *new_buf = OPENSSL_realloc(buf, new_cap);
char *new_buf = reinterpret_cast<char *>(OPENSSL_realloc(buf, new_cap));
if (new_buf == NULL) {
goto err;
}
@@ -1,4 +1,4 @@
/* Copyright (c) 2018, Google Inc.
/* Copyright 2018 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -56,7 +56,8 @@
#include <CCryptoBoringSSL_base.h>
#if !defined(OPENSSL_NO_ASM) && (defined(OPENSSL_X86) || defined(OPENSSL_X86_64))
#if !defined(OPENSSL_NO_ASM) && \
(defined(OPENSSL_X86) || defined(OPENSSL_X86_64))
#include <inttypes.h>
#include <stdio.h>
@@ -88,21 +89,19 @@ static void OPENSSL_cpuid(uint32_t *out_eax, uint32_t *out_ebx,
#elif defined(__pic__) && defined(OPENSSL_32_BIT)
// Inline assembly may not clobber the PIC register. For 32-bit, this is EBX.
// See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=47602.
__asm__ volatile (
"xor %%ecx, %%ecx\n"
"mov %%ebx, %%edi\n"
"cpuid\n"
"xchg %%edi, %%ebx\n"
: "=a"(*out_eax), "=D"(*out_ebx), "=c"(*out_ecx), "=d"(*out_edx)
: "a"(leaf)
);
__asm__ volatile(
"xor %%ecx, %%ecx\n"
"mov %%ebx, %%edi\n"
"cpuid\n"
"xchg %%edi, %%ebx\n"
: "=a"(*out_eax), "=D"(*out_ebx), "=c"(*out_ecx), "=d"(*out_edx)
: "a"(leaf));
#else
__asm__ volatile (
"xor %%ecx, %%ecx\n"
"cpuid\n"
: "=a"(*out_eax), "=b"(*out_ebx), "=c"(*out_ecx), "=d"(*out_edx)
: "a"(leaf)
);
__asm__ volatile(
"xor %%ecx, %%ecx\n"
"cpuid\n"
: "=a"(*out_eax), "=b"(*out_ebx), "=c"(*out_ecx), "=d"(*out_edx)
: "a"(leaf));
#endif
}
@@ -113,35 +112,51 @@ static uint64_t OPENSSL_xgetbv(uint32_t xcr) {
return (uint64_t)_xgetbv(xcr);
#else
uint32_t eax, edx;
__asm__ volatile ("xgetbv" : "=a"(eax), "=d"(edx) : "c"(xcr));
__asm__ volatile("xgetbv" : "=a"(eax), "=d"(edx) : "c"(xcr));
return (((uint64_t)edx) << 32) | eax;
#endif
}
static bool os_supports_avx512(uint64_t xcr0) {
#if defined(__APPLE__)
// The Darwin kernel had a bug where it could corrupt the opmask registers.
// See
// https://community.intel.com/t5/Software-Tuning-Performance/MacOS-Darwin-kernel-bug-clobbers-AVX-512-opmask-register-state/m-p/1327259
// Darwin also does not initially set the XCR0 bits for AVX512, but they are
// set if the thread tries to use AVX512 anyway. Thus, to safely and
// consistently use AVX512 on macOS we'd need to check the kernel version as
// well as detect AVX512 support using a macOS-specific method. We don't
// bother with this, especially given Apple's transition to arm64.
return false;
#else
return (xcr0 & 0xe6) == 0xe6;
#endif
}
// handle_cpu_env applies the value from |in| to the CPUID values in |out[0]|
// and |out[1]|. See the comment in |OPENSSL_cpuid_setup| about this.
static void handle_cpu_env(uint32_t *out, const char *in) {
const int invert = in[0] == '~';
const int or = in[0] == '|';
const int skip_first_byte = invert || or;
const int hex = in[skip_first_byte] == '0' && in[skip_first_byte+1] == 'x';
const int invert_op = in[0] == '~';
const int or_op = in[0] == '|';
const int skip_first_byte = invert_op || or_op;
const int hex = in[skip_first_byte] == '0' && in[skip_first_byte + 1] == 'x';
int sscanf_result;
uint64_t v;
if (hex) {
sscanf_result = sscanf(in + invert + 2, "%" PRIx64, &v);
sscanf_result = sscanf(in + invert_op + 2, "%" PRIx64, &v);
} else {
sscanf_result = sscanf(in + invert, "%" PRIu64, &v);
sscanf_result = sscanf(in + invert_op, "%" PRIu64, &v);
}
if (!sscanf_result) {
return;
}
if (invert) {
if (invert_op) {
out[0] &= ~v;
out[1] &= ~(v >> 32);
} else if (or) {
} else if (or_op) {
out[0] |= v;
out[1] |= (v >> 32);
} else {
@@ -157,11 +172,11 @@ void OPENSSL_cpuid_setup(void) {
uint32_t num_ids = eax;
int is_intel = ebx == 0x756e6547 /* Genu */ &&
edx == 0x49656e69 /* ineI */ &&
int is_intel = ebx == 0x756e6547 /* Genu */ && //
edx == 0x49656e69 /* ineI */ && //
ecx == 0x6c65746e /* ntel */;
int is_amd = ebx == 0x68747541 /* Auth */ &&
edx == 0x69746e65 /* enti */ &&
int is_amd = ebx == 0x68747541 /* Auth */ && //
edx == 0x69746e65 /* enti */ && //
ecx == 0x444d4163 /* cAMD */;
uint32_t extended_features[2] = {0};
@@ -225,9 +240,9 @@ void OPENSSL_cpuid_setup(void) {
// See Intel manual, volume 1, section 14.3.
if ((xcr0 & 6) != 6) {
// YMM registers cannot be used.
ecx &= ~(1u << 28); // AVX
ecx &= ~(1u << 12); // FMA
ecx &= ~(1u << 11); // AMD XOP
ecx &= ~(1u << 28); // AVX
ecx &= ~(1u << 12); // FMA
ecx &= ~(1u << 11); // AMD XOP
extended_features[0] &= ~(1u << 5); // AVX2
extended_features[1] &= ~(1u << 9); // VAES
extended_features[1] &= ~(1u << 10); // VPCLMULQDQ
@@ -235,7 +250,7 @@ void OPENSSL_cpuid_setup(void) {
// See Intel manual, volume 1, sections 15.2 ("Detection of AVX-512 Foundation
// Instructions") through 15.4 ("Detection of Intel AVX-512 Instruction Groups
// Operating at 256 and 128-bit Vector Lengths").
if ((xcr0 & 0xe6) != 0xe6) {
if (!os_supports_avx512(xcr0)) {
// Without XCR0.111xx11x, no AVX512 feature can be used. This includes ZMM
// registers, masking, SIMD registers 16-31 (even if accessed as YMM or
// XMM), and EVEX-coded instructions (even on YMM or XMM). Even if only
@@ -1,4 +1,4 @@
/* Copyright (c) 2014, Google Inc.
/* Copyright 2014 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -15,9 +15,10 @@
#include <CCryptoBoringSSL_crypto.h>
#include <assert.h>
#include <stdio.h>
#include "fipsmodule/rand/internal.h"
#include "bcm_support.h"
#include "fipsmodule/rand/internal.h"
#include "internal.h"
@@ -53,7 +54,7 @@ static_assert(sizeof(ossl_ssize_t) == sizeof(size_t),
// archive, linking on OS X will fail to resolve common symbols. By
// initialising it to zero, it becomes a "data symbol", which isn't so
// affected.
HIDDEN uint8_t BORINGSSL_function_hit[7] = {0};
HIDDEN uint8_t BORINGSSL_function_hit[8] = {0};
#endif
#if defined(OPENSSL_X86) || defined(OPENSSL_X86_64)
@@ -131,14 +132,6 @@ int CRYPTO_is_confidential_build(void) {
#endif
}
int CRYPTO_has_asm(void) {
#if defined(OPENSSL_NO_ASM)
return 0;
#else
return 1;
#endif
}
void CRYPTO_pre_sandbox_init(void) {
// Read from /proc/cpuinfo if needed.
OPENSSL_init_cpuid();
@@ -186,3 +179,5 @@ int OPENSSL_init_crypto(uint64_t opts, const OPENSSL_INIT_SETTINGS *settings) {
}
void OPENSSL_cleanup(void) {}
FILE *CRYPTO_get_stderr(void) { return stderr; }
@@ -1,6 +1,6 @@
#define BORINGSSL_PREFIX CCryptoBoringSSL
#if defined(__arm__) && defined(__linux__)
/* Copyright (c) 2015, Google Inc.
/* Copyright 2015 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -1,4 +1,4 @@
/* Copyright (c) 2020, Google Inc.
/* Copyright 2020 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
@@ -26,8 +26,8 @@
#include <CCryptoBoringSSL_rand.h>
#include <CCryptoBoringSSL_sha.h>
#include "internal.h"
#include "../internal.h"
#include "internal.h"
// Various pre-computed constants.
#include "./curve25519_tables.h"
@@ -168,13 +168,9 @@ static void fe_tobytes(uint8_t s[32], const fe *f) {
}
// h = 0
static void fe_0(fe *h) {
OPENSSL_memset(h, 0, sizeof(fe));
}
static void fe_0(fe *h) { OPENSSL_memset(h, 0, sizeof(fe)); }
static void fe_loose_0(fe_loose *h) {
OPENSSL_memset(h, 0, sizeof(fe_loose));
}
static void fe_loose_0(fe_loose *h) { OPENSSL_memset(h, 0, sizeof(fe_loose)); }
// h = 1
static void fe_1(fe *h) {
@@ -205,7 +201,7 @@ static void fe_sub(fe_loose *h, const fe *f, const fe *g) {
assert_fe_loose(h->v);
}
static void fe_carry(fe *h, const fe_loose* f) {
static void fe_carry(fe *h, const fe_loose *f) {
assert_fe_loose(f->v);
fiat_25519_carry(h->v, f->v);
assert_fe(h->v);
@@ -261,7 +257,7 @@ static void fe_sq_tt(fe *h, const fe *f) {
//
// Preconditions: b in {0,1}.
static void fe_cswap(fe *f, fe *g, fe_limb_t b) {
b = 0-b;
b = 0 - b;
for (unsigned i = 0; i < FE_NUM_LIMBS; i++) {
fe_limb_t x = f->v[i] ^ g->v[i];
x &= b;
@@ -293,9 +289,8 @@ static void fe_cmov(fe_loose *f, const fe_loose *g, fe_limb_t b) {
//
// TODO(davidben): Switch to fiat's calling convention, or ask fiat to emit a
// different one.
(void)fiat_25519_selectznz;
b = 0-b;
b = 0 - b;
for (unsigned i = 0; i < FE_NUM_LIMBS; i++) {
fe_limb_t x = f->v[i] ^ g->v[i];
x &= b;
@@ -304,9 +299,7 @@ static void fe_cmov(fe_loose *f, const fe_loose *g, fe_limb_t b) {
}
// h = f
static void fe_copy(fe *h, const fe *f) {
OPENSSL_memmove(h, f, sizeof(fe));
}
static void fe_copy(fe *h, const fe *f) { OPENSSL_memmove(h, f, sizeof(fe)); }
static void fe_copy_lt(fe_loose *h, const fe *f) {
static_assert(sizeof(fe_loose) == sizeof(fe), "fe and fe_loose mismatch");
@@ -506,8 +499,8 @@ int x25519_ge_frombytes_vartime(ge_p3 *h, const uint8_t s[32]) {
fe_carry(&u, &v);
fe_add(&v, &vxx, &h->Z); // v = dy^2+1
fe_mul_ttl(&w, &u, &v); // w = u*v
fe_pow22523(&h->X, &w); // x = w^((q-5)/8)
fe_mul_ttl(&w, &u, &v); // w = u*v
fe_pow22523(&h->X, &w); // x = w^((q-5)/8)
fe_mul_ttt(&h->X, &h->X, &u); // x = u*w^((q-5)/8)
fe_sq_tt(&vxx, &h->X);
@@ -706,7 +699,7 @@ void x25519_ge_scalarmult_small_precomp(
for (i = 0; i < 15; i++) {
// The precomputed table is assumed to already clear the top bit, so
// |fe_frombytes_strict| may be used directly.
const uint8_t *bytes = &precomp_table[i*(2 * 32)];
const uint8_t *bytes = &precomp_table[i * (2 * 32)];
fe x, y;
fe_frombytes_strict(&x, bytes);
fe_frombytes_strict(&y, bytes + 32);
@@ -736,7 +729,7 @@ void x25519_ge_scalarmult_small_precomp(
ge_precomp_0(&e);
for (j = 1; j < 16; j++) {
cmov(&e, &multiples[j-1], 1&constant_time_eq_w(index, j));
cmov(&e, &multiples[j - 1], 1 & constant_time_eq_w(index, j));
}
ge_cached cached;
@@ -763,9 +756,11 @@ static void table_select(ge_precomp *t, const int pos, const signed char 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*/);
{static_cast<uint8_t>(constant_time_is_zero_w(b) & 1)},
{static_cast<uint8_t>(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++) {
@@ -787,7 +782,7 @@ static void table_select(ge_precomp *t, const int pos, const signed char b) {
fe_copy_lt(&minust.yplusx, &yminusx);
fe_copy_lt(&minust.yminusx, &yplusx);
fe_neg(&minust.xy2d, &xy2d);
cmov(t, &minust, bnegative>>7);
cmov(t, &minust, bnegative >> 7);
}
// h = a * B
@@ -903,7 +898,7 @@ void x25519_ge_scalarmult(ge_p2 *r, const uint8_t *scalar, const ge_p3 *A) {
ge_p2_dbl(&t, r);
x25519_ge_p1p1_to_p3(&u, &t);
uint8_t index = scalar[31 - i/8];
uint8_t index = scalar[31 - i / 8];
index >>= 4 - (i & 4);
index &= 0xf;
@@ -911,7 +906,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], 1&constant_time_eq_w(index, j));
cmov_cached(&selected, &Ai[j], 1 & constant_time_eq_w(index, j));
}
x25519_ge_add(&t, &u, &selected);
@@ -1937,10 +1932,10 @@ int ED25519_verify(const uint8_t *message, size_t message_len,
// kOrder is the order of Curve25519 in little-endian form.
static const uint64_t kOrder[4] = {
UINT64_C(0x5812631a5cf5d3ed),
UINT64_C(0x14def9dea2f79cd6),
0,
UINT64_C(0x1000000000000000),
UINT64_C(0x5812631a5cf5d3ed),
UINT64_C(0x14def9dea2f79cd6),
0,
UINT64_C(0x1000000000000000),
};
for (size_t i = 3;; i--) {
uint64_t word = CRYPTO_load_u64_le(scopy + i * 8);
@@ -2045,8 +2040,10 @@ static void x25519_scalar_mult_generic(uint8_t out[32],
// Coq transcription of ladderstep formula (called from transcribed loop):
// <https://github.com/mit-plv/fiat-crypto/blob/2456d821825521f7e03e65882cc3521795b0320f/src/Curves/Montgomery/XZ.v#L89>
// <https://github.com/mit-plv/fiat-crypto/blob/2456d821825521f7e03e65882cc3521795b0320f/src/Curves/Montgomery/XZProofs.v#L131>
// x1 != 0 <https://github.com/mit-plv/fiat-crypto/blob/2456d821825521f7e03e65882cc3521795b0320f/src/Curves/Montgomery/XZProofs.v#L217>
// x1 = 0 <https://github.com/mit-plv/fiat-crypto/blob/2456d821825521f7e03e65882cc3521795b0320f/src/Curves/Montgomery/XZProofs.v#L147>
// x1 != 0
// <https://github.com/mit-plv/fiat-crypto/blob/2456d821825521f7e03e65882cc3521795b0320f/src/Curves/Montgomery/XZProofs.v#L217>
// x1 = 0
// <https://github.com/mit-plv/fiat-crypto/blob/2456d821825521f7e03e65882cc3521795b0320f/src/Curves/Montgomery/XZProofs.v#L147>
fe_sub(&tmp0l, &x3, &z3);
fe_sub(&tmp1l, &x2, &z2);
fe_add(&x2l, &x2, &z2);
@@ -1,4 +1,4 @@
/* Copyright (c) 2023, Google Inc.
/* Copyright 2023 The BoringSSL Authors
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
Loaded 100 of 709 files, more files were not shown because too many files have changed in this diff. Show more