diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 00000000..f96b8c06 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,15 @@ +root = true + +[*] +end_of_line = lf +insert_final_newline = true +trim_trailing_whitespace = true +charset = utf-8 + +[*.rs] +indent_style = space +indent_size = 4 + +[*.{yml,yaml,toml}] +indent_style = space +indent_size = 2 diff --git a/.gitattributes b/.gitattributes index dfdb8b77..f7e2def6 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1 +1,2 @@ +* text=auto eol=lf *.sh text eol=lf diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md index 96868fa3..a7bf0449 100644 --- a/.github/PULL_REQUEST_TEMPLATE.md +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -1,16 +1,15 @@ -### Description of Changes: - - - -### Breaking Changes if any: - - - - -### ✅ Admin Checklist -- [ ] Review the PR description and ensure all necessary details are included. -- [ ] Update/add unit tests for changed code. -- [ ] Update/add documentation for new or changed APIs. -- [ ] Run `cargo test --all-features` on `Windows` and `WSL`. - -Check the Developer Guidelines in [DEVELOPER.md](./DEVELOPER.md) for more info. \ No newline at end of file +### Description of Changes: + + + +### Breaking Changes if any: + + + +### ✅ Admin Checklist +- [ ] PR targets the active `release/X.Y.Z` branch. +- [ ] Review the PR description and ensure all necessary details are included. +- [ ] Update/add unit tests for changed code. +- [ ] Update/add documentation for new or changed APIs. + +Check the guidelines in [`CONTRIBUTING.md`](../CONTRIBUTING.md) for more info. diff --git a/.github/workflows/bindgen.yml b/.github/workflows/bindgen.yml index 1783dc40..4d9d68ed 100644 --- a/.github/workflows/bindgen.yml +++ b/.github/workflows/bindgen.yml @@ -5,6 +5,9 @@ on: branches: [ "main" ] pull_request: +permissions: + contents: read + env: CARGO_TERM_COLOR: always diff --git a/.github/workflows/build_linux.yml b/.github/workflows/build_linux.yml index eb00eb76..4968271c 100644 --- a/.github/workflows/build_linux.yml +++ b/.github/workflows/build_linux.yml @@ -1,77 +1,72 @@ -name: Build Linux - -on: - push: - branches: [ "main" ] - pull_request: - -env: - CARGO_TERM_COLOR: always - FEATURES_TO_TEST: md5,sha1,pkcs1-encrypt-decrypt - -jobs: - build: - strategy: - fail-fast: false - matrix: - include: - - target: x86_64-unknown-linux-gnu - os: ubuntu-latest - runs-on: ubuntu-latest - run-tests: true - - target: aarch64-unknown-linux-gnu - os: ubuntu-24.04-arm - runs-on: ubuntu-24.04-arm - run-tests: true - - runs-on: ${{ matrix.os }} - name: ${{ matrix.target }} - env: - CARGO_BUILD_TARGET: ${{ matrix.target }} - - steps: - - uses: actions/checkout@v4 # Checks out SymCrypt based on Github submodule - with: - submodules: true - - - uses: Swatinem/rust-cache@v2 - - # Download SymCrypt via PMC - - name: Install SymCrypt via PMC - shell: bash - run: | - curl -sSL -O https://packages.microsoft.com/config/ubuntu/24.04/packages-microsoft-prod.deb - sudo dpkg -i packages-microsoft-prod.deb - sudo apt-get update - sudo apt-get install -y symcrypt - - - name: Install host target - shell: pwsh - run: | - rustup target add ${{ matrix.target }} - if ("${{ matrix.target }}" -match "aarch64-unknown-linux-gnu") { - sudo apt update - sudo apt install gcc-aarch64-linux-gnu g++-aarch64-linux-gnu - } - - - name: Debug build - run: cargo build --locked --verbose --target ${{ matrix.target }} - - - name: Release build - run: cargo build --release --locked --verbose --target ${{ matrix.target }} - - - name: Run tests (Debug, dynamic) - if: matrix.run-tests - run: cargo test --locked --verbose --all-features --target ${{ matrix.target }} - - - name: Run tests (Release, dynamic) - if: matrix.run-tests - run: cargo test --release --locked --verbose --all-features --target ${{ matrix.target }} - - - name: Run test (Debug, static) - if: matrix.run-tests - run: cargo test --features ${{ env.FEATURES_TO_TEST }} --locked --target ${{ matrix.target }} - - - name: Run test (Release, static) - if: matrix.run-tests - run: cargo test --features ${{ env.FEATURES_TO_TEST }} --locked --target ${{ matrix.target }} +name: Build Linux + +on: + push: + branches: [ "main" ] + pull_request: + +permissions: + contents: read + +env: + CARGO_TERM_COLOR: always + FEATURES_TO_TEST: md5,sha1,pkcs1-encrypt-decrypt + +jobs: + build: + strategy: + fail-fast: false + matrix: + include: + - target: x86_64-unknown-linux-gnu + os: ubuntu-latest + runs-on: ubuntu-latest + run-tests: true + - target: aarch64-unknown-linux-gnu + os: ubuntu-24.04-arm + runs-on: ubuntu-24.04-arm + run-tests: true + + runs-on: ${{ matrix.os }} + name: ${{ matrix.target }} + env: + CARGO_BUILD_TARGET: ${{ matrix.target }} + + steps: + - uses: actions/checkout@v4 # Checks out SymCrypt based on Github submodule + with: + submodules: true + + - uses: Swatinem/rust-cache@v2 + + # Download SymCrypt via PMC + - name: Install SymCrypt via PMC + shell: bash + run: | + curl -sSL -O https://packages.microsoft.com/config/ubuntu/24.04/packages-microsoft-prod.deb + sudo dpkg -i packages-microsoft-prod.deb + sudo apt-get update + sudo apt-get install -y symcrypt + + - name: Install host target + shell: pwsh + run: | + rustup target add ${{ matrix.target }} + if ("${{ matrix.target }}" -match "aarch64-unknown-linux-gnu") { + sudo apt update + sudo apt install gcc-aarch64-linux-gnu g++-aarch64-linux-gnu + } + + - name: Debug build + run: cargo build --locked --verbose --target ${{ matrix.target }} + + - name: Release build + run: cargo build --release --locked --verbose --target ${{ matrix.target }} + + - name: Run tests (Debug) + if: matrix.run-tests + run: cargo test --locked --verbose --all-features --target ${{ matrix.target }} + + - name: Run tests (Release) + if: matrix.run-tests + run: cargo test --release --locked --verbose --all-features --target ${{ matrix.target }} diff --git a/.github/workflows/build_windows.yml b/.github/workflows/build_windows.yml index fd711e3b..827bd548 100644 --- a/.github/workflows/build_windows.yml +++ b/.github/workflows/build_windows.yml @@ -1,76 +1,76 @@ -name: Build Windows - -on: - push: - branches: [ "main" ] - pull_request: - -env: - CARGO_TERM_COLOR: always - FEATURES_TO_TEST: md5,sha1,pkcs1-encrypt-decrypt - -jobs: - build: - strategy: - fail-fast: false - matrix: - include: - - target: x86_64-pc-windows-msvc - os: windows-latest - runs-on: windows-latest - symcrypt: "https://github.com/microsoft/SymCrypt/releases/download/v103.8.0/symcrypt-windows-amd64-release-103.8.0-53be637d.zip" - run-tests: true - - target: aarch64-pc-windows-msvc - os: windows-latest - runs-on: windows-latest - symcrypt: "https://github.com/microsoft/SymCrypt/releases/download/v103.8.0/symcrypt-windows-arm64-release-103.8.0-53be637d.zip" - run-tests: false # Windows doesn't support ARM64 emulation - runs-on: ${{ matrix.os }} - name: ${{ matrix.target }} - env: - CARGO_BUILD_TARGET: ${{ matrix.target }} - - steps: - - uses: actions/checkout@v4 # Checks out SymCrypt based on Github submodule - with: - submodules: true - - - uses: Swatinem/rust-cache@v2 - - # Install host architecture, required for cross-compilation since there is no arm64-windows-msvc runner - - name: Install host target - shell: pwsh - run: | - rustup target add ${{ matrix.target }} - - - name: Download SymCrypt and Set Environment Variables - shell: pwsh - run: | - Invoke-WebRequest -Uri ${{ matrix.symcrypt }} -OutFile symcrypt.zip - New-Item -ItemType Directory -Force -Path symcrypt - Expand-Archive -Path symcrypt.zip -DestinationPath symcrypt - echo "$env:GITHUB_WORKSPACE\symcrypt\dll" >> $env:GITHUB_PATH - echo "SYMCRYPT_LIB_PATH=$env:GITHUB_WORKSPACE\symcrypt\dll" >> $env:GITHUB_ENV - echo "PATH=$env:GITHUB_WORKSPACE\symcrypt\dll;$env:PATH" >> $env:GITHUB_ENV - - - name: Debug build - run: cargo build --locked --verbose --target ${{ matrix.target }} - - - name: Release build - run: cargo build --release --locked --verbose --target ${{ matrix.target }} - - - name: Run tests (Debug, dynamic) - if: matrix.run-tests - run: cargo test --locked --verbose --all-features --target ${{ matrix.target }} - - - name: Run tests (Release, dynamic) - if: matrix.run-tests - run: cargo test --release --locked --verbose --all-features --target ${{ matrix.target }} - - - name: Run test (Debug, static) - if: matrix.run-tests - run: cargo test --features ${{ env.FEATURES_TO_TEST }} --locked --target ${{ matrix.target }} - - - name: Run test (Release, static) - if: matrix.run-tests - run: cargo test --features ${{ env.FEATURES_TO_TEST }} --locked --target ${{ matrix.target }} +# TODO: Re-enable once Azure host images ship with SymCrypt >= v103.11.0. +# The current runner images have an older symcrypt.dll in System32 that causes +# SymCryptModuleInit to crash with STATUS_STACK_BUFFER_OVERRUN. Our downloaded +# v103.11.0 DLL cannot override it reliably via PATH or DLL staging. + +# name: Build Windows +# +# on: +# push: +# branches: [ "main" ] +# pull_request: +# +# permissions: +# contents: read +# +# env: +# CARGO_TERM_COLOR: always +# FEATURES_TO_TEST: md5,sha1,pkcs1-encrypt-decrypt +# +# jobs: +# build: +# strategy: +# fail-fast: false +# matrix: +# include: +# - target: x86_64-pc-windows-msvc +# os: windows-latest +# runs-on: windows-latest +# symcrypt: "https://github.com/microsoft/SymCrypt/releases/download/v103.11.0/symcrypt-windows-amd64-release-103.11.0-748c20f1.zip" +# run-tests: true +# - target: aarch64-pc-windows-msvc +# os: windows-latest +# runs-on: windows-latest +# symcrypt: "https://github.com/microsoft/SymCrypt/releases/download/v103.11.0/symcrypt-windows-arm64-release-103.11.0-748c20f1.zip" +# run-tests: false # Windows doesn't support ARM64 emulation +# runs-on: ${{ matrix.os }} +# name: ${{ matrix.target }} +# env: +# CARGO_BUILD_TARGET: ${{ matrix.target }} +# +# steps: +# - uses: actions/checkout@v4 # Checks out SymCrypt based on Github submodule +# with: +# submodules: true +# +# - uses: Swatinem/rust-cache@v2 +# +# # Install host architecture, required for cross-compilation since there is no arm64-windows-msvc runner +# - name: Install host target +# shell: pwsh +# run: | +# rustup target add ${{ matrix.target }} +# +# - name: Download SymCrypt and Set Environment Variables +# shell: pwsh +# run: | +# Invoke-WebRequest -Uri ${{ matrix.symcrypt }} -OutFile symcrypt.zip +# New-Item -ItemType Directory -Force -Path symcrypt +# Expand-Archive -Path symcrypt.zip -DestinationPath symcrypt +# echo "$env:GITHUB_WORKSPACE\symcrypt\dll" >> $env:GITHUB_PATH +# echo "SYMCRYPT_LIB_PATH=$env:GITHUB_WORKSPACE\symcrypt\dll" >> $env:GITHUB_ENV +# echo "PATH=$env:GITHUB_WORKSPACE\symcrypt\dll;$env:PATH" >> $env:GITHUB_ENV +# +# - name: Debug build +# run: cargo build --locked --verbose --target ${{ matrix.target }} +# +# - name: Release build +# run: cargo build --release --locked --verbose --target ${{ matrix.target }} +# +# - name: Run tests (Debug) +# if: matrix.run-tests +# run: cargo test --locked --verbose --all-features --target ${{ matrix.target }} +# +# - name: Run tests (Release) +# if: matrix.run-tests +# run: cargo test --release --locked --verbose --all-features --target ${{ matrix.target }} diff --git a/.github/workflows/check-submodule.yml b/.github/workflows/check-submodule.yml index 718401f0..39d48d47 100644 --- a/.github/workflows/check-submodule.yml +++ b/.github/workflows/check-submodule.yml @@ -1,34 +1,37 @@ -name: Check Submodule Version - -on: - push: - branches: [ "main" ] - pull_request: - -jobs: - check-submodule: - runs-on: ubuntu-latest - steps: - - name: Checkout Repository with Submodules - uses: actions/checkout@v4 - with: - submodules: true - - - name: Get Expected Commit from VERSION.md - id: expected_commit - run: echo "EXPECTED_COMMIT=$(cat symcrypt-sys/VERSION.md | tr -d '[:space:]')" >> $GITHUB_ENV - - - name: Get Current Submodule Commit - id: current_commit - run: echo "CURRENT_COMMIT=$(git rev-parse HEAD:symcrypt-sys/symcrypt | tr -d '[:space:]')" >> $GITHUB_ENV - - - name: Compare Commits - run: | - if [ "$EXPECTED_COMMIT" != "$CURRENT_COMMIT" ]; then - echo "❌ Submodule commit mismatch!" - echo "Expected: $EXPECTED_COMMIT" - echo "Found: $CURRENT_COMMIT" - exit 1 - else - echo "✅ Submodule commit matches VERSION.md" - fi +name: Check Submodule Version + +on: + push: + branches: [ "main" ] + pull_request: + +permissions: + contents: read + +jobs: + check-submodule: + runs-on: ubuntu-latest + steps: + - name: Checkout Repository with Submodules + uses: actions/checkout@v4 + with: + submodules: true + + - name: Get Expected Commit from VERSION.md + id: expected_commit + run: echo "EXPECTED_COMMIT=$(cat symcrypt-sys/VERSION.md | tr -d '[:space:]')" >> $GITHUB_ENV + + - name: Get Current Submodule Commit + id: current_commit + run: echo "CURRENT_COMMIT=$(git rev-parse HEAD:symcrypt-sys/symcrypt | tr -d '[:space:]')" >> $GITHUB_ENV + + - name: Compare Commits + run: | + if [ "$EXPECTED_COMMIT" != "$CURRENT_COMMIT" ]; then + echo "❌ Submodule commit mismatch!" + echo "Expected: $EXPECTED_COMMIT" + echo "Found: $CURRENT_COMMIT" + exit 1 + else + echo "✅ Submodule commit matches VERSION.md" + fi diff --git a/.github/workflows/clippy.yml b/.github/workflows/clippy.yml index 763ba9e0..dc4186e7 100644 --- a/.github/workflows/clippy.yml +++ b/.github/workflows/clippy.yml @@ -1,32 +1,37 @@ -name: Cargo Clippy Check - -on: - push: - branches: [ "main" ] - pull_request: - -env: - CARGO_TERM_COLOR: always - SYMCRYPT_LIB_PATH: "/dev/null" # Dummy value to bypass the env variable check on Windows - - -jobs: - clippy: - name: Clippy Check - runs-on: ${{ matrix.os }} - - strategy: - matrix: - os: [ubuntu-latest, windows-latest] # Run on Linux and Windows - - steps: - - name: Checkout sources - uses: actions/checkout@v4 - - - name: Install Rust toolchain - uses: dtolnay/rust-toolchain@stable - with: - components: clippy - - - name: Run Clippy - run: cargo clippy --all-targets --all-features -- -D warnings +name: Cargo Clippy Check + +on: + push: + branches: [ "main" ] + pull_request: + +permissions: + contents: read + +env: + CARGO_TERM_COLOR: always + SYMCRYPT_LIB_PATH: "/dev/null" # Dummy value to bypass the env variable check on Windows + + +jobs: + clippy: + name: Clippy Check + runs-on: ${{ matrix.os }} + + strategy: + matrix: + os: [ubuntu-latest, windows-latest] # Run on Linux and Windows + + steps: + - name: Checkout sources + uses: actions/checkout@v4 + with: + submodules: true + + - name: Install Rust toolchain + uses: dtolnay/rust-toolchain@stable + with: + components: clippy + + - name: Run Clippy + run: cargo clippy --all-targets --all-features -- -D warnings diff --git a/.github/workflows/fmt.yml b/.github/workflows/fmt.yml index 6cd82978..4b3c13ae 100644 --- a/.github/workflows/fmt.yml +++ b/.github/workflows/fmt.yml @@ -1,26 +1,29 @@ -name: Cargo Fmt Check - -on: - push: - branches: [ "main" ] - pull_request: - -env: - CARGO_TERM_COLOR: always - -jobs: - format: - name: Format Check - runs-on: ubuntu-latest - - steps: - - name: Checkout sources - uses: actions/checkout@v4 - - - name: Install Rust toolchain - uses: dtolnay/rust-toolchain@stable - with: - components: rustfmt - - - name: Check formatting - run: cargo fmt --all -- --check +name: Cargo Fmt Check + +on: + push: + branches: [ "main" ] + pull_request: + +permissions: + contents: read + +env: + CARGO_TERM_COLOR: always + +jobs: + format: + name: Format Check + runs-on: ubuntu-latest + + steps: + - name: Checkout sources + uses: actions/checkout@v4 + + - name: Install Rust toolchain + uses: dtolnay/rust-toolchain@stable + with: + components: rustfmt + + - name: Check formatting + run: cargo fmt --all -- --check diff --git a/.github/workflows/linelint.yml b/.github/workflows/linelint.yml index 8ac3894d..988127e3 100644 --- a/.github/workflows/linelint.yml +++ b/.github/workflows/linelint.yml @@ -5,6 +5,9 @@ on: branches: [ "main" ] pull_request: +permissions: + contents: read + jobs: linelint: runs-on: ubuntu-latest diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 00000000..6f2a5e73 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,121 @@ +# Contributing to rust-symcrypt + +Thank you for your interest in contributing. This document covers the branch model, how to send pull requests, and technical workflows for maintainers. + +--- + +## Branch Model + +| Branch | Purpose | +|---|---| +| `main` | Published releases only (tagged) | +| `release/X.Y.Z` | Staging for the next release | +| `experimental/static-linking` | Long-lived experimental work (not yet released) | +| `user//` | Individual contributor branches | + +### `main` +Matches the latest published crate version exactly. Only updated when a release ships. `main` is never committed to directly. Every commit on `main` has a corresponding version tag (`0.5.1`, `0.6.0`, etc.). + +### `release/X.Y.Z` +The active staging branch for the next release. Feature and fix PRs should target this branch. When the release is ready, it is merged into `main` and tagged. The branch is kept alive afterward for backporting critical fixes. + +**To find the current active release branch**, check the branch list, it will be the most recent `release/` branch. + +### `experimental/static-linking` +WIP static linking support. Not part of any release yet, periodic rebases onto `main`. + +--- + +## How to Contribute + +1. **Fork** the repository and create your branch from the active `release/X.Y.Z` branch: + ```bash + git checkout -b user// origin/release/X.Y.Z + ``` + +2. **Make your changes.** Follow the existing code style and FFI safety conventions used throughout the codebase. + +3. **Run the full test suite** on both Windows and Linux (WSL) before opening a PR: + ```bash + cargo test --all-features --locked + cargo clippy --all-features -- -D warnings + cargo fmt --check + ``` + +4. **Open a PR** targeting the active `release/X.Y.Z` branch (not `main`). + +5. Ensure all CI checks pass. + +--- + +## Repo Structure + +This repo contains `symcrypt` and `symcrypt-sys` as a Cargo workspace, with the former depending on the latter. `symcrypt-bindgen` is a build tool for generating FFI bindings. + +--- + +## Generating Bindings + +Bindings can be generated two ways: + +1. **With the `generate-all-bindings.ps1` script.** Requires build dependencies installed locally. See the script for installation instructions. + +2. **Via GitHub Actions.** Create a PR with the `publish_new_bindings` label. This produces an artifact with bindings for each supported target triple. The action pulls SymCrypt from the GitHub submodule, not from the PR branch. + +**Note:** CI validates that checked-in bindings match freshly generated ones. A mismatch fails the build. + +### Adding New APIs + +1. Ensure you have the correct SymCrypt submodule (see [Updating the SymCrypt Submodule](#updating-the-symcrypt-submodule) if needed). +2. Add the new SymCrypt APIs to `symcrypt-bindgen/src/main.rs`. Use regex semantics to expose only the needed symbols. +3. Generate new bindings via GitHub Actions or the `generate-all-bindings.ps1` script. +4. Implement safe wrappers in `rust-symcrypt/`. Document your changes and update the API list in `rust-symcrypt/README.md`. +5. Push and ensure all CI checks pass. +6. Depending on the change, you may need to bump the crate version (see [Publishing](#publishing)). + +### Updating the SymCrypt Submodule + +You may need to update the underlying SymCrypt version when: +- Adding bindings for newly released SymCrypt APIs +- Applying a security patch from SymCrypt + +`symcrypt-sys` depends on SymCrypt via a GitHub submodule. The pinned commit is recorded in `symcrypt-sys/VERSION.md`, and CI validates the submodule matches it. + +To update: +1. In `symcrypt-sys/symcrypt/`, check out the required commit (should be a tagged SymCrypt release). +2. Stage: `git add symcrypt-sys/symcrypt`. +3. Update `symcrypt-sys/VERSION.md` with the new commit hash. +4. Update `rust-symcrypt/README.md` with the new SymCrypt version. +5. Update `build_windows.yml` and `build_linux.yml` to download the matching SymCrypt release artifacts. +6. Push and ensure the `check-submodule` CI check passes. + +--- + +## Release Flow + +Releases are managed by the maintainers. The general flow is: + +``` +feature PRs -> release/X.Y.Z -> PR into main -> tag vX.Y.Z -> publish to crates.io +``` + +### Publishing + +1. Branch: `user//bump_version_0.X.X`. +2. Bump the version in the relevant `Cargo.toml`(s). Follow [semver](https://semver.org/). +3. Update `README.md` with the new version. +4. Test: `cargo test --all-features` on both Windows and WSL. +5. Open a PR against the active `release/X.Y.Z` branch. Wait for review and CI. +6. Once the release PR is merged into `main`, check out `main` and prep the Cargo release. +7. Ensure no uncommitted changes exist (they would be included in the publish). +8. Verify: `cargo package --list`. +9. Dry run: `cargo publish --dry-run`. +10. Publish: `cargo publish`. +11. Create a GitHub release tag. Highlight any breaking changes. +12. For critical bugs (dangling pointer, invalid memory), discuss a [cargo yank](https://doc.rust-lang.org/cargo/commands/cargo-yank.html) with the team. + +--- + +## Support and Reporting Issues + +If you have a question, bug report, or feature request, please [open a GitHub issue](https://github.com/microsoft/rust-symcrypt/issues). diff --git a/Cargo.lock b/Cargo.lock index 22ad5e62..551f18bf 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1,21 +1,21 @@ # This file is automatically @generated by Cargo. # It is not intended for manual editing. -version = 3 +version = 4 [[package]] name = "aho-corasick" -version = "1.1.3" +version = "1.1.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916" +checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301" dependencies = [ "memchr", ] [[package]] name = "anyhow" -version = "1.0.95" +version = "1.0.102" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "34ac096ce696dc2fcabef30516bb13c0a68a11d30131d3df6f04711467681b04" +checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c" [[package]] name = "bindgen" @@ -23,7 +23,7 @@ version = "0.71.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3" dependencies = [ - "bitflags 2.8.0", + "bitflags 2.11.0", "cexpr", "clang-sys", "itertools", @@ -45,18 +45,9 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "bitflags" -version = "2.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f68f53c83ab957f72c32642f3868eec03eb974d1fb82e453128456482613d36" - -[[package]] -name = "cc" -version = "1.2.10" +version = "2.11.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "13208fcbb66eaeffe09b99fffbe1af420f00a7b35aa99ad683dfc1aa76145229" -dependencies = [ - "shlex", -] +checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af" [[package]] name = "cexpr" @@ -69,9 +60,9 @@ dependencies = [ [[package]] name = "cfg-if" -version = "1.0.0" +version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" +checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" [[package]] name = "clang-sys" @@ -86,9 +77,9 @@ dependencies = [ [[package]] name = "cmd_lib" -version = "1.9.5" +version = "1.9.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "371c15a3c178d0117091bd84414545309ca979555b1aad573ef591ad58818d41" +checksum = "1af0f9b65935ff457da75535a6b6ff117ac858f03f71191188b3b696f90aec5a" dependencies = [ "cmd_lib_macros", "env_logger", @@ -100,9 +91,9 @@ dependencies = [ [[package]] name = "cmd_lib_macros" -version = "1.9.5" +version = "1.9.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cb844bd05be34d91eb67101329aeba9d3337094c04fd8507d821db7ebb488eaf" +checksum = "1e69eee115667ccda8b9ed7010bcf13356ad45269fc92aa78534890b42809a64" dependencies = [ "proc-macro-error2", "proc-macro2", @@ -112,9 +103,9 @@ dependencies = [ [[package]] name = "either" -version = "1.13.0" +version = "1.15.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0" +checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719" [[package]] name = "env_logger" @@ -142,15 +133,15 @@ dependencies = [ [[package]] name = "glob" -version = "0.3.2" +version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2" +checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280" [[package]] name = "hermit-abi" -version = "0.4.0" +version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fbf6a919d6cf397374f7dfeeea91d974c7c0a7221d0d0f4f20d859d329e53fcc" +checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c" [[package]] name = "hex" @@ -160,19 +151,19 @@ checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" [[package]] name = "humantime" -version = "2.1.0" +version = "2.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4" +checksum = "135b12329e5e3ce057a9f972339ea52bc954fe1e9358ef27f95e89716fbc5424" [[package]] name = "is-terminal" -version = "0.4.13" +version = "0.4.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "261f68e344040fbd0edea105bef17c66edf46f984ddb1115b775ce31be948f4b" +checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46" dependencies = [ "hermit-abi", "libc", - "windows-sys 0.52.0", + "windows-sys", ] [[package]] @@ -186,9 +177,9 @@ dependencies = [ [[package]] name = "itoa" -version = "1.0.14" +version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d75a2a4b1b190afb6f5425f10f6a8f959d2ea0b9c2b1d79553551850539e4674" +checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" [[package]] name = "lazy_static" @@ -198,31 +189,31 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe" [[package]] name = "libc" -version = "0.2.169" +version = "0.2.183" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a" +checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d" [[package]] name = "libloading" -version = "0.8.6" +version = "0.8.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34" +checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55" dependencies = [ "cfg-if", - "windows-targets", + "windows-link", ] [[package]] name = "log" -version = "0.4.25" +version = "0.4.29" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "04cbf5b083de1c7e0222a7a51dbfdba1cbe1c6ab0b15e29fff3f6c077fd9cd9f" +checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897" [[package]] name = "memchr" -version = "2.7.4" +version = "2.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" +checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79" [[package]] name = "minimal-lexical" @@ -242,19 +233,19 @@ dependencies = [ [[package]] name = "os_pipe" -version = "1.2.1" +version = "1.2.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ffd2b0a5634335b135d5728d84c5e0fd726954b87111f7506a61c502280d982" +checksum = "7d8fae84b431384b68627d0f9b3b1245fcf9f46f6c0e3dc902e9dce64edd1967" dependencies = [ "libc", - "windows-sys 0.59.0", + "windows-sys", ] [[package]] name = "prettyplease" -version = "0.2.29" +version = "0.2.37" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6924ced06e1f7dfe3fa48d57b9f74f55d8915f5036121bef647ef4b204895fac" +checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" dependencies = [ "proc-macro2", "syn", @@ -284,27 +275,27 @@ dependencies = [ [[package]] name = "proc-macro2" -version = "1.0.93" +version = "1.0.106" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "60946a68e5f9d28b0dc1c21bb8a97ee7d018a8b322fa57838ba31cc878e22d99" +checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934" dependencies = [ "unicode-ident", ] [[package]] name = "quote" -version = "1.0.38" +version = "1.0.45" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc" +checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924" dependencies = [ "proc-macro2", ] [[package]] name = "regex" -version = "1.11.1" +version = "1.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191" +checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276" dependencies = [ "aho-corasick", "memchr", @@ -314,9 +305,9 @@ dependencies = [ [[package]] name = "regex-automata" -version = "0.4.9" +version = "0.4.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908" +checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f" dependencies = [ "aho-corasick", "memchr", @@ -325,36 +316,39 @@ dependencies = [ [[package]] name = "regex-syntax" -version = "0.8.5" +version = "0.8.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c" +checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a" [[package]] name = "rustc-hash" -version = "2.1.0" +version = "2.1.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c7fb8039b3032c191086b10f11f319a6e99e1e82889c5cc6046f515c9db1d497" +checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe" [[package]] -name = "ryu" -version = "1.0.18" +name = "serde" +version = "1.0.228" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f" +checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e" +dependencies = [ + "serde_core", +] [[package]] -name = "serde" -version = "1.0.217" +name = "serde_core" +version = "1.0.228" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "02fc4265df13d6fa1d00ecff087228cc0a2b5f3c0e87e258d8b94a156e984c70" +checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" -version = "1.0.217" +version = "1.0.228" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a9bf7cf98d04a2b28aead066b7496853d4779c9cc183c440dbac457641e19a0" +checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" dependencies = [ "proc-macro2", "quote", @@ -363,14 +357,15 @@ dependencies = [ [[package]] name = "serde_json" -version = "1.0.135" +version = "1.0.149" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b0d7ba2887406110130a978386c4e1befb98c674b4fba677954e4db976630d9" +checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86" dependencies = [ "itoa", "memchr", - "ryu", "serde", + "serde_core", + "zmij", ] [[package]] @@ -381,10 +376,9 @@ checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" [[package]] name = "symcrypt" -version = "0.5.1" +version = "0.6.0" dependencies = [ "hex", - "lazy_static", "libc", "symcrypt-sys", ] @@ -404,15 +398,14 @@ dependencies = [ name = "symcrypt-sys" version = "0.4.0" dependencies = [ - "cc", "libc", ] [[package]] name = "syn" -version = "2.0.96" +version = "2.0.117" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d5d0adab1ae378d7f53bdebc67a39f1f151407ef230f0ce2883572f5d8985c80" +checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99" dependencies = [ "proc-macro2", "quote", @@ -430,9 +423,9 @@ dependencies = [ [[package]] name = "unicode-ident" -version = "1.0.14" +version = "1.0.24" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "adb9e6ca4f869e1180728b7950e35922a7fc6397f7b641499e8f3ef06e50dc83" +checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" [[package]] name = "winapi" @@ -452,11 +445,11 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" [[package]] name = "winapi-util" -version = "0.1.9" +version = "0.1.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb" +checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22" dependencies = [ - "windows-sys 0.59.0", + "windows-sys", ] [[package]] @@ -466,83 +459,22 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" [[package]] -name = "windows-sys" -version = "0.52.0" +name = "windows-link" +version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" -dependencies = [ - "windows-targets", -] +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" [[package]] name = "windows-sys" -version = "0.59.0" +version = "0.61.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" dependencies = [ - "windows-targets", + "windows-link", ] [[package]] -name = "windows-targets" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" -dependencies = [ - "windows_aarch64_gnullvm", - "windows_aarch64_msvc", - "windows_i686_gnu", - "windows_i686_gnullvm", - "windows_i686_msvc", - "windows_x86_64_gnu", - "windows_x86_64_gnullvm", - "windows_x86_64_msvc", -] - -[[package]] -name = "windows_aarch64_gnullvm" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" - -[[package]] -name = "windows_aarch64_msvc" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" - -[[package]] -name = "windows_i686_gnu" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" - -[[package]] -name = "windows_i686_gnullvm" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" - -[[package]] -name = "windows_i686_msvc" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" - -[[package]] -name = "windows_x86_64_gnu" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" - -[[package]] -name = "windows_x86_64_gnullvm" -version = "0.52.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" - -[[package]] -name = "windows_x86_64_msvc" -version = "0.52.6" +name = "zmij" +version = "1.0.21" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" +checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa" diff --git a/Cargo.toml b/Cargo.toml index 93c91b48..4a75bca5 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,4 +8,9 @@ resolver = "2" [workspace.package] edition = "2021" -rust-version = "1.64.0" +rust-version = "1.84.0" + +[workspace.dependencies] +libc = "0.2.0" +hex = "0.4.3" +symcrypt-sys = { path = "symcrypt-sys", version = "0.4.0" } diff --git a/README.md b/README.md index be214f7e..cfb572a4 100644 --- a/README.md +++ b/README.md @@ -1,15 +1,14 @@ -# SymCrypt on Rust - -## Introduction - -Within this repository, there are 2 crates: - -1. **symcrypt-sys**: Modified Rust/C FFI bindings over SymCrypt. -2. **symcrypt**: Provides friendly Rust wrappers over `symcrypt-sys`. - -Additionally, the repository includes **`symcrypt-bindgen`**, a folder that contains tooling to generate Rust/C FFI bindings used by **symcrypt-sys**. - -The purpose of these crates is to bring FIPS-compliant cryptography to the Rust Ecosystem. - -## Contribute -We love to receive comments and suggestions. Unfortunately we cannot accept external code contributions except in specific circumstances from vetted partners with whom we have a pre-arranged agreement. If you are a developer of `symcrypt` please see DEVELOPER.md \ No newline at end of file +# SymCrypt on Rust + +Within this repository, there are 2 crates: + +1. **symcrypt-sys**: Rust/C FFI bindings for [SymCrypt](https://github.com/microsoft/SymCrypt). +2. **symcrypt**: Friendly and idiomatic Rust wrappers over `symcrypt-sys`. + +Additionally, the repository includes **`symcrypt-bindgen`**, tooling to generate the FFI bindings used by `symcrypt-sys`. + +The purpose of these crates is to bring FIPS-compliant cryptography to the Rust ecosystem. + +## Contributing + +We welcome comments, suggestions, and contributions from vetted partners. See [`CONTRIBUTING.md`](CONTRIBUTING.md) for the branch model, PR process, and developer workflows. diff --git a/SUPPORT.md b/SUPPORT.md deleted file mode 100644 index 291d4d43..00000000 --- a/SUPPORT.md +++ /dev/null @@ -1,25 +0,0 @@ -# TODO: The maintainer of this repo has not yet edited this file - -**REPO OWNER**: Do you want Customer Service & Support (CSS) support for this product/project? - -- **No CSS support:** Fill out this template with information about how to file issues and get help. -- **Yes CSS support:** Fill out an intake form at [aka.ms/onboardsupport](https://aka.ms/onboardsupport). CSS will work with/help you to determine next steps. -- **Not sure?** Fill out an intake as though the answer were "Yes". CSS will help you decide. - -*Then remove this first heading from this SUPPORT.MD file before publishing your repo.* - -# Support - -## How to file issues and get help - -This project uses GitHub Issues to track bugs and feature requests. Please search the existing -issues before filing new issues to avoid duplicates. For new issues, file your bug or -feature request as a new Issue. - -For help and questions about using this project, please **REPO MAINTAINER: INSERT INSTRUCTIONS HERE -FOR HOW TO ENGAGE REPO OWNERS OR COMMUNITY FOR HELP. COULD BE A STACK OVERFLOW TAG OR OTHER -CHANNEL. WHERE WILL YOU HELP PEOPLE?**. - -## Microsoft Support Policy - -Support for this **PROJECT or PRODUCT** is limited to the resources listed above. diff --git a/rust-symcrypt/Cargo.toml b/rust-symcrypt/Cargo.toml index cd2e5d79..6825283d 100644 --- a/rust-symcrypt/Cargo.toml +++ b/rust-symcrypt/Cargo.toml @@ -1,30 +1,26 @@ -[package] -name = "symcrypt" -authors = ["nnmkhang"] -version = "0.5.1" -license = "MIT OR Apache-2.0" -description = "Friendly and Idiomatic Wrappers for SymCrypt" -edition.workspace = true -rust-version.workspace = true -homepage = "https://github.com/microsoft/SymCrypt" -repository = "https://github.com/microsoft/rust-symcrypt" -readme = "README.md" - -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html - -[dependencies] -# uses '../symcrypt-sys' when compiled locally, and uses -# crates.io versioning when published -symcrypt-sys = {path = "../symcrypt-sys", version = "0.4.0"} -libc = "0.2.0" -lazy_static = "1.4.0" - -[features] -default = [] -md5 = [] -sha1 = [] -pkcs1-encrypt-decrypt = [] -dynamic = ["symcrypt-sys/dynamic"] - -[dev-dependencies] -hex = "0.4.3" +[package] +name = "symcrypt" +authors = ["Microsoft"] +version = "0.6.0" +license = "MIT OR Apache-2.0" +description = "Friendly and Idiomatic Wrappers for SymCrypt" +edition.workspace = true +rust-version.workspace = true +homepage = "https://github.com/microsoft/SymCrypt" +repository = "https://github.com/microsoft/rust-symcrypt" +readme = "README.md" +categories = ["cryptography", "api-bindings"] +keywords = ["symcrypt", "crypto", "fips", "encryption", "hashing"] + +[dependencies] +symcrypt-sys = { workspace = true } +libc = { workspace = true } + +[features] +default = [] +md5 = [] +sha1 = [] +pkcs1-encrypt-decrypt = [] + +[dev-dependencies] +hex = { workspace = true } diff --git a/rust-symcrypt/DEVELOPER.md b/rust-symcrypt/DEVELOPER.md deleted file mode 100644 index 00f0e608..00000000 --- a/rust-symcrypt/DEVELOPER.md +++ /dev/null @@ -1,61 +0,0 @@ -# Contributing - -This document is intended to be read by the current developers of `rust-symcrypt`. - -## Structure - -This repo contains `rust-symcrypt` as well as `symcrypt-sys` with the former depending on the latter. We utilize the cargo workspaces feature to organize the cargo environment between both sub crates. - -## How To Generate Bindings -Bindings can be generated 2 ways. -1. With the `generate-all-bindings.ps1` script. - -Using this option will require you to have some build dependencies installed on your machine, more in depth installation instructions are provided in the `generate-all-bindings.ps1` file. - -2. Via Github actions - -Bindings can be created by creating a PR with the label `publish_new_bindings` attached to the PR. More info around labels can be found on the [Github documentation](https://docs.Github.com/en/issues/using-labels-and-milestones-to-track-work/managing-labels). This will create an artifact via Github actions that has the bindings for each supported triple. This Github action will not use the `SymCrypt` that is tied to the PR and instead will pull `SymCrypt` from the Github submodule. To update this please see the `Updating SymCrypt Submodule/SymCrypt Version` section. - -**Note:** As part of the Github actions workflow, the CI will check the generated bindings in the Github actions against the new bindings that you are checking in. - -### Adding New APIs -To add safe wrappers for a new `symcrypt` API you must first generate the required bindings: - -1. Ensure that you have the correct `SymCrypt` submodule. If you are updating the version of `SymCrypt` that `symcrypt-sys`, please see the `Updating SymCrypt Submodule/SymCrypt Version` section. -2. Add the new SymCrypt APIs to `symcrypt-bindgen/src/main`. Ensure to use regex semantics as to not include more that is needed for the API you are going to expose. -3. Generate new bindings with Github actions or the with `generate-all-bindings.ps1` script. -4. Implement wrapper code in the `rust-symcrypt` layer. Ensure that you are properly documenting your changes and updating the API master list on `rust-symcrypt`'s README.md. -5. Once you are complete with your API additions, push and ensure that all CI checks pass. -6. Depending on the type of change you are making you may or may not need to update the cargo version, for more info please see the `Cargo Publishing Guidelines` section. - -### Updating SymCrypt Submodule/SymCrypt Version. -You may have to update the under-lying `SymCrypt` version from time to time, this will require you to update the `SymCrypt` submodule. Some examples of requiring to update the `SymCrypt` version include: -- Adding new bindings for APIs that have been released by `SymCrypt`. -- Applying a security patch provided by `SymCrypt`. -- When you update the static linking version. - -`symcrypt-sys` depends on a `SymCrypt` via a Github submodule. The `SymCrypt` dependency is tied to a specific version of `SymCrypt`, and a specific commit from the `SymCrypt` Github repo. The specific commit that we depend on can be seen on VERSION.md. There is also a CI check that will ensure that your Github submodule matches the version specified in VERSION.md - -If you need to make an update to the `SymCrypt` submodule dependency, you can do so by: -1. First going to the `SymCrypt` submodule in `symcrypt-sys/symcrypt` and checking out the required commit. This should be tied to tagged release of `SymCrypt`. -2. Check in the change via `git add symcrypt-sys/symcrypt`. -3. Update `VERSION.md` in `symcrypt-sys` to include the new commit HASH that you have checked out in `Step 1`. -4. Update `README.md` with the new version of `SymCrypt` that `rust-symcrypt` depends on. -5. Update the `build.yaml` file to ensure that you are downloading the correct SymCrypt dll and .so from the Github artifacts page. -6. Push your changes and ensure that the CI check passes. - - -### Cargo Publishing Guidelines -1. Check out a branch and make your desired changes. ex: `user//bump_version_0.X.X`. -2. Update version number in the `Cargo.toml` of `rust-symcrypt`, or `symcrypt-sys` or both if required. -3. Update the `README.md` with the updated version of `rust-symcrypt` or `symcrypt-sys` or both if required. -4. Adhere to [semver](https://semver.org/) guidelines when bumping version numbers. -5. Test and validate your changes. As a minimum, manual `cargo test --all-features` must be ran on `Windows` and `WSL`. -6. After your change is completed, create a PR against `main`, wait for review and ensure that all Github checks have passed. -7. Once your PR is completed, check out `main` and prep `Cargo` release. -8. It is important to ensure that you have no dangling un-commited changes on your active branch. When publishing to `Crates.io`, these files will be published in as well. -9. You can verify which files will be published via `cargo package --list`. -10. Do a dry publish of the crate via `cargo publish --dry-run`. -11. If that was successful, publish the crate via `cargo publish`. -12. Update the release docs by assigning a new `tag` and detailing the changes associated with the new version. Make sure to highlight breaking changes. -13. If the reason for bumping the version was a critical bug such as a danging pointer, or invalid memory reference, discuss doing a [cargo yank](https://doc.rust-lang.org/cargo/commands/cargo-yank.html) with the rest of the team. diff --git a/rust-symcrypt/INSTALL.md b/rust-symcrypt/INSTALL.md index bc0c47fe..b6b17afa 100644 --- a/rust-symcrypt/INSTALL.md +++ b/rust-symcrypt/INSTALL.md @@ -1,48 +1,69 @@ -# Detailed Build and Install - -This page provides more detailed installation instructions - -## Installation -For ease of use, the recommended usage is to obtain these binaries from the official SymCrypt [Repo](https://github.com/microsoft/SymCrypt/releases/tag/v103.4.2). - -**Note:** If you wish to build your own version please follow the [Build Instructions](https://github.com/microsoft/SymCrypt/blob/main/BUILD.md) that are provided by SymCrypt to install SymCrypt for your target architecture. - -Once SymCrypt is installed on your machine, we must configure your machine so that the SymCrypt crate's build script can easily find `symcrypt.dll` and `symcrypt.lib` which are needed on Windows, or the `libsymcrypt.so*` files which are needed for Linux. - -### Windows Install - -The `symcrypt.lib` can be found in the the following path after SymCrypt has been downloaded and unzipped. - -`C:\Your-Path-To-SymCrypt-Release-Download\dll\` - -The SymCrypt crate needs to link against the SymCrypt import library during build. - -To do so you must set the `SYMCRYPT_LIB_PATH` environment variable. You can do this by using the following command: - -`setx SYMCRYPT_LIB_PATH ""` - -The `symcrypt.dll` can be found in the the following path after SymCrypt has been downloaded and unzipped. - -`C:\Your-Path-To-SymCrypt-Release-Download\dll\` - -During runtime, Windows will handle finding all needed `dll`'s in order to run the intended program, this includes our `symcrypt.dll` file. The places Windows will look are: - -1. The folder from which the application loaded. -2. The system folder. Use the `GetSystemDirectory` function to retrieve the path of this folder. -3. The Windows folder. Use the `GetWindowsDirectory` function to get the path of this folder. -4. The current folder. -5. The directories listed in the PATH environment variable. - -For more info please see: [Dynamic-link library search order](https://learn.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-search-order) - -Here are 2 recommended options to ensure your `symcrypt.dll` is found by Windows during runtime. - -1. Put the `symcrypt.dll` in the same folder as your output `.exe` file. If you are doing development (not release), the common path will be: `C:\your-project\target\debug\`. -2. Permanently add the `symcrypt.dll` path into your System PATH environment variable. Doing this will ensure that any project that uses the SymCrypt crate will be able to access `symcrypt.lib` - -### Linux Install - -After installing and unzipping SymCrypt on a Linux distro, the required `libsymcrypt.so*` files can be found in the following path: -`~/Your-Path-To-SymCrypt-Release-Download/lib/` - -The symcrypt crate needs to be able to link with these libs during build/run time. In order to mimic the installation path for other libraries, you must place the `libsymcrypt.so*` files into linker load path. The way that this is set will vary between distros. On most distros it set via the environment variable `$LD_LIBRARY_PATH`. +# Detailed Build and Install + +This page provides more detailed installation instructions for linking against `SymCrypt` on Windows and Linux. + +The `symcrypt` crate is a wrapper on top of the `SymCrypt` library, and requires access to the `SymCrypt` library during the build and execution stage. For ease of use, the recommended way to configure your `SymCrypt` library dependancy is to obtain the required binaries from the official [SymCrypt Repo](https://github.com/microsoft/SymCrypt/releases/tag/v103.11.0). + +However, If you wish to build your own version of the underlying `SymCrypt` library please follow the [Build Instructions](https://github.com/microsoft/SymCrypt/blob/main/BUILD.md) that are provided by SymCrypt to install SymCrypt for your target architecture. + +By default, the crate links against SymCrypt dynamically. See [Static Linking](#static-linking) below for the experimental static-link option. + +### Windows Install + +The `symcrypt.lib` can be found in the the following path after `SymCrypt` has been downloaded and unzipped. + +`C:\Your-Path-To-SymCrypt-Release-Download\dll\` + +The SymCrypt crate needs to link against the `SymCrypt` import library during build. + +To do so you must set the `SYMCRYPT_LIB_PATH` environment variable. You can do this by using the following command: + +`setx SYMCRYPT_LIB_PATH ""` +The `symcrypt.dll` can be found in the the following path after SymCrypt has been downloaded and unzipped. +`C:\Your-Path-To-SymCrypt-Release-Download\dll\` +During runtime, Windows will handle finding all needed `dll`'s in order to run the intended program, this includes our `symcrypt.dll` file. The places Windows will look are: +1. The folder from which the application loaded. +2. The system folder. Use the `GetSystemDirectory` function to retrieve the path of this folder. +3. The Windows folder. Use the `GetWindowsDirectory` function to get the path of this folder. +4. The current folder. +5. The directories listed in the PATH environment variable. +For more info please see: [Dynamic-link library search order](https://learn.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-search-order) +Here are 2 recommended options to ensure your `symcrypt.dll` is found by Windows during runtime. +1. Put the `symcrypt.dll` in the same folder as your output `.exe` file. If you are doing development (not release), the common path will be: `C:\your-project\target\debug\`. +2. Permanently add the `symcrypt.dll` path into your System PATH environment variable. Doing this will ensure that any project that uses the SymCrypt crate will be able to access `symcrypt.lib` + +**NOTE:** By setting the `SYMCRYPT_LIB_PATH` via `setx SYMCRYPT_LIB_PATH ""`; `symcrypt.dll` will already be on the `PATH` and you will not have to do any additional configuration for your program. + +### Linux Install + +Though the artifacts on the [SymCrypt Repo](https://github.com/microsoft/SymCrypt/releases/tag/v103.11.0). Have been built with `Ubuntu` in mind, the `SymCrypt` library has been built with very few standard library dependencies and should work on most Linux distributions. + +After installing and unzipping SymCrypt on a Linux distro, the required `libsymcrypt.so*` files can be found in the following path: +`~/Your-Path-To-SymCrypt-Release-Download/lib/` + +The `symcrypt` crate needs to be able to link with these libs during build/run time. In order to mimic the installation path for other libraries, you must place the `libsymcrypt.so*` files into linker load path. The way that this is set will vary between distros. On most distros it set via the environment variable `$LD_LIBRARY_PATH`. + +Alternatively, you can point the build at an arbitrary directory by setting `SYMCRYPT_LIB_PATH` to the folder containing `libsymcrypt.so*`. This adds that folder to the linker search path at build time but does not affect runtime library resolution — you still need the loader to find the `.so` at run time (e.g. via `LD_LIBRARY_PATH`, `rpath`, or `ldconfig`). + +**Note:** While the `symcrypt` crate has only been tested on `Ubuntu`, working with other distros should be similar. The goal is to place the `libsymcrypt.so*` files in a location where the your Linux distro can find the required libs at build/run time. The path may be different depending on your flavour of Linux, and architecture. + +--- + +## Target-Specific Environment Variables + +All `SYMCRYPT_*` environment variables consumed by the build script (`SYMCRYPT_LIB_PATH`, `SYMCRYPT_STATIC`) also accept a target-prefixed form, which takes precedence when set. The prefix is the current Rust target triple, uppercased with `-` replaced by `_`. + +Examples: +- `X86_64_UNKNOWN_LINUX_GNU_SYMCRYPT_LIB_PATH` +- `AARCH64_UNKNOWN_LINUX_GNU_SYMCRYPT_LIB_PATH` +- `X86_64_PC_WINDOWS_MSVC_SYMCRYPT_LIB_PATH` + +This is useful when cross-compiling or when a single host needs different values for different targets. + +--- + +## Static Linking + +> **Experimental.** Static linking is a work-in-progress and not recommended for production use. The interface may change. + +Static linking can be enabled by setting the environment veriable `SYMCRYPT_STATIC` to any non-zero value (e.g. `1`). When enabled, the build script will attempt to statically link SymCrypt into the final binary, instead of creating a dynamic link directive. Set `SYMCRYPT_LIB_PATH` to the directory containing the static `symcrypt` library. As SymCrypt's build system does not output a single static libsymcrypt library by default, acquiring such an object is left as an exercise to the reader. diff --git a/rust-symcrypt/README.md b/rust-symcrypt/README.md index 3468c3bd..7e34c05d 100644 --- a/rust-symcrypt/README.md +++ b/rust-symcrypt/README.md @@ -1,130 +1,131 @@ -# SymCrypt Rust Wrapper - -This crate provides friendly and idiomatic Rust wrappers over [SymCrypt](https://github.com/microsoft/SymCrypt), an open-source cryptographic library. - -This crate has a dependency on `symcrypt-sys`, which utilizes `bindgen` to create Rust/C FFI bindings. - -**`symcrypt` version `0.5.1` is based off of `SymCrypt v103.4.2`.**. You must use a version that is greater than or equal to `SymCrypt v103.4.2`. - -To view a detailed list of changes please see the [releases page](https://github.com/microsoft/rust-symcrypt/releases/). - - -### Supported Configurations - -| Operating Environment | Architecture | Dynamic Linking | -| --------------------- | ----------------- | ----------- | -| Windows user mode | AMD64, ARM64 | ✅ | -| Ubuntu | AMD64, ARM64 | ✅ | -| Azure Linux 3 | AMD64, ARM64 | ✅ | - -## Supported APIs - -Hashing: -- Md5 ( stateful/stateless ) -- Sha1 ( stateful/stateless ) -- Sha256 ( stateful/stateless ) -- Sha384 ( stateful/stateless ) -- Sha512 ( stateful/stateless ) -- Sha3_256 ( stateful/stateless ) -- Sha3_384 ( stateful/stateless ) -- Sha3_512 ( stateful/stateless ) - -HMAC: -- HmacMd5 ( stateful/stateless ) -- HmacSha1 ( stateful/stateless ) -- HmacSha256 ( stateful/stateless ) -- HmacSha384 ( stateful/stateless ) -- HmacSha512 ( stateful/stateless ) - -HKDF: -- HmacMd5 -- HmacSha1 -- HmacSha256 -- HmacSha384 -- HmacSha512 - -Encryption: -- AES-GCM Encrypt/Decrypt -- ChaCha20-Poly1305 Encrypt/Decrypt -- AES-CBC Encrypt/Decrypt - -ECC: -- ECDH Secret Agreement ( NistP256, NistP384, NistP521, Curve25519) -- ECDSA Sign / Verify ( NistP256, NistP384, NistP521 ) - -RSA: -- PKCS1 ( Sign, Verify, Encrypt, Decrypt ) -- PSS ( Sign, Verify ) -- OAEP ( Encrypt, Decrypt ) - -**Note**: `Md5` and `Sha1`, and `PKCS1 Encrypt/Decrypt` are considered weak crypto, and are only added for interop purposes. -To enable either `Md5` or `Sha1`, or `Pkcs1 Encrypt/Decrypt` pass the `md5` or `sha1` or `pkcs1-encrypt-decrypt` flag into your `Cargo.toml`. - ---- - - -## Quick Start Guide - -`symcrypt` requires the `SymCrypt` library to be present at both build time and run time. - -### Windows: -Download the latest `symcrypt.dll` and `symcrypt.lib` for your corresponding CPU architecture from the [SymCrypt Releases Page](https://github.com/microsoft/SymCrypt/releases) and place them somewhere accessible on your machine. - -Set the required `SYMCRYPT_LIB_PATH` environment variable. You can do this by using the following command: - -`setx SYMCRYPT_LIB_PATH ""` - -You will need to restart `terminal` / `cmd` after setting the environment variable. - -For more information please see the `INSTALL.md` file on the [`rust-symcrypt`](https://github.com/microsoft/rust-symcrypt/tree/main/rust-symcrypt) page. - -### Linux: - -#### Azure Linux 3: -SymCrypt is pre-installed on Azure Linux 3 machines. Please ensure that you have the most up to date version of SymCrypt by updating via `tdnf`. - - -#### Other distros: - -For Ubuntu, you can install SymCrypt via package manager by connecting to PMC. - -1. [Connect to PMC](https://learn.microsoft.com/en-us/linux/packages) -2. `sudo apt-get install symcrypt` - -Alternatively, you can manually install the lib files: - -Download the latest `libsymcrypt.so*` files for your corresponding CPU architecture from the [SymCrypt Releases Page](https://github.com/microsoft/SymCrypt/releases) and place them in your machines `$LD_LIBRARY_PATH`. - -For more information please see the `INSTALL.md` file on the [`rust-symcrypt`](https://github.com/microsoft/rust-symcrypt/tree/main/rust-symcrypt) page - -**Note:** This path may be different depending on your flavour of Linux, and architecture. The goal is to place the `libsymcrypt.so*` files in a location where the your Linux distro can find the required libs at build/run time. - ---- - -## Usage -There are unit tests attached to each file that show how to use each function. Included is some sample code to do a stateless Sha256 hash. - -**Note:** This code snippet also uses the [hex](https://crates.io/crates/hex) crate. - -### Instructions: - -add symcrypt to your `Cargo.toml` file. - -```cargo -[dependencies] -symcrypt = "0.5.1" -hex = "0.4.3" -``` - -include symcrypt in your code - -```rust -use symcrypt::hash::sha256; -use hex; - -let data = hex::decode("641ec2cf711e").unwrap(); -let expected: &str = "cfdbd6c9acf9842ce04e8e6a0421838f858559cf22d2ea8a38bd07d5e4692233"; - -let result = sha256(&data); -assert_eq!(hex::encode(result), expected); -``` +# SymCrypt Rust Wrapper +This crate provides friendly and idiomatic Rust wrappers over [SymCrypt](https://github.com/microsoft/SymCrypt), an open-source cryptographic library. + +This crate has a dependency on `symcrypt-sys`, which utilizes `bindgen` to create Rust/C FFI bindings. + +**`symcrypt` version `0.6.0` is based off of `SymCrypt v103.11.0`.** You must use a version that is greater than or equal to `SymCrypt v103.11.0`. + +To view a detailed list of changes please see the [releases page](https://github.com/microsoft/rust-symcrypt/releases/). + + +### Supported Configurations +| Operating Environment | Architecture | +| --------------------- | ------------ | +| Windows user mode | AMD64, ARM64 | +| Ubuntu | AMD64, ARM64 | +| Azure Linux 3 | AMD64, ARM64 | + +--- + +## Supported APIs + +Hashing: +- Md5 ( stateful/stateless ) +- Sha1 ( stateful/stateless ) +- Sha256 ( stateful/stateless ) +- Sha384 ( stateful/stateless ) +- Sha512 ( stateful/stateless ) +- Sha3_256 ( stateful/stateless ) +- Sha3_384 ( stateful/stateless ) +- Sha3_512 ( stateful/stateless ) + +HMAC: +- HmacMd5 ( stateful/stateless ) +- HmacSha1 ( stateful/stateless ) +- HmacSha256 ( stateful/stateless ) +- HmacSha384 ( stateful/stateless ) +- HmacSha512 ( stateful/stateless ) + +HKDF: +- HmacMd5 +- HmacSha1 +- HmacSha256 +- HmacSha384 +- HmacSha512 + +SP800-108 Counter Mode KDF: +- HmacSha1 +- HmacSha256 +- HmacSha384 +- HmacSha512 + +Encryption: +- AES-GCM Encrypt/Decrypt +- ChaCha20-Poly1305 Encrypt/Decrypt +- AES-CBC Encrypt/Decrypt +- XTS-AES Encrypt/Decrypt (128, 192, 256-bit keys) + +Key Wrap (NIST SP 800-38F): +- AES-KW (RFC 3394) — Wraps plaintext that is a multiple of 8 bytes. Output length is the length of the plaintext + 8 bytes. +- AES-KWP (RFC 5649) — wraps any non-zero-length plaintext + +ECC: +- ECDH Secret Agreement ( NistP256, NistP384, NistP521, Curve25519) +- ECDSA Sign / Verify ( NistP256, NistP384, NistP521 ) + +RSA: +- PKCS1 ( Sign, Verify, Encrypt, Decrypt ) +- PSS ( Sign, Verify ) +- OAEP ( Encrypt, Decrypt ) + +**Note**: `Md5` and `Sha1`, and `PKCS1 Encrypt/Decrypt` are considered weak crypto, and are only added for interop purposes. +To enable either `Md5` or `Sha1`, or `Pkcs1 Encrypt/Decrypt` pass the `md5` or `sha1` or `pkcs1-encrypt-decrypt` flag into your `Cargo.toml`. + +--- + +## Quick Start Guide + +The `symcrypt` crate links against the `SymCrypt` library dynamically by default. This requires the `SymCrypt` library to be available on your system at build and runtime. Experimental static linking is also available, see [`INSTALL.md`](./INSTALL.md#static-linking) for details. + +### Windows: +Download the latest `symcrypt.dll` and `symcrypt.lib` for your corresponding CPU architecture from the [SymCrypt Releases Page](https://github.com/microsoft/SymCrypt/releases) and place them somewhere accessible on your machine. +Set the required `SYMCRYPT_LIB_PATH` environment variable: +`setx SYMCRYPT_LIB_PATH ""` + +You will need to restart `terminal` / `cmd` after setting the environment variable. + +For more information please see `INSTALL.md`. + +### Linux: + +#### Azure Linux 3: +SymCrypt is pre-installed on Azure Linux 3 machines. Please ensure that you have the most up to date version of SymCrypt by updating via `tdnf`. + +#### Other distros: + +For Ubuntu, you can install SymCrypt via package manager by connecting to PMC ( Example shown for Ubuntu `24.04` ): + +1. `curl -sSL -O https://packages.microsoft.com/config/ubuntu/24.04/packages-microsoft-prod.deb` +2. `sudo dpkg -i packages-microsoft-prod.deb` +3. `sudo apt-get update` +4. `sudo apt-get install symcrypt` + +For more info on connecting to PMC please see: [Connecting to PMC](https://learn.microsoft.com/en-us/linux/packages) + +If you want to try connecting with another flavour of Linux, or for more info please see `INSTALL.md` + +--- + +## Usage +There are unit tests attached to each file that show how to use each function. Included is some sample code to do a stateless Sha256 hash. +**Note:** This code snippet also uses the [hex](https://crates.io/crates/hex) crate. + +### Instructions: + +Add symcrypt to your `Cargo.toml` file: +```cargo +[dependencies] +symcrypt = "0.6.0" +hex = "0.4.3" +``` + +Include symcrypt in your code: + +```rust +use symcrypt::hash::sha256; +use hex; +let data = hex::decode("641ec2cf711e").unwrap(); +let expected: &str = "cfdbd6c9acf9842ce04e8e6a0421838f858559cf22d2ea8a38bd07d5e4692233"; +let result = sha256(&data); +assert_eq!(hex::encode(result), expected); +``` diff --git a/rust-symcrypt/src/cipher/aes_kw.rs b/rust-symcrypt/src/cipher/aes_kw.rs new file mode 100644 index 00000000..7f837089 --- /dev/null +++ b/rust-symcrypt/src/cipher/aes_kw.rs @@ -0,0 +1,449 @@ +//! AES Key Wrap (KW) and AES Key Wrap with Padding (KWP). See symcrypt.h for more info. +//! +//! - **AES-KW**: wraps plaintext whose length is a multiple of 8 bytes and at least 16 +//! bytes. The output is always plaintext length + 8 bytes. +//! - **AES-KWP**: wraps plaintext of any non-zero length. Output is rounded up to the +//! next multiple of 8 bytes plus 8 bytes for the integrity check value. +//! +//! The wrapping key passed to either constructor must be a valid AES key length: 16, 24, or 32 +//! bytes. The wrapping key is independent of which mode is used. +//! +//! AES-KW(P) is significantly slower than other AES modes, use of this cipher is not recommended. +//! +//! The plaintext recovered by [`AesKwKey::decrypt`] and [`AesKwpKey::decrypt`] is returned in a +//! plain [`Vec`]. The recovered bytes are sensitive key material, and it is the caller's +//! responsibility to wipe the buffer (for example with [`zeroize`](https://crates.io/crates/zeroize)) +//! when it is no longer needed; simply dropping the `Vec` does **not** clear its memory. +//! +//! # Examples +//! +//! ## AES-KW +//! ```rust +//! use symcrypt::cipher::aes_kw::AesKwKey; +//! +//! let wrapping_key = hex::decode("ABF3A659F6D4AF5EAB250BF05A0B623C").unwrap(); +//! let plaintext = hex::decode("6B95ECAA3C712FACF175DD06FF88704A").unwrap(); +//! +//! let kw = AesKwKey::new(&wrapping_key).unwrap(); +//! let ciphertext = kw.encrypt(&plaintext).unwrap(); +//! let recovered = kw.decrypt(&ciphertext).unwrap(); +//! assert_eq!(recovered, plaintext); +//! ``` +//! +//! ## AES-KWP +//! ```rust +//! use symcrypt::cipher::aes_kw::AesKwpKey; +//! +//! let wrapping_key = hex::decode("A19C08545013B997639E7D4C227324AC").unwrap(); +//! let plaintext = hex::decode("25").unwrap(); // arbitrary length, even 1 byte +//! +//! let kwp = AesKwpKey::new(&wrapping_key).unwrap(); +//! let ciphertext = kwp.encrypt(&plaintext).unwrap(); +//! let recovered = kwp.decrypt(&ciphertext).unwrap(); +//! assert_eq!(recovered, plaintext); +//! ``` + +use crate::cipher::{expand_aes_key, AesInnerKey}; +use crate::errors::SymCryptError; +use std::pin::Pin; +use symcrypt_sys; + +const KW_SEMIBLOCK: usize = 8; + +/// Computes the AES-KW encrypt output buffer length: `plaintext_len + KW_SEMIBLOCK`. +/// Returns `InvalidArgument` if the addition would overflow `usize`. +#[inline] +fn kw_encrypt_buffer_len(plaintext_len: usize) -> Result { + plaintext_len + .checked_add(KW_SEMIBLOCK) + .ok_or(SymCryptError::InvalidArgument) +} + +/// Computes the AES-KWP encrypt output buffer length: +/// `plaintext_len.next_multiple_of(KW_SEMIBLOCK) + KW_SEMIBLOCK`. +/// Returns `InvalidArgument` if either operation would overflow `usize`. +#[inline] +fn kwp_encrypt_buffer_len(plaintext_len: usize) -> Result { + let padded = plaintext_len + .checked_next_multiple_of(KW_SEMIBLOCK) + .ok_or(SymCryptError::InvalidArgument)?; + padded + .checked_add(KW_SEMIBLOCK) + .ok_or(SymCryptError::InvalidArgument) +} + +/// [`AesKwKey`] wraps an expanded AES key for use with AES-KW. +pub struct AesKwKey { + expanded_key: Pin>, +} + +/// [`AesKwpKey`] wraps an expanded AES key for use with AES-KWP. +pub struct AesKwpKey { + expanded_key: Pin>, +} + +impl AesKwKey { + /// `new()` returns an [`AesKwKey`] or a [`SymCryptError`] if the key is the wrong size. + /// Accepted key sizes are 16, 24, or 32 bytes (AES-128/192/256). + pub fn new(key: &[u8]) -> Result { + Ok(AesKwKey { + expanded_key: expand_aes_key(key)?, + }) + } + + /// `encrypt()` wraps `plaintext` using AES-KW and returns the ciphertext. + /// + /// `plaintext.len()` must be a multiple of 8 and at least 16. The returned `Vec` has length + /// `plaintext.len() + 8`. + pub fn encrypt(&self, plaintext: &[u8]) -> Result, SymCryptError> { + // Use checked_add so inputs cannot wrap and produce an undersized output buffer. + let ct_len = kw_encrypt_buffer_len(plaintext.len())?; + let mut ciphertext = vec![0u8; ct_len]; + let mut written: symcrypt_sys::SIZE_T = 0; + unsafe { + // SAFETY: FFI call. + match symcrypt_sys::SymCryptAesKwEncrypt( + self.expanded_key.get_inner(), + plaintext.as_ptr(), + plaintext.len() as symcrypt_sys::SIZE_T, + ciphertext.as_mut_ptr(), + ciphertext.len() as symcrypt_sys::SIZE_T, + &mut written, + ) { + symcrypt_sys::SYMCRYPT_ERROR_SYMCRYPT_NO_ERROR => { + ciphertext.truncate(written as usize); + Ok(ciphertext) + } + err => Err(err.into()), + } + } + } + + /// `decrypt()` unwraps `ciphertext` using AES-KW and returns the recovered plaintext. + /// + /// `ciphertext.len()` must be a multiple of 8 and at least 24. Returns + /// [`SymCryptError::AuthenticationFailure`] if the integrity check fails. + /// + /// The returned `Vec` holds sensitive key material. Dropping it does **not** wipe the + /// underlying memory; callers should explicitly zero the buffer (e.g. with the + /// [`zeroize`](https://crates.io/crates/zeroize) crate) once it is no longer needed. + pub fn decrypt(&self, ciphertext: &[u8]) -> Result, SymCryptError> { + // SymCrypt's SymCryptAesKwDecrypt writes exactly `ciphertext.len() - 8` bytes on + // success and requires `cbDst >= cbSrc - 8`. + let mut plaintext = vec![0u8; ciphertext.len().saturating_sub(KW_SEMIBLOCK)]; + let mut written: symcrypt_sys::SIZE_T = 0; + unsafe { + // SAFETY: FFI call. + match symcrypt_sys::SymCryptAesKwDecrypt( + self.expanded_key.get_inner(), + ciphertext.as_ptr(), + ciphertext.len() as symcrypt_sys::SIZE_T, + plaintext.as_mut_ptr(), + plaintext.len() as symcrypt_sys::SIZE_T, + &mut written, + ) { + symcrypt_sys::SYMCRYPT_ERROR_SYMCRYPT_NO_ERROR => { + plaintext.truncate(written as usize); + Ok(plaintext) + } + err => Err(err.into()), + } + } + } +} + +impl AesKwpKey { + /// `new()` returns an [`AesKwpKey`] or a [`SymCryptError`] if the key is the wrong size. + /// Accepted key sizes are 16, 24, or 32 bytes (AES-128/192/256). + pub fn new(key: &[u8]) -> Result { + Ok(AesKwpKey { + expanded_key: expand_aes_key(key)?, + }) + } + + /// `encrypt()` wraps `plaintext` (any non-zero length) using AES-KWP and returns the ciphertext. + /// + /// The output length is `plaintext.len().next_multiple_of(8) + 8`. + pub fn encrypt(&self, plaintext: &[u8]) -> Result, SymCryptError> { + // Use checked_add so inputs cannot wrap and produce an undersized output buffer. + let ct_len = kwp_encrypt_buffer_len(plaintext.len())?; + let mut ciphertext = vec![0u8; ct_len]; + let mut written: symcrypt_sys::SIZE_T = 0; + unsafe { + // SAFETY: FFI call. + match symcrypt_sys::SymCryptAesKwpEncrypt( + self.expanded_key.get_inner(), + plaintext.as_ptr(), + plaintext.len() as symcrypt_sys::SIZE_T, + ciphertext.as_mut_ptr(), + ciphertext.len() as symcrypt_sys::SIZE_T, + &mut written, + ) { + symcrypt_sys::SYMCRYPT_ERROR_SYMCRYPT_NO_ERROR => { + ciphertext.truncate(written as usize); + Ok(ciphertext) + } + err => Err(err.into()), + } + } + } + + /// `decrypt()` unwraps `ciphertext` using AES-KWP and returns the recovered plaintext. + /// + /// `ciphertext.len()` must be a multiple of 8 and at least 16. Returns + /// [`SymCryptError::AuthenticationFailure`] if the integrity check or padding check fails. + /// + /// The returned `Vec` holds sensitive key material. Dropping it does **not** wipe the + /// underlying memory; callers should explicitly zero the buffer (e.g. with the + /// [`zeroize`](https://crates.io/crates/zeroize) crate) once it is no longer needed. + pub fn decrypt(&self, ciphertext: &[u8]) -> Result, SymCryptError> { + // SymCrypt's SymCryptAesKwpDecrypt requires `cbDst >= cbSrc - 15`, and the actual + // plaintext length is always `<= cbSrc - 8`. Allocate that upper bound; the buffer + // is truncated to the real plaintext length on success. + let mut plaintext = vec![0u8; ciphertext.len().saturating_sub(KW_SEMIBLOCK)]; + let mut written: symcrypt_sys::SIZE_T = 0; + unsafe { + // SAFETY: FFI call. + match symcrypt_sys::SymCryptAesKwpDecrypt( + self.expanded_key.get_inner(), + ciphertext.as_ptr(), + ciphertext.len() as symcrypt_sys::SIZE_T, + plaintext.as_mut_ptr(), + plaintext.len() as symcrypt_sys::SIZE_T, + &mut written, + ) { + symcrypt_sys::SYMCRYPT_ERROR_SYMCRYPT_NO_ERROR => { + plaintext.truncate(written as usize); + Ok(plaintext) + } + err => Err(err.into()), + } + } + } +} + +// AesInnerKey carries the SymCrypt opaque state which is immutable after key expansion. +unsafe impl Send for AesKwKey {} +unsafe impl Sync for AesKwKey {} +unsafe impl Send for AesKwpKey {} +unsafe impl Sync for AesKwpKey {} + +#[cfg(test)] +mod test { + use super::*; + + const KW_KEY_HEX: &str = "ABF3A659F6D4AF5EAB250BF05A0B623C"; + const KW_PT_HEX: &str = "6B95ECAA3C712FACF175DD06FF88704A"; + const KW_CT_HEX: &str = "7AD5368CC43D2EF691B666CE24C4B52DCEB1442A53EA1A16"; + + const KWP_KEY_HEX: &str = "A19C08545013B997639E7D4C227324AC"; + const KWP_PT_HEX: &str = "25"; + const KWP_CT_HEX: &str = "E641A9489F50E6DBF21B29FA995AFCA4"; + + // -------- AES-KW -------- + + #[test] + fn test_aes_kw_kat_encrypt() { + let key = hex::decode(KW_KEY_HEX).unwrap(); + let pt = hex::decode(KW_PT_HEX).unwrap(); + let expected_ct = hex::decode(KW_CT_HEX).unwrap(); + let kw = AesKwKey::new(&key).unwrap(); + let ct = kw.encrypt(&pt).unwrap(); + assert_eq!(ct, expected_ct); + } + + #[test] + fn test_aes_kw_kat_decrypt() { + let key = hex::decode(KW_KEY_HEX).unwrap(); + let ct = hex::decode(KW_CT_HEX).unwrap(); + let expected_pt = hex::decode(KW_PT_HEX).unwrap(); + let kw = AesKwKey::new(&key).unwrap(); + let pt = kw.decrypt(&ct).unwrap(); + assert_eq!(pt, expected_pt); + } + + #[test] + fn test_aes_kw_round_trip_aes_256() { + let key = vec![0xA5u8; 32]; + let pt = vec![0x11u8; 32]; + let kw = AesKwKey::new(&key).unwrap(); + let ct = kw.encrypt(&pt).unwrap(); + assert_eq!(ct.len(), pt.len() + 8); + let recovered = kw.decrypt(&ct).unwrap(); + assert_eq!(recovered, pt); + } + + #[test] + fn test_aes_kw_wrong_key_size() { + let key = vec![0u8; 17]; + match AesKwKey::new(&key) { + Ok(_) => panic!("expected WrongKeySize"), + Err(err) => assert_eq!(err, SymCryptError::WrongKeySize), + } + } + + #[test] + fn test_aes_kw_plaintext_too_short() { + let key = vec![0u8; 16]; + let pt = vec![0u8; 8]; // KW requires >=16 + let kw = AesKwKey::new(&key).unwrap(); + assert_eq!(kw.encrypt(&pt).unwrap_err(), SymCryptError::InvalidArgument); + } + + #[test] + fn test_aes_kw_plaintext_not_multiple_of_8() { + let key = vec![0u8; 16]; + let pt = vec![0u8; 17]; + let kw = AesKwKey::new(&key).unwrap(); + assert_eq!(kw.encrypt(&pt).unwrap_err(), SymCryptError::InvalidArgument); + } + + #[test] + fn test_aes_kw_decrypt_corrupted_fails() { + let key = hex::decode(KW_KEY_HEX).unwrap(); + let mut ct = hex::decode(KW_CT_HEX).unwrap(); + ct[0] ^= 0xFF; // corrupt the integrity check + let kw = AesKwKey::new(&key).unwrap(); + assert_eq!( + kw.decrypt(&ct).unwrap_err(), + SymCryptError::AuthenticationFailure + ); + } + + // -------- AES-KWP -------- + + #[test] + fn test_aes_kwp_kat_encrypt_one_byte() { + let key = hex::decode(KWP_KEY_HEX).unwrap(); + let pt = hex::decode(KWP_PT_HEX).unwrap(); + let expected_ct = hex::decode(KWP_CT_HEX).unwrap(); + let kwp = AesKwpKey::new(&key).unwrap(); + let ct = kwp.encrypt(&pt).unwrap(); + assert_eq!(ct, expected_ct); + assert_eq!(ct.len(), 16); + } + + #[test] + fn test_aes_kwp_kat_decrypt_one_byte() { + let key = hex::decode(KWP_KEY_HEX).unwrap(); + let ct = hex::decode(KWP_CT_HEX).unwrap(); + let expected_pt = hex::decode(KWP_PT_HEX).unwrap(); + let kwp = AesKwpKey::new(&key).unwrap(); + let pt = kwp.decrypt(&ct).unwrap(); + assert_eq!(pt, expected_pt); + } + + #[test] + fn test_aes_kwp_round_trip_arbitrary_lengths() { + let key = vec![0x5Au8; 32]; + let kwp = AesKwpKey::new(&key).unwrap(); + for len in [1usize, 7, 8, 9, 15, 16, 17, 31, 33, 100] { + let pt: Vec = (0..len).map(|i| i as u8).collect(); + let ct = kwp.encrypt(&pt).unwrap(); + // Output is the next multiple-of-8 of plaintext length, plus 8 bytes for the IV. + let expected_ct_len = pt.len().next_multiple_of(8) + 8; + assert_eq!(ct.len(), expected_ct_len, "len={}", len); + let recovered = kwp.decrypt(&ct).unwrap(); + assert_eq!(recovered, pt, "round-trip mismatch at len={}", len); + } + } + + #[test] + fn test_aes_kwp_empty_plaintext_fails() { + let key = vec![0u8; 16]; + let kwp = AesKwpKey::new(&key).unwrap(); + assert_eq!( + kwp.encrypt(&[]).unwrap_err(), + SymCryptError::InvalidArgument + ); + } + + #[test] + fn test_aes_kwp_decrypt_corrupted_fails() { + let key = hex::decode(KWP_KEY_HEX).unwrap(); + let mut ct = hex::decode(KWP_CT_HEX).unwrap(); + ct[0] ^= 0xFF; + let kwp = AesKwpKey::new(&key).unwrap(); + assert_eq!( + kwp.decrypt(&ct).unwrap_err(), + SymCryptError::AuthenticationFailure + ); + } + + // -------- output buffer sizing helpers -------- + + #[test] + fn test_kw_encrypt_buffer_len_basic() { + assert_eq!(kw_encrypt_buffer_len(0).unwrap(), 8); + assert_eq!(kw_encrypt_buffer_len(16).unwrap(), 24); + assert_eq!(kw_encrypt_buffer_len(4096).unwrap(), 4104); + } + + #[test] + fn test_kw_encrypt_buffer_len_overflow() { + // usize::MAX - 7 + 8 wraps; usize::MAX + 8 wraps. + for len in [usize::MAX - 7, usize::MAX - 1, usize::MAX] { + assert_eq!( + kw_encrypt_buffer_len(len).unwrap_err(), + SymCryptError::InvalidArgument, + "len={}", + len + ); + } + } + + #[test] + fn test_kwp_encrypt_buffer_len_basic() { + assert_eq!(kwp_encrypt_buffer_len(1).unwrap(), 16); + assert_eq!(kwp_encrypt_buffer_len(8).unwrap(), 16); + assert_eq!(kwp_encrypt_buffer_len(9).unwrap(), 24); + assert_eq!(kwp_encrypt_buffer_len(100).unwrap(), 112); + } + + #[test] + fn test_kwp_encrypt_buffer_len_overflow() { + // next_multiple_of(8) overflows for any len in (usize::MAX - 7 ..= usize::MAX) that + // isn't already a multiple of 8. + for len in [usize::MAX, usize::MAX - 1, usize::MAX - 7] { + assert_eq!( + kwp_encrypt_buffer_len(len).unwrap_err(), + SymCryptError::InvalidArgument, + "len={}", + len + ); + } + } + + // -------- decrypt output buffer trimming -------- + + #[test] + fn test_aes_kw_decrypt_buffer_len_is_trimmed() { + let key = vec![0xA5u8; 32]; + let pt = vec![0x11u8; 32]; + let kw = AesKwKey::new(&key).unwrap(); + let ct = kw.encrypt(&pt).unwrap(); + let recovered = kw.decrypt(&ct).unwrap(); + // KW always produces exactly cbSrc - 8 bytes of plaintext. + assert_eq!(recovered.len(), ct.len() - KW_SEMIBLOCK); + } + + #[test] + fn test_aes_kwp_decrypt_buffer_len_is_at_most_ct_minus_8() { + let key = vec![0x5Au8; 32]; + let kwp = AesKwpKey::new(&key).unwrap(); + for len in [1usize, 7, 8, 9, 15, 16, 17, 100] { + let pt: Vec = (0..len).map(|i| i as u8).collect(); + let ct = kwp.encrypt(&pt).unwrap(); + let recovered = kwp.decrypt(&ct).unwrap(); + // KWP plaintext is always <= cbSrc - 8. + assert!( + recovered.len() <= ct.len() - KW_SEMIBLOCK, + "len={}: recovered.len() = {}, ct.len() - 8 = {}", + len, + recovered.len(), + ct.len() - KW_SEMIBLOCK + ); + assert_eq!(recovered.len(), pt.len(), "len={}", len); + } + } +} diff --git a/rust-symcrypt/src/cipher/mod.rs b/rust-symcrypt/src/cipher/mod.rs index d10e302b..0214fe4d 100644 --- a/rust-symcrypt/src/cipher/mod.rs +++ b/rust-symcrypt/src/cipher/mod.rs @@ -20,11 +20,16 @@ use crate::errors::SymCryptError; use crate::symcrypt_init; use symcrypt_sys; +use core::ffi::c_void; use std::marker::PhantomPinned; +use std::mem; use std::pin::Pin; +use std::ptr; // export ciphers +pub mod aes_kw; pub mod cbc; +pub mod xts; /// 16 pub const AES_BLOCK_SIZE: u32 = symcrypt_sys::SYMCRYPT_AES_BLOCK_SIZE; @@ -34,7 +39,7 @@ pub const AES_BLOCK_SIZE: u32 = symcrypt_sys::SYMCRYPT_AES_BLOCK_SIZE; pub enum BlockCipherType { AesBlock, } -struct AesInnerKey { +pub(crate) struct AesInnerKey { inner: symcrypt_sys::SYMCRYPT_AES_EXPANDED_KEY, _pinned: PhantomPinned, } @@ -61,6 +66,18 @@ impl AesInnerKey { } } +impl Drop for AesInnerKey { + fn drop(&mut self) { + unsafe { + // SAFETY: FFI calls + symcrypt_sys::SymCryptWipe( + ptr::addr_of_mut!(self.inner) as *mut c_void, + mem::size_of_val(&self.inner) as symcrypt_sys::SIZE_T, + ); + } + } +} + /// `AesExpandedKey` is a struct that represents an expanded AES key. This struct holds no state and is used to encrypt and decrypt data. pub struct AesExpandedKey { // Owned expanded key, this has no state, other calls will take reference to this key. @@ -70,22 +87,9 @@ pub struct AesExpandedKey { impl AesExpandedKey { /// `new()` returns an `AesExpandedKey` or a [`SymCryptError`] if the operation fails. pub fn new(key: &[u8]) -> Result { - symcrypt_init(); - let mut expanded_key = AesInnerKey::new(); - - unsafe { - // SAFETY: FFI call - match symcrypt_sys::SymCryptAesExpandKey( - expanded_key.as_mut().get_inner_mut(), - key.as_ptr(), - key.len() as symcrypt_sys::SIZE_T, - ) { - symcrypt_sys::SYMCRYPT_ERROR_SYMCRYPT_NO_ERROR => { - Ok(AesExpandedKey { expanded_key }) - } - err => Err(err.into()), - } - } + Ok(AesExpandedKey { + expanded_key: expand_aes_key(key)?, + }) } pub fn get_block_size() -> u32 { @@ -93,6 +97,24 @@ impl AesExpandedKey { } } +/// Shared key-expansion helper. Used by (e.g. AES-KW, AES-KWP) so that the SymCrypt +/// `SymCryptAesExpandKey` call lives in one place. +pub(crate) fn expand_aes_key(key: &[u8]) -> Result>, SymCryptError> { + symcrypt_init(); + let mut expanded_key = AesInnerKey::new(); + unsafe { + // SAFETY: FFI call. Returns WrongKeySize for non-AES key lengths. + match symcrypt_sys::SymCryptAesExpandKey( + expanded_key.as_mut().get_inner_mut(), + key.as_ptr(), + key.len() as symcrypt_sys::SIZE_T, + ) { + symcrypt_sys::SYMCRYPT_ERROR_SYMCRYPT_NO_ERROR => Ok(expanded_key), + err => Err(err.into()), + } + } +} + // No custom Send / Sync impl. needed for AesInnerKey and AesExpandedKey and BlockCipherType since the // underlying data is a pointer to a SymCrypt struct that is not modified after it is created. unsafe impl Send for AesInnerKey {} diff --git a/rust-symcrypt/src/cipher/xts.rs b/rust-symcrypt/src/cipher/xts.rs new file mode 100644 index 00000000..069cf05a --- /dev/null +++ b/rust-symcrypt/src/cipher/xts.rs @@ -0,0 +1,718 @@ +//! XTS-AES (NIST SP 800-38E) functions. For further documentation please refer to symcrypt.h +//! +//! Supports XTS-AES-128, XTS-AES-192, and XTS-AES-256. The key passed to [`XtsAesKey::new`] +//! must be two equal-length AES keys concatenated (32, 48, or 64 bytes total). Per FIPS the +//! two halves must be unequal. +//! +//! # Examples +//! +//! ## Encrypt in place +//! +//! ```rust +//! use symcrypt::cipher::xts::XtsAesKey; +//! +//! // Set up input. Two AES-256 keys concatenated; per FIPS the halves must be unequal. +//! let key = hex::decode("\ +//! 2718281828459045235360287471352662497757247093699959574966967627\ +//! 3141592653589793238462643383279502884197169399375105820974944592" +//! ).unwrap(); +//! +//! let mut buffer = [0u8; 32]; +//! hex::decode_to_slice( +//! "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", +//! &mut buffer, +//! ).unwrap(); +//! let plaintext = buffer; +//! +//! // Perform encryption in place with data_unit_size = 32 and tweak = 0xff. +//! let xts = XtsAesKey::new(&key).unwrap(); +//! xts.encrypt_in_place(32, 0xff, &mut buffer).unwrap(); +//! +//! ``` +//! +//! ## Decrypt in place +//! ```rust +//! use symcrypt::cipher::xts::XtsAesKey; +//! +//! // Set up input +//! let key = hex::decode("\ +//! 2718281828459045235360287471352662497757247093699959574966967627\ +//! 3141592653589793238462643383279502884197169399375105820974944592" +//! ).unwrap(); +//! let expected_result = "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"; +//! +//! // Produce a ciphertext by encrypting the expected plaintext under the same +//! // (data_unit_size, tweak) so we have something to decrypt. +//! let mut buffer = [0u8; 32]; +//! hex::decode_to_slice(expected_result, &mut buffer).unwrap(); +//! let xts = XtsAesKey::new(&key).unwrap(); +//! xts.encrypt_in_place(32, 0xff, &mut buffer).unwrap(); +//! +//! // Perform the decryption in place +//! xts.decrypt_in_place(32, 0xff, &mut buffer).unwrap(); +//! assert_eq!(hex::encode(buffer), expected_result); +//! ``` + +use crate::errors::SymCryptError; +use crate::symcrypt_init; +use core::ffi::c_void; +use std::marker::PhantomPinned; +use std::mem; +use std::pin::Pin; +use std::ptr; +use symcrypt_sys; + +const XTS_DATA_UNIT_MIN: u64 = 16; +const XTS_DATA_UNIT_MAX: u64 = 1 << 24; + +/// [`XtsAesKey`] holds an expanded XTS-AES key from SymCrypt. +/// +/// Accepts 32-byte (AES-128), 48-byte (AES-192), or 64-byte (AES-256) keys, each consisting +/// of two equal-length AES keys concatenated. The expanded key is `Pin>`'d because +/// SymCrypt requires the underlying state to remain at a fixed address for its lifetime. +pub struct XtsAesKey { + expanded_key: Pin>, +} + +/// Wraps the raw SymCrypt XTS expanded key. +struct XtsAesInnerKey { + inner: symcrypt_sys::SYMCRYPT_XTS_AES_EXPANDED_KEY, + _pinned: PhantomPinned, +} + +impl XtsAesInnerKey { + fn new() -> Pin> { + Box::pin(XtsAesInnerKey { + inner: symcrypt_sys::SYMCRYPT_XTS_AES_EXPANDED_KEY::default(), + _pinned: PhantomPinned, + }) + } + + /// Provides a mutable pointer to the inner SymCrypt state. + /// + /// This is primarily meant to be used while making calls to the underlying SymCrypt APIs. + /// The pointer returned is pinned and cannot be moved + /// This function returns pointer to pinned data, which means callers must not use the pointer to move the data out of its location. + fn get_inner_mut(self: Pin<&mut Self>) -> *mut symcrypt_sys::SYMCRYPT_XTS_AES_EXPANDED_KEY { + // SAFETY: Accessing the inner state of the pinned data + unsafe { &mut self.get_unchecked_mut().inner as *mut _ } + } + + /// Safe method to access the inner state immutably + fn get_inner(&self) -> *const symcrypt_sys::SYMCRYPT_XTS_AES_EXPANDED_KEY { + &self.inner as *const _ + } +} + +impl Drop for XtsAesInnerKey { + fn drop(&mut self) { + unsafe { + // SAFETY: FFI calls + symcrypt_sys::SymCryptWipe( + ptr::addr_of_mut!(self.inner) as *mut c_void, + mem::size_of_val(&self.inner) as symcrypt_sys::SIZE_T, + ); + } + } +} + +impl XtsAesKey { + /// `new()` returns a new [`XtsAesKey`] or a [`SymCryptError`] if the operation fails. + /// + /// `key` must be 32, 48, or 64 bytes (two equal-length AES keys concatenated for + /// XTS-AES-128, XTS-AES-192, or XTS-AES-256 respectively). The two halves must be + /// unequal; if they are equal, [`SymCryptError::FipsFailure`] is returned. + pub fn new(key: &[u8]) -> Result { + symcrypt_init(); + let mut expanded_key = XtsAesInnerKey::new(); + unsafe { + // SAFETY: FFI call. + match symcrypt_sys::SymCryptXtsAesExpandKeyEx( + expanded_key.as_mut().get_inner_mut(), + key.as_ptr(), + key.len() as symcrypt_sys::SIZE_T, + 0, // FIPS mode on. Enforces the key-halves-not-equal check. + ) { + symcrypt_sys::SYMCRYPT_ERROR_SYMCRYPT_NO_ERROR => Ok(XtsAesKey { expanded_key }), + err => Err(err.into()), + } + } + } + + /// `encrypt` encrypts `plaintext` into `ciphertext` using XTS-AES with a 64-bit tweak. + /// + /// `data_unit_size` is the size in bytes of each data unit, typically 512. It must be at least + /// 16 and at most 2^24. `plaintext.len()` must be a multiple of `data_unit_size`. + /// `tweak` is the tweak for the first data unit; it is incremented for each subsequent data + /// unit in `plaintext`. + /// + /// `plaintext` is a `&[u8]` containing the data to be encrypted. `ciphertext` is a + /// `&mut [u8]` that receives the encrypted data; it must have the same length as `plaintext`. + pub fn encrypt( + &self, + data_unit_size: u64, + tweak: u64, + plaintext: &[u8], + ciphertext: &mut [u8], + ) -> Result<(), SymCryptError> { + validate_xts_args(data_unit_size, plaintext.len())?; + if plaintext.len() != ciphertext.len() { + return Err(SymCryptError::WrongDataSize); + } + unsafe { + // SAFETY: FFI call. + symcrypt_sys::SymCryptXtsAesEncrypt( + self.expanded_key.get_inner(), + data_unit_size as symcrypt_sys::SIZE_T, + tweak as symcrypt_sys::UINT64, + plaintext.as_ptr(), + ciphertext.as_mut_ptr(), + plaintext.len() as symcrypt_sys::SIZE_T, + ); + } + Ok(()) + } + + /// `encrypt_in_place` encrypts `buffer` in place using XTS-AES with a 64-bit tweak. + /// + /// `data_unit_size` is the size in bytes of each data unit, typically 512. + /// It must be at least 16 and at most 2^24. `buffer.len()` must be a multiple of `data_unit_size`. + /// `tweak` is the tweak for the first data unit; it is incremented for each subsequent data unit + /// in `buffer`. + /// + /// `buffer` is a `&mut [u8]` that contains the plain text data to be encrypted. After the encryption has been completed, + /// `buffer` will be over-written to contain the cipher text data. + pub fn encrypt_in_place( + &self, + data_unit_size: u64, + tweak: u64, + buffer: &mut [u8], + ) -> Result<(), SymCryptError> { + validate_xts_args(data_unit_size, buffer.len())?; + unsafe { + // SAFETY: FFI call. + symcrypt_sys::SymCryptXtsAesEncrypt( + self.expanded_key.get_inner(), + data_unit_size as symcrypt_sys::SIZE_T, + tweak as symcrypt_sys::UINT64, + buffer.as_ptr(), + buffer.as_mut_ptr(), + buffer.len() as symcrypt_sys::SIZE_T, + ); + } + Ok(()) + } + + /// `decrypt` decrypts `ciphertext` into `plaintext` using XTS-AES with a 64-bit tweak. + /// + /// `data_unit_size` is the size in bytes of each data unit, typically 512. It must be at least + /// 16 and at most 2^24. `ciphertext.len()` must be a multiple of `data_unit_size`. + /// `tweak` is the tweak for the first data unit; it is incremented for each subsequent data + /// unit in `ciphertext`. + /// + /// `ciphertext` is a `&[u8]` containing the data to be decrypted. `plaintext` is a + /// `&mut [u8]` that receives the decrypted data; it must have the same length as `ciphertext`. + pub fn decrypt( + &self, + data_unit_size: u64, + tweak: u64, + ciphertext: &[u8], + plaintext: &mut [u8], + ) -> Result<(), SymCryptError> { + validate_xts_args(data_unit_size, ciphertext.len())?; + if ciphertext.len() != plaintext.len() { + return Err(SymCryptError::WrongDataSize); + } + unsafe { + // SAFETY: FFI call. + symcrypt_sys::SymCryptXtsAesDecrypt( + self.expanded_key.get_inner(), + data_unit_size as symcrypt_sys::SIZE_T, + tweak as symcrypt_sys::UINT64, + ciphertext.as_ptr(), + plaintext.as_mut_ptr(), + ciphertext.len() as symcrypt_sys::SIZE_T, + ); + } + Ok(()) + } + + /// `decrypt_in_place` decrypts `buffer` in place using XTS-AES with a 64-bit tweak. + /// + /// `data_unit_size` is the size in bytes of each data unit, typically 512. + /// It must be at least 16 and at most 2^24. `buffer.len()` must be a multiple of `data_unit_size`. + /// `tweak` is the tweak for the first data unit; it is incremented for each subsequent data unit + /// in `buffer`. + /// + /// `buffer` is a `&mut [u8]` that contains the cipher text data to be decrypted. After the decryption has been completed, + /// `buffer` will be over-written to contain the plain text data. + pub fn decrypt_in_place( + &self, + data_unit_size: u64, + tweak: u64, + buffer: &mut [u8], + ) -> Result<(), SymCryptError> { + validate_xts_args(data_unit_size, buffer.len())?; + unsafe { + // SAFETY: FFI call. + symcrypt_sys::SymCryptXtsAesDecrypt( + self.expanded_key.get_inner(), + data_unit_size as symcrypt_sys::SIZE_T, + tweak as symcrypt_sys::UINT64, + buffer.as_ptr(), + buffer.as_mut_ptr(), + buffer.len() as symcrypt_sys::SIZE_T, + ); + } + Ok(()) + } + + /// `encrypt_with_128b_tweak` encrypts `plaintext` into `ciphertext` using XTS-AES with a + /// 128-bit tweak. + /// + /// `data_unit_size` is the size in bytes of each data unit, typically 512. It must be at least + /// 16 and at most 2^24. `plaintext.len()` must be a multiple of `data_unit_size`. + /// `tweak` is a `&[u8; 16]` containing the 128-bit tweak for the first data unit; it is + /// incremented as a 128-bit integer for each subsequent data unit. + pub fn encrypt_with_128b_tweak( + &self, + data_unit_size: u64, + tweak: &[u8; 16], + plaintext: &[u8], + ciphertext: &mut [u8], + ) -> Result<(), SymCryptError> { + validate_xts_args(data_unit_size, plaintext.len())?; + if plaintext.len() != ciphertext.len() { + return Err(SymCryptError::WrongDataSize); + } + unsafe { + // SAFETY: FFI call. + symcrypt_sys::SymCryptXtsAesEncryptWith128bTweak( + self.expanded_key.get_inner(), + data_unit_size as symcrypt_sys::SIZE_T, + tweak.as_ptr(), + plaintext.as_ptr(), + ciphertext.as_mut_ptr(), + plaintext.len() as symcrypt_sys::SIZE_T, + ); + } + Ok(()) + } + + /// `encrypt_in_place_with_128b_tweak` encrypts `buffer` in place using XTS-AES with a + /// 128-bit tweak. + /// + /// `data_unit_size` is the size in bytes of each data unit, typically 512. + /// It must be at least 16 and at most 2^24. `buffer.len()` must be a multiple of `data_unit_size`. + /// `tweak` is a `&[u8; 16]` containing the 128-bit tweak for the first data unit; it is + /// incremented as a 128-bit integer for each subsequent data unit. + pub fn encrypt_in_place_with_128b_tweak( + &self, + data_unit_size: u64, + tweak: &[u8; 16], + buffer: &mut [u8], + ) -> Result<(), SymCryptError> { + validate_xts_args(data_unit_size, buffer.len())?; + unsafe { + // SAFETY: FFI call. + symcrypt_sys::SymCryptXtsAesEncryptWith128bTweak( + self.expanded_key.get_inner(), + data_unit_size as symcrypt_sys::SIZE_T, + tweak.as_ptr(), + buffer.as_ptr(), + buffer.as_mut_ptr(), + buffer.len() as symcrypt_sys::SIZE_T, + ); + } + Ok(()) + } + + /// `decrypt_with_128b_tweak` decrypts `ciphertext` into `plaintext` using XTS-AES with a + /// 128-bit tweak. + /// + /// `data_unit_size` is the size in bytes of each data unit, typically 512. It must be at least + /// 16 and at most 2^24. `ciphertext.len()` must be a multiple of `data_unit_size`. + /// `tweak` is a `&[u8; 16]` containing the 128-bit tweak for the first data unit; it is + /// incremented as a 128-bit integer for each subsequent data unit. + pub fn decrypt_with_128b_tweak( + &self, + data_unit_size: u64, + tweak: &[u8; 16], + ciphertext: &[u8], + plaintext: &mut [u8], + ) -> Result<(), SymCryptError> { + validate_xts_args(data_unit_size, ciphertext.len())?; + if ciphertext.len() != plaintext.len() { + return Err(SymCryptError::WrongDataSize); + } + unsafe { + // SAFETY: FFI call. + symcrypt_sys::SymCryptXtsAesDecryptWith128bTweak( + self.expanded_key.get_inner(), + data_unit_size as symcrypt_sys::SIZE_T, + tweak.as_ptr(), + ciphertext.as_ptr(), + plaintext.as_mut_ptr(), + ciphertext.len() as symcrypt_sys::SIZE_T, + ); + } + Ok(()) + } + + /// `decrypt_in_place_with_128b_tweak` decrypts `buffer` in place using XTS-AES with a + /// 128-bit tweak. + /// + /// `data_unit_size` is the size in bytes of each data unit, typically 512. + /// It must be at least 16 and at most 2^24. `buffer.len()` must be a multiple of `data_unit_size`. + /// `tweak` is a `&[u8; 16]` containing the 128-bit tweak for the first data unit; it is + /// incremented as a 128-bit integer for each subsequent data unit. + pub fn decrypt_in_place_with_128b_tweak( + &self, + data_unit_size: u64, + tweak: &[u8; 16], + buffer: &mut [u8], + ) -> Result<(), SymCryptError> { + validate_xts_args(data_unit_size, buffer.len())?; + unsafe { + // SAFETY: FFI call. + symcrypt_sys::SymCryptXtsAesDecryptWith128bTweak( + self.expanded_key.get_inner(), + data_unit_size as symcrypt_sys::SIZE_T, + tweak.as_ptr(), + buffer.as_ptr(), + buffer.as_mut_ptr(), + buffer.len() as symcrypt_sys::SIZE_T, + ); + } + Ok(()) + } +} + +// No custom Send / Sync impl. needed for XtsAesKey since the +// underlying data is a pointer to a SymCrypt struct that is not modified after it is created. +unsafe impl Send for XtsAesKey {} +unsafe impl Sync for XtsAesKey {} + +fn validate_xts_args(data_unit_size: u64, data_len: usize) -> Result<(), SymCryptError> { + if !(XTS_DATA_UNIT_MIN..=XTS_DATA_UNIT_MAX).contains(&data_unit_size) { + return Err(SymCryptError::InvalidArgument); + } + // SP 800-38E requires each data unit to be a multiple of the AES block size. + // SymCrypt's XTS encrypt/decrypt functions return VOID and only debug-assert + // alignment, so this check has to live in the wrapper. + if data_unit_size % (symcrypt_sys::SYMCRYPT_AES_BLOCK_SIZE as u64) != 0 { + return Err(SymCryptError::InvalidArgument); + } + if data_len == 0 { + return Err(SymCryptError::WrongDataSize); + } + if (data_len as u64) % data_unit_size != 0 { + return Err(SymCryptError::WrongDataSize); + } + Ok(()) +} + +#[cfg(test)] +mod test { + use super::*; + + const KEY_HEX: &str = "\ + 2718281828459045235360287471352662497757247093699959574966967627\ + 3141592653589793238462643383279502884197169399375105820974944592"; + + const KAT_PLAINTEXT_HEX: &str = "\ + 000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f\ + 303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f\ + 606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f\ + 909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebf\ + c0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeef\ + f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f\ + 202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f\ + 505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f\ + 808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeaf\ + b0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedf\ + e0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"; + + const KAT_CIPHERTEXT_HEX: &str = "\ + 1c3b3a102f770386e4836c99e370cf9bea00803f5e482357a4ae12d414a3e63b5d31e276f8fe4a8d66b317f9ac683f44\ + 680a86ac35adfc3345befecb4bb188fd5776926c49a3095eb108fd1098baec70aaa66999a72a82f27d848b21d4a741b0\ + c5cd4d5fff9dac89aeba122961d03a757123e9870f8acf1000020887891429ca2a3e7a7d7df7b10355165c8b9a6d0a7d\ + e8b062c4500dc4cd120c0f7418dae3d0b5781c34803fa75421c790dfe1de1834f280d7667b327f6c8cd7557e12ac3a0f\ + 93ec05c52e0493ef31a12d3d9260f79a289d6a379bc70c50841473d1a8cc81ec583e9645e07b8d9670655ba5bbcfecc6\ + dc3966380ad8fecb17b6ba02469a020a84e18e8f84252070c13e9f1f289be54fbc481457778f616015e1327a02b140f1\ + 505eb309326d68378f8374595c849d84f4c333ec4423885143cb47bd71c5edae9be69a2ffeceb1bec9de244fbe15992b\ + 11b77c040f12bd8f6a975a44a0f90c29a9abc3d4d893927284c58754cce294529f8614dcd2aba991925fedc4ae74ffac\ + 6e333b93eb4aff0479da9a410e4450e0dd7ae4c6e2910900575da401fc07059f645e8b7e9bfdef33943054ff84011493\ + c27b3429eaedb4ed5376441a77ed43851ad77f16f541dfd269d50d6a5f14fb0aab1cbb4c1550be97f7ab4066193c4caa\ + 773dad38014bd2092fa755c824bb5e54c4f36ffda9fcea70b9c6e693e148c151"; + + #[test] + fn test_xts_aes_256_kat_ieee_1619_tweak_0xff() { + let key = hex::decode(KEY_HEX).unwrap(); + let plaintext = hex::decode(KAT_PLAINTEXT_HEX).unwrap(); + let expected_ciphertext = hex::decode(KAT_CIPHERTEXT_HEX).unwrap(); + assert_eq!(plaintext.len(), 512); + assert_eq!(expected_ciphertext.len(), 512); + + let xts = XtsAesKey::new(&key).unwrap(); + + let mut buffer = plaintext.clone(); + xts.encrypt_in_place(512, 0xff, &mut buffer).unwrap(); + assert_eq!(buffer, expected_ciphertext); + + xts.decrypt_in_place(512, 0xff, &mut buffer).unwrap(); + assert_eq!(buffer, plaintext); + } + + #[test] + fn test_xts_aes_256_round_trip_single_unit() { + let key = hex::decode(KEY_HEX).unwrap(); + let xts = XtsAesKey::new(&key).unwrap(); + + let original: Vec = (0..64u8).collect(); + let mut buffer = original.clone(); + + xts.encrypt_in_place(64, 0xff, &mut buffer).unwrap(); + assert_ne!(buffer, original); + + xts.decrypt_in_place(64, 0xff, &mut buffer).unwrap(); + assert_eq!(buffer, original); + } + + #[test] + fn test_xts_aes_256_round_trip_multiple_units() { + let key = hex::decode(KEY_HEX).unwrap(); + let xts = XtsAesKey::new(&key).unwrap(); + + let original: Vec = (0..=255u8).collect(); // 256 bytes + let mut buffer = original.clone(); + + xts.encrypt_in_place(64, 0, &mut buffer).unwrap(); + xts.decrypt_in_place(64, 0, &mut buffer).unwrap(); + assert_eq!(buffer, original); + } + + #[test] + fn test_xts_aes_256_different_tweaks_produce_different_ciphertext() { + let key = hex::decode(KEY_HEX).unwrap(); + let xts = XtsAesKey::new(&key).unwrap(); + + let plaintext: Vec = (0..64u8).collect(); + let mut a = plaintext.clone(); + let mut b = plaintext.clone(); + + xts.encrypt_in_place(64, 0, &mut a).unwrap(); + xts.encrypt_in_place(64, 1, &mut b).unwrap(); + assert_ne!(a, b); + } + + #[test] + fn test_xts_aes_wrong_key_size() { + // 17 bytes is not a valid AES key pair size. + // SymCrypt splits into two 8-byte halves, which AES rejects as WrongKeySize. + let key: Vec = (0..17u8).collect(); + match XtsAesKey::new(&key) { + Ok(_) => panic!("expected WrongKeySize"), + Err(err) => assert_eq!(err, SymCryptError::WrongKeySize), + } + } + + #[test] + fn test_xts_aes_128_round_trip() { + // 32 bytes = two AES-128 keys + let key: Vec = (0..32u8).collect(); + let xts = XtsAesKey::new(&key).unwrap(); + + let original: Vec = (0..64u8).collect(); + let mut buffer = original.clone(); + + xts.encrypt_in_place(64, 0, &mut buffer).unwrap(); + assert_ne!(buffer, original); + + xts.decrypt_in_place(64, 0, &mut buffer).unwrap(); + assert_eq!(buffer, original); + } + + #[test] + fn test_xts_aes_256_equal_key_halves_fail_fips() { + let mut key = vec![0u8; 64]; + // Two equal halves. FIPS check rejects this. + for i in 0..32 { + key[i] = i as u8; + key[i + 32] = i as u8; + } + match XtsAesKey::new(&key) { + Ok(_) => panic!("expected FIPS-related failure on equal key halves"), + Err(err) => assert!( + matches!( + err, + SymCryptError::FipsFailure | SymCryptError::InvalidArgument + ), + "got {:?}", + err + ), + } + } + + #[test] + fn test_xts_aes_256_invalid_data_unit_size() { + let key = hex::decode(KEY_HEX).unwrap(); + let xts = XtsAesKey::new(&key).unwrap(); + let mut buffer = [0u8; 64]; + + // data_unit_size below 16 + let r = xts.encrypt_in_place(8, 0, &mut buffer); + assert_eq!(r.unwrap_err(), SymCryptError::InvalidArgument); + } + + #[test] + fn test_xts_aes_data_unit_size_not_block_aligned() { + let key = hex::decode(KEY_HEX).unwrap(); + let xts = XtsAesKey::new(&key).unwrap(); + let mut buffer = [0u8; 64]; + + let r = xts.encrypt_in_place(17, 0, &mut buffer); + assert_eq!(r.unwrap_err(), SymCryptError::InvalidArgument); + + let r = xts.encrypt_in_place(24, 0, &mut buffer); + assert_eq!(r.unwrap_err(), SymCryptError::InvalidArgument); + } + + #[test] + fn test_xts_aes_empty_buffer_fails() { + let key = hex::decode(KEY_HEX).unwrap(); + let xts = XtsAesKey::new(&key).unwrap(); + let mut buffer = [0u8; 0]; + + // Empty buffer with a valid data_unit_size, should be WrongDataSize path. + let r = xts.encrypt_in_place(16, 0, &mut buffer); + assert_eq!(r.unwrap_err(), SymCryptError::WrongDataSize); + } + + #[test] + fn test_xts_aes_empty_buffer_with_zero_data_unit_size_reports_data_unit_error() { + let key = hex::decode(KEY_HEX).unwrap(); + let xts = XtsAesKey::new(&key).unwrap(); + let mut buffer = [0u8; 0]; + + let r = xts.encrypt_in_place(0, 0, &mut buffer); + assert_eq!(r.unwrap_err(), SymCryptError::InvalidArgument); + } + + #[test] + fn test_xts_aes_256_buffer_not_multiple_of_data_unit() { + let key = hex::decode(KEY_HEX).unwrap(); + let xts = XtsAesKey::new(&key).unwrap(); + let mut buffer = [0u8; 80]; // 80 is not a multiple of 64 + + let r = xts.encrypt_in_place(64, 0, &mut buffer); + assert_eq!(r.unwrap_err(), SymCryptError::WrongDataSize); + } + + #[test] + fn test_xts_aes_256_out_of_place_round_trip() { + let key = hex::decode(KEY_HEX).unwrap(); + let xts = XtsAesKey::new(&key).unwrap(); + + let plaintext: Vec = (0..64u8).collect(); + let mut ciphertext = vec![0u8; plaintext.len()]; + + xts.encrypt(64, 0xff, &plaintext, &mut ciphertext).unwrap(); + assert_ne!(ciphertext, plaintext); + + let mut recovered = vec![0u8; ciphertext.len()]; + xts.decrypt(64, 0xff, &ciphertext, &mut recovered).unwrap(); + assert_eq!(recovered, plaintext); + } + + #[test] + fn test_xts_aes_256_out_of_place_matches_in_place() { + let key = hex::decode(KEY_HEX).unwrap(); + let xts = XtsAesKey::new(&key).unwrap(); + + let plaintext: Vec = (0..=255u8).collect(); + + // out-of-place + let mut ct_oop = vec![0u8; plaintext.len()]; + xts.encrypt(64, 7, &plaintext, &mut ct_oop).unwrap(); + + // in-place on a clone + let mut ct_ip = plaintext.clone(); + xts.encrypt_in_place(64, 7, &mut ct_ip).unwrap(); + + assert_eq!(ct_oop, ct_ip); + } + + #[test] + fn test_xts_aes_256_out_of_place_size_mismatch() { + let key = hex::decode(KEY_HEX).unwrap(); + let xts = XtsAesKey::new(&key).unwrap(); + + let plaintext = vec![0u8; 64]; + let mut ciphertext = vec![0u8; 32]; // wrong size + let r = xts.encrypt(64, 0, &plaintext, &mut ciphertext); + assert_eq!(r.unwrap_err(), SymCryptError::WrongDataSize); + } + + // -------- 128-bit tweak -------- + + #[test] + fn test_xts_aes_128b_tweak_in_place_round_trip() { + let key = hex::decode(KEY_HEX).unwrap(); + let xts = XtsAesKey::new(&key).unwrap(); + + let tweak: [u8; 16] = [0xff; 16]; + let original: Vec = (0..64u8).collect(); + let mut buffer = original.clone(); + + xts.encrypt_in_place_with_128b_tweak(64, &tweak, &mut buffer) + .unwrap(); + assert_ne!(buffer, original); + + xts.decrypt_in_place_with_128b_tweak(64, &tweak, &mut buffer) + .unwrap(); + assert_eq!(buffer, original); + } + + #[test] + fn test_xts_aes_128b_tweak_out_of_place_round_trip() { + let key = hex::decode(KEY_HEX).unwrap(); + let xts = XtsAesKey::new(&key).unwrap(); + + let tweak: [u8; 16] = [0x01; 16]; + let plaintext: Vec = (0..64u8).collect(); + let mut ciphertext = vec![0u8; plaintext.len()]; + + xts.encrypt_with_128b_tweak(64, &tweak, &plaintext, &mut ciphertext) + .unwrap(); + assert_ne!(ciphertext, plaintext); + + let mut recovered = vec![0u8; ciphertext.len()]; + xts.decrypt_with_128b_tweak(64, &tweak, &ciphertext, &mut recovered) + .unwrap(); + assert_eq!(recovered, plaintext); + } + + #[test] + fn test_xts_aes_128b_tweak_differs_from_64b_tweak() { + let key = hex::decode(KEY_HEX).unwrap(); + let xts = XtsAesKey::new(&key).unwrap(); + + let plaintext: Vec = (0..64u8).collect(); + + // 64-bit tweak = 0xff + let mut ct_64 = plaintext.clone(); + xts.encrypt_in_place(64, 0xff, &mut ct_64).unwrap(); + + // 128-bit tweak with high 64 bits set (differs from 64-bit variant which zeros the high half) + let tweak_128: [u8; 16] = [ + 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, + ]; + let mut ct_128 = plaintext.clone(); + xts.encrypt_in_place_with_128b_tweak(64, &tweak_128, &mut ct_128) + .unwrap(); + + assert_ne!(ct_64, ct_128); + } +} diff --git a/rust-symcrypt/src/ecc/mod.rs b/rust-symcrypt/src/ecc/mod.rs index 8af5fb1e..c7aacfbd 100644 --- a/rust-symcrypt/src/ecc/mod.rs +++ b/rust-symcrypt/src/ecc/mod.rs @@ -58,8 +58,8 @@ //! use crate::NumberFormat; use crate::{errors::SymCryptError, symcrypt_init}; -use lazy_static::lazy_static; use std::ptr; +use std::sync::LazyLock; pub mod ecdh; pub mod ecdsa; @@ -416,13 +416,14 @@ unsafe impl Send for EcKey {} unsafe impl Sync for EcKey {} // Curves can be re-used across EcKey calls, creating static references to save on allocations and increase perf. -lazy_static! { - static ref NIST_P256: Result = internal_new(CurveType::NistP256); - static ref NIST_P384: Result = internal_new(CurveType::NistP384); - static ref NIST_P521: Result = internal_new(CurveType::NistP521); - static ref CURVE_25519: Result = - internal_new(CurveType::Curve25519); -} +static NIST_P256: LazyLock> = + LazyLock::new(|| internal_new(CurveType::NistP256)); +static NIST_P384: LazyLock> = + LazyLock::new(|| internal_new(CurveType::NistP384)); +static NIST_P521: LazyLock> = + LazyLock::new(|| internal_new(CurveType::NistP521)); +static CURVE_25519: LazyLock> = + LazyLock::new(|| internal_new(CurveType::Curve25519)); // SymCryptInit must be called before any EcDh operations are performed. fn internal_new(curve: CurveType) -> Result { diff --git a/rust-symcrypt/src/errors.rs b/rust-symcrypt/src/errors.rs index db296be2..18c79c08 100644 --- a/rust-symcrypt/src/errors.rs +++ b/rust-symcrypt/src/errors.rs @@ -1,12 +1,13 @@ //! Friendly rust errors for SYMCRYPT_ERROR. For more info on SYMCRYPT_ERRORS please refer to symcrypt.h use std::convert::From; +use std::error; use std::fmt; use symcrypt_sys; /// `SymCryptError` is an enum that enumerates all of the errors from `SymCrypt`. #[non_exhaustive] -#[derive(Debug, PartialEq)] +#[derive(Clone, Debug, PartialEq)] pub enum SymCryptError { NoError, Unused, @@ -110,3 +111,5 @@ impl fmt::Display for SymCryptError { write!(f, "{}", message) } } + +impl error::Error for SymCryptError {} diff --git a/rust-symcrypt/src/gcm.rs b/rust-symcrypt/src/gcm.rs index 5b2432ee..7c229b21 100644 --- a/rust-symcrypt/src/gcm.rs +++ b/rust-symcrypt/src/gcm.rs @@ -114,7 +114,7 @@ impl GcmInnerKey { unsafe { &mut self.get_unchecked_mut().inner as *mut _ } } - // Safe method to access the inner state immutably + /// Safe method to access the inner state immutably pub(crate) fn get_inner(&self) -> *const symcrypt_sys::SYMCRYPT_GCM_EXPANDED_KEY { &self.inner as *const _ } diff --git a/rust-symcrypt/src/hkdf.rs b/rust-symcrypt/src/hkdf.rs index a6e86fed..214e4671 100644 --- a/rust-symcrypt/src/hkdf.rs +++ b/rust-symcrypt/src/hkdf.rs @@ -54,15 +54,15 @@ use symcrypt_sys; /// `info` is a `&[u8]` that represents an optional application-specific context that customizes the derived key. If you do not /// wish to use a salt, you can pass an empty slice. /// -/// `output_key_size` is an `u64` that represents the desired length of the derived key in bytes, the `Vec` returned will be of this length. +/// `output_key_size` is a `usize` that represents the desired length of the derived key in bytes, the `Vec` returned will be of this length. pub fn hkdf( hmac_algorithm: HmacAlgorithm, key_material: &[u8], salt: &[u8], info: &[u8], - output_key_size: u64, + output_key_size: usize, ) -> Result, SymCryptError> { - let mut hmac_res = vec![0u8; output_key_size as usize]; + let mut hmac_res = vec![0u8; output_key_size]; unsafe { // UNSAFE: FFI calls match symcrypt_sys::SymCryptHkdf( diff --git a/rust-symcrypt/src/lib.rs b/rust-symcrypt/src/lib.rs index 70607f32..4908412a 100644 --- a/rust-symcrypt/src/lib.rs +++ b/rust-symcrypt/src/lib.rs @@ -10,56 +10,31 @@ pub mod hash; pub mod hkdf; pub mod hmac; pub mod rsa; +pub mod sp800_108; // symcrypt_init must be called before any other API can be called. All subsequent calls to symcrypt_init will be no-ops fn symcrypt_init() { // Subsequent calls to `symcrypt_init()` after the first will not be invoked per .call_once docs https://doc.rust-lang.org/std/sync/struct.Once.html static INIT: Once = Once::new(); - - // `symcrypt_init` calls `SymCryptModuleInit` or `SymCryptInit` depending on the feature flag - // We have also set feature flags on the bindings themselves to only expose the functions we need. - // This is to try and eliminate footguns like calling SymCryptModuleInit on a statically linked module. unsafe { // SAFETY: FFI calls, blocking from being run again. - - #[cfg(feature = "dynamic")] INIT.call_once(|| { symcrypt_sys::SymCryptModuleInit( symcrypt_sys::SYMCRYPT_CODE_VERSION_API, symcrypt_sys::SYMCRYPT_CODE_VERSION_MINOR, ) }); - - #[cfg(not(feature = "dynamic"))] - INIT.call_once(|| { - symcrypt_sys::SymCryptInit(); - }); } } /// Takes in a buffer called `buff` and fills it with random bytes. This function /// is never expected to fail, but failure (due to OS dependencies) will crash the application. /// There is no recoverable failure mode. -/// -/// If calling `symcrypt_random` with a dynamically linked module, `SymCryptRandom` will be called. -/// -/// If calling `symcrypt_random` with a statically linked module, `SymCryptCallbackRandom` will be called. pub fn symcrypt_random(buff: &mut [u8]) { symcrypt_init(); - - // `symcrypt_random` calls `SymCryptRandom` or `SymCryptCallbackRandom` depending on the feature flag - // We have also set feature flags on the bindings themselves to only expose the functions we need. - // This is to try and eliminate footguns like calling SymCryptRandom on a statically linked module. unsafe { // SAFETY: FFI call - - // Call SymCryptRandom for dynamic linking - #[cfg(feature = "dynamic")] symcrypt_sys::SymCryptRandom(buff.as_mut_ptr(), buff.len() as symcrypt_sys::SIZE_T); - - // Call SymCryptCallbackRandom for static linking - #[cfg(not(feature = "dynamic"))] - symcrypt_sys::SymCryptCallbackRandom(buff.as_mut_ptr(), buff.len() as symcrypt_sys::SIZE_T); } } diff --git a/rust-symcrypt/src/sp800_108.rs b/rust-symcrypt/src/sp800_108.rs new file mode 100644 index 00000000..96e23ea0 --- /dev/null +++ b/rust-symcrypt/src/sp800_108.rs @@ -0,0 +1,151 @@ +//! SP800-108 Counter-Mode KDF functions. For more info please refer to symcrypt.h +//! +//! # Example +//! +//! ## SP800-108 Counter Mode with HmacSha256 +//! +//! ```rust +//! use symcrypt::sp800_108::sp800_108_counter_mode; +//! use symcrypt::hmac::HmacAlgorithm; +//! use hex::*; +//! +//! // Setup the initial keying material. +//! let key = hex::decode("0001020304050607").unwrap(); +//! let label = b"Label"; +//! +//! let context = hex::decode("101112131415161718191a1b1c1d1e1f").unwrap(); +//! let hmac_algorithm = HmacAlgorithm::HmacSha256; +//! +//! let expected = "00264bbb14974054"; +//! let res = sp800_108_counter_mode(hmac_algorithm, &key, label, &context, 8).unwrap(); +//! assert_eq!(res.len(), 8); +//! assert_eq!(expected, hex::encode(res)); +//! ``` +//! +//! ## SP800-108 Counter Mode with empty label and context +//! +//! `label` and `context` are both optional and may be passed as empty slices when not used. +//! +//! ```rust +//! use symcrypt::sp800_108::sp800_108_counter_mode; +//! use symcrypt::hmac::HmacAlgorithm; +//! use hex::*; +//! +//! // Setup the initial keying material (KI) +//! let key = hex::decode("0001020304050607").unwrap(); +//! let hmac_algorithm = HmacAlgorithm::HmacSha256; +//! +//! let res = sp800_108_counter_mode(hmac_algorithm, &key, &[], &[], 32).unwrap(); +//! assert_eq!(res.len(), 32); +//! ``` +//! +use crate::errors::SymCryptError; +use crate::hmac::HmacAlgorithm; +use crate::symcrypt_init; +use symcrypt_sys; + +/// `sp800_108_counter_mode()` derives a key using the NIST SP800-108 Counter Mode KDF and returns +/// a `Vec`, or a [`SymCryptError`] if the operation fails. +/// +/// `hmac_algorithm` is an [`HmacAlgorithm`] selecting the HMAC PRF used internally by the KDF. +/// +/// `key_material` is a `&[u8]` containing the secret key. +/// +/// `label` is a `&[u8]` containing an application-specific label. You can pass an empty slice. +/// +/// `context` is a `&[u8]` containing application-specific context bytes. You can pass an empty slice. +/// +/// `output_key_size` is a `usize` specifying the desired length of the derived key in bytes. +/// The returned `Vec` will have exactly this length. +pub fn sp800_108_counter_mode( + hmac_algorithm: HmacAlgorithm, + key_material: &[u8], + label: &[u8], + context: &[u8], + output_key_size: usize, +) -> Result, SymCryptError> { + symcrypt_init(); + let mut result = vec![0u8; output_key_size]; + unsafe { + // UNSAFE: FFI calls + match symcrypt_sys::SymCryptSp800_108( + hmac_algorithm.to_symcrypt_hmac_algorithm(), + key_material.as_ptr(), + key_material.len() as symcrypt_sys::SIZE_T, + label.as_ptr(), + label.len() as symcrypt_sys::SIZE_T, + context.as_ptr(), + context.len() as symcrypt_sys::SIZE_T, + result.as_mut_ptr(), + result.len() as symcrypt_sys::SIZE_T, + ) { + symcrypt_sys::SYMCRYPT_ERROR_SYMCRYPT_NO_ERROR => Ok(result), + err => Err(SymCryptError::from(err)), + } + } +} + +#[cfg(test)] +mod test { + use super::*; + use hex; + + #[test] + fn test_sp800_108_hmac_sha256_kat() { + let key = hex::decode("0001020304050607").unwrap(); + let context = hex::decode("101112131415161718191a1b1c1d1e1f").unwrap(); + let expected = "00264bbb14974054"; + let res = + sp800_108_counter_mode(HmacAlgorithm::HmacSha256, &key, b"Label", &context, 8).unwrap(); + assert_eq!(hex::encode(res), expected); + } + + #[test] + fn test_sp800_108_hmac_sha384_kat() { + let key = hex::decode("0001020304050607").unwrap(); + let context = hex::decode("101112131415161718191a1b1c1d1e1f").unwrap(); + let expected = "c7102787d896bc89"; + let res = + sp800_108_counter_mode(HmacAlgorithm::HmacSha384, &key, b"Label", &context, 8).unwrap(); + assert_eq!(hex::encode(res), expected); + } + + #[test] + fn test_sp800_108_hmac_sha512_kat() { + let key = hex::decode("0001020304050607").unwrap(); + let context = hex::decode("101112131415161718191a1b1c1d1e1f").unwrap(); + let expected = "db3a18d96c4ad41e"; + let res = + sp800_108_counter_mode(HmacAlgorithm::HmacSha512, &key, b"Label", &context, 8).unwrap(); + assert_eq!(hex::encode(res), expected); + } + + #[test] + fn test_sp800_108_deterministic() { + let key = hex::decode("0001020304050607").unwrap(); + let context = hex::decode("101112131415161718191a1b1c1d1e1f").unwrap(); + let res1 = sp800_108_counter_mode(HmacAlgorithm::HmacSha256, &key, b"Label", &context, 64) + .unwrap(); + let res2 = sp800_108_counter_mode(HmacAlgorithm::HmacSha256, &key, b"Label", &context, 64) + .unwrap(); + assert_eq!(res1, res2); + assert_eq!(res1.len(), 64); + } + + #[test] + fn test_sp800_108_different_context_differs() { + let key = hex::decode("0001020304050607").unwrap(); + let res1 = + sp800_108_counter_mode(HmacAlgorithm::HmacSha256, &key, b"Label", b"A", 32).unwrap(); + let res2 = + sp800_108_counter_mode(HmacAlgorithm::HmacSha256, &key, b"Label", b"B", 32).unwrap(); + assert_ne!(res1, res2); + } + + #[test] + fn test_sp800_108_empty_label_and_context() { + let key = hex::decode("0001020304050607").unwrap(); + let res = sp800_108_counter_mode(HmacAlgorithm::HmacSha256, &key, &[], &[], 32).unwrap(); + assert_eq!(res.len(), 32); + } +} diff --git a/symcrypt-bindgen/README.md b/symcrypt-bindgen/README.md index eb52ea17..81526531 100644 --- a/symcrypt-bindgen/README.md +++ b/symcrypt-bindgen/README.md @@ -1,21 +1,21 @@ -# symcrypt-bindgen - -This repository is intended for development purposes only. Users should not generate or use their -own raw bindings. - -## Updating Bindings - -To create new bindings, run the following command: - -```powershell -cargo run --locked --bin symcrypt-bindgen -``` - -For Windows users, there is a script available to update bindings for all four supported platforms: - -```powershell -./scripts/generate_all_bindings.ps1 -``` - -Alternatively, you can create a pull request with the `publish_new_bindings` label. In this case, -the bindings will be published as an artifact on GitHub. +# symcrypt-bindgen + +This repository is intended for development purposes only. Users should not generate or use their +own raw bindings. + +## Updating Bindings + +To create new bindings, run the following command: + +```powershell +cargo run --locked --bin symcrypt-bindgen +``` + +For Windows users, there is a script available to update bindings for all four supported platforms: + +```powershell +./scripts/generate_all_bindings.ps1 +``` + +Alternatively, you can create a pull request with the `publish_new_bindings` label. In this case, +the bindings will be published as an artifact on GitHub. diff --git a/symcrypt-bindgen/src/main.rs b/symcrypt-bindgen/src/main.rs index 1f12bcd7..43162567 100644 --- a/symcrypt-bindgen/src/main.rs +++ b/symcrypt-bindgen/src/main.rs @@ -57,7 +57,6 @@ fn main() { // INIT FUNCTIONS .allowlist_function("SymCryptModuleInit") - .allowlist_function("SymCryptInit") .allowlist_var("^(SYMCRYPT_CODE_VERSION.*)$") // HASH FUNCTIONS .allowlist_function("^SymCrypt(?:Sha3_(?:256|384|512)|Sha(?:256|384|512|1)|Md5)(?:Init|Append|Result|StateCopy)?$") @@ -76,8 +75,14 @@ fn main() { .allowlist_var("SymCryptAesBlockCipher") .allowlist_function("^SymCryptAesExpandKey$") .allowlist_var("SYMCRYPT_AES_BLOCK_SIZE") + // XTS-AES FUNCTIONS + .allowlist_function("^SymCryptXtsAes(ExpandKey|ExpandKeyEx|KeyCopy|Encrypt|Decrypt|EncryptWith128bTweak|DecryptWith128bTweak)$") + // AES-KW and AES-KWP FUNCTIONS (SP 800-38F) + .allowlist_function("^SymCryptAes(Kw|Kwp)(Encrypt|Decrypt)$") // HKDF FUNCTIONS - .allowlist_function("^(SymCryptHkdf.*)$") + .allowlist_function("^(SymCryptHkdf.*)$") + // SP800-108 FUNCTIONS + .allowlist_function("^(SymCryptSp800_108.*)$") // ECDH KEY AGREEMENT FUNCTIONS .allowlist_function("^SymCryptEcurve(Allocate|Free|SizeofFieldElement)$") .allowlist_var("^SymCryptEcurveParams(NistP256|NistP384|NistP521|Curve25519)$") @@ -107,7 +112,6 @@ fn main() { // UTILITY FUNCTIONS .allowlist_function("SymCryptWipe") .allowlist_function("SymCryptRandom") - .allowlist_function("SymCryptCallbackRandom") .allowlist_function("SymCryptLoadMsbFirstUint64") .allowlist_function("SymCryptStoreMsbFirstUint64") @@ -120,10 +124,6 @@ fn main() { .write_to_file(&bindings_file) .expect("Couldn't write bindings!"); - // For dynamic linking, we expose SymCryptModuleInit, for static linking, we expose SymCryptInit. - fix_symcrypt_bindings(&bindings_file); - - // For dynamic linking, we need to add a link attribute to the bindings. fix_bindings_for_windows(triple, &bindings_file); } @@ -158,8 +158,7 @@ fn get_rust_version_from_cargo_metadata() -> String { fn fix_bindings_for_windows(triple: &str, bindings_file: &str) { if triple.contains("windows") { println!("Fixing bindings for Windows"); - let link_str = - r#"#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))]"#; + let link_str = "#[link(name = \"symcrypt\", kind = \"dylib\")]"; let regex_exp1 = regex::Regex::new(r"pub static \w+: \[SYMCRYPT_OID; \d+usize\];").unwrap(); let regex_exp2 = regex::Regex::new(r"pub static \w+: PCSYMCRYPT_\w+;").unwrap(); let bindings_content = @@ -185,54 +184,3 @@ fn fix_bindings_for_windows(triple: &str, bindings_file: &str) { .expect("Unable to write bindings file"); } } - -#[allow(clippy::collapsible_if)] -fn fix_symcrypt_bindings(bindings_file: &str) { - println!("Fixing bindings to expose SymCryptInit or SymCryptModuleInit and SymCryptRandom"); - - let bindings_content = - std::fs::read_to_string(bindings_file).expect("Unable to read bindings file"); - - let mut out_content = Vec::new(); - let lines: Vec<&str> = bindings_content.lines().collect(); - let mut i = 0; - - // With Dynamic, we want to expose SymCryptModuleInit and SymCryptRandom - // With Static, we want to expose SymCryptInit and SymCryptCallbackRandom - while i < lines.len() { - if lines[i].trim() == "extern \"C\" {" { - if i + 1 < lines.len() { - let next_line = lines[i + 1].trim(); - - let cfg_attr = match next_line { - line if line == "pub fn SymCryptInit();" - || line.starts_with("pub fn SymCryptCallbackRandom(") => - { - "#[cfg(not(feature = \"dynamic\"))]" - } - line if line.starts_with("pub fn SymCryptModuleInit(") - || line.starts_with("pub fn SymCryptRandom(") => - { - "#[cfg(feature = \"dynamic\")]" - } - _ => "", - }; - - if !cfg_attr.is_empty() { - out_content.push(cfg_attr.to_string()); - } - } - } - - out_content.push(lines[i].to_string()); - i += 1; - } - - // Append newline for linux bindings - if !out_content.last().unwrap_or(&String::new()).ends_with('\n') { - out_content.push("".to_string()); - } - - // Write the modified content back - std::fs::write(bindings_file, out_content.join("\n")).expect("Unable to write bindings file"); -} diff --git a/symcrypt-sys/Cargo.toml b/symcrypt-sys/Cargo.toml index 28f399ea..e6d23c5f 100644 --- a/symcrypt-sys/Cargo.toml +++ b/symcrypt-sys/Cargo.toml @@ -6,20 +6,13 @@ license = "MIT OR Apache-2.0" description = "Rust/C Bindings for SymCrypt" edition.workspace = true rust-version.workspace = true -build = "build/main.rs" +build = "build.rs" homepage = "https://github.com/microsoft/SymCrypt" repository = "https://github.com/microsoft/rust-symcrypt" readme = "README.md" -exclude = ["symcrypt/*", "inc/*"] # FIXME: update this before merging to main branch -#links = "symcrypt" # FIXME: uncomment this before merging to main branch - -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html - -[features] -dynamic = [] +links = "symcrypt" +categories = ["cryptography", "external-ffi-bindings"] +keywords = ["symcrypt", "crypto", "ffi", "fips", "bindings"] [dependencies] -libc = "0.2.0" - -[build-dependencies] -cc = { version = "1.2.10" } # FIXME: enable parallel feature before merging to main branch +libc = { workspace = true } diff --git a/symcrypt-sys/README.md b/symcrypt-sys/README.md index 0cd79b66..b7e7514b 100644 --- a/symcrypt-sys/README.md +++ b/symcrypt-sys/README.md @@ -1,35 +1,35 @@ -# SymCrypt Rust/C FFI Bindings -symcrypt-sys provides Rust/C FFI bindings for the [SymCrypt](https://github.com/microsoft/SymCrypt) library. - -This crate is supplementary to the `symcrypt` crate. - -The bindings are checked into this crate in order to have better control over the binding generation as well as the exposed APIs from SymCrypt. To speed up the common case build process, the binding generation has been separated to `symcrypt-bindgen` - -## Changelog - -To view a detailed list of changes please see the [releases page](https://github.com/microsoft/rust-symcrypt/releases/). - - -## Usage - -Recommended usage is to take advantage of the `symcrypt` crate, which provides safe and rust idiomatic wrappers over the bindings. - -However, If you want to access the bindings directly, you can add `symcrypt-sys` as a dependency in your rust project. - -You must also configure your system to pick up the SymCrypt lib on your machine, please see: [INSTALL.md](https://github.com/microsoft/rust-symcrypt/blob/main/rust-symcrypt/INSTALL.md) for more info. - -In your `Cargo.toml` -```Rust -symcrypt-sys = "0.4.0" -``` -Then you can call the underlying SymCrypt code directly via the FFIs. -```Rust -unsafe { - // SAFETY: FFI calls - symcrypt_sys::SymCryptSha384( - data.as_ptr(), - data.len() as symcrypt_sys::SIZE_T, - result.as_mut_ptr(), - ); -} -``` \ No newline at end of file +# SymCrypt Rust/C FFI Bindings +symcrypt-sys provides Rust/C FFI bindings for the [SymCrypt](https://github.com/microsoft/SymCrypt) library. + +This crate is supplementary to the `symcrypt` crate. + +The bindings are checked into this crate in order to have better control over the binding generation as well as the exposed APIs from SymCrypt. To speed up the common case build process, the binding generation has been separated to `symcrypt-bindgen` + +## Changelog + +To view a detailed list of changes please see the [releases page](https://github.com/microsoft/rust-symcrypt/releases/). + + +## Usage + +Recommended usage is to take advantage of the `symcrypt` crate, which provides safe and rust idiomatic wrappers over the bindings. + +However, If you want to access the bindings directly, you can add `symcrypt-sys` as a dependency in your rust project. + +You must also configure your system to pick up the SymCrypt lib on your machine, please see: [INSTALL.md](https://github.com/microsoft/rust-symcrypt/blob/main/rust-symcrypt/INSTALL.md) for more info. + +In your `Cargo.toml` +```Rust +symcrypt-sys = "0.4.0" +``` +Then you can call the underlying SymCrypt code directly via the FFIs. +```Rust +unsafe { + // SAFETY: FFI calls + symcrypt_sys::SymCryptSha384( + data.as_ptr(), + data.len() as symcrypt_sys::SIZE_T, + result.as_mut_ptr(), + ); +} +``` diff --git a/symcrypt-sys/VERSION.md b/symcrypt-sys/VERSION.md index 6af964d4..c6c25b7f 100644 --- a/symcrypt-sys/VERSION.md +++ b/symcrypt-sys/VERSION.md @@ -1 +1 @@ -53be637dab201a4c9d95e1cf58040c85d71cf3c2 +748c20f1fc486beca1a2679ed06492712cfdc950 diff --git a/symcrypt-sys/build.rs b/symcrypt-sys/build.rs new file mode 100644 index 00000000..ca6f686c --- /dev/null +++ b/symcrypt-sys/build.rs @@ -0,0 +1,45 @@ +fn env_var_for_target(name: &str) -> Option { + let prefix = std::env::var("TARGET") + .unwrap() + .to_uppercase() + .replace('-', "_"); + let prefixed = format!("{prefix}_{name}"); + + fn env_inner(name: &str) -> Option { + let var = std::env::var_os(name); + let var = var.map(|x| x.to_string_lossy().into()); + println!("cargo:rerun-if-env-changed={name}"); + // Debug prints + match var { + Some(ref v) => println!("{} = {}", name, v), + None => println!("{name} unset"), + } + var + } + + env_inner(&prefixed).or_else(|| env_inner(name)) +} + +fn main() { + // Optionally allow callers to override where the linker/loader looks for + // libsymcrypt by setting SYMCRYPT_LIB_PATH (or the target-specific + // variant, e.g. X86_64_UNKNOWN_LINUX_GNU_SYMCRYPT_LIB_PATH). This is + // useful when libsymcrypt is not installed in a default library + // search path, or when cross-compiling. + if let Some(lib_path) = env_var_for_target("SYMCRYPT_LIB_PATH") { + println!("cargo:rustc-link-search=native={}", lib_path); + } else { + #[cfg(windows)] + panic!("SYMCRYPT_LIB_PATH environment variable not set, for more information please see: https://github.com/microsoft/rust-symcrypt/tree/main/rust-symcrypt#quick-start-guide") + } + + if let Some(static_link) = env_var_for_target("SYMCRYPT_STATIC") { + if static_link != "0" { + println!("cargo:rustc-link-lib=static=symcrypt"); + } else { + println!("cargo:rustc-link-lib=dylib=symcrypt"); + } + } else { + println!("cargo:rustc-link-lib=dylib=symcrypt"); + } +} diff --git a/symcrypt-sys/build/main.rs b/symcrypt-sys/build/main.rs deleted file mode 100644 index 66acc7d9..00000000 --- a/symcrypt-sys/build/main.rs +++ /dev/null @@ -1,50 +0,0 @@ -#[cfg(not(feature = "dynamic"))] -pub mod static_link; - -#[cfg(not(feature = "dynamic"))] -pub mod triple; - -fn main() -> std::io::Result<()> { - #[cfg(feature = "dynamic")] - link_symcrypt_dynamically()?; - - #[cfg(not(feature = "dynamic"))] - static_link::compile_and_link_symcrypt()?; - - Ok(()) -} - -#[cfg(feature = "dynamic")] -fn link_symcrypt_dynamically() -> std::io::Result<()> { - #[cfg(target_os = "windows")] - { - // Look for the .lib file during link time. We are searching the PATH for symcrypt.dll - let lib_path = std::env::var("SYMCRYPT_LIB_PATH") - .unwrap_or_else(|_| panic!("SYMCRYPT_LIB_PATH environment variable not set, for more information please see: https://github.com/microsoft/rust-symcrypt/tree/main/rust-symcrypt#quick-start-guide")); - println!("cargo:rustc-link-search=native={}", lib_path); - - println!("cargo:rustc-link-lib=dylib=symcrypt"); - - // During run time, the OS will handle finding the symcrypt.dll file. The places Windows will look will be: - // 1. The folder from which the application loaded. - // 2. The system folder. Use the GetSystemDirectory function to retrieve the path of this folder. - // 3. The Windows folder. Use the GetWindowsDirectory function to get the path of this folder. - // 4. The current folder. - // 5. The directories that are listed in the PATH environment variable. - - // For more info please see: https://learn.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-search-order - } - - #[cfg(target_os = "linux")] - { - println!("cargo:rustc-link-lib=dylib=symcrypt"); // the "lib" prefix for libsymcrypt is implied on Linux - - // If you are using AL3, you can get the required symcrypt.so via tdnf - // If you are using Ubuntu, you can get the required symcrypt.so via PMC. Please see the quick start guide for more information. - - // If you are using a different Linux distro, you will need to configure your distro's LD linker to find the required symcrypt.so files. - // As an example, on Ubuntu you can place your symcrypt.so files in your usr/lib/x86_64-linux-gnu/ path. - } - - Ok(()) -} diff --git a/symcrypt-sys/build/static_link.rs b/symcrypt-sys/build/static_link.rs deleted file mode 100644 index 4391452e..00000000 --- a/symcrypt-sys/build/static_link.rs +++ /dev/null @@ -1,465 +0,0 @@ -use super::triple::Triple; -use std::collections::HashSet; - -const LIB_NAME: &str = "symcrypt"; - -/// Compiles and links the SymCrypt library statically. -/// This is the entery point for building SymCrypt statically. -/// -/// - Determines the build configuration based on target architecture. -/// - Calls `compile_symcrypt_static()` to actually build SymCrypt. -/// - Outputs necessary metadata for Cargo (`cargo:rustc-link-lib=...`). -/// -/// Based on SymCrypt's `CMakeLists.txt`, but adapted for Rust. -pub fn compile_and_link_symcrypt() -> std::io::Result<()> { - let options = SymCryptOptions::new(); - println!("Build config: {:?}", options); - - // Required Windows bcrypt dependency for BCryptGenRandom - const ADDITIONAL_DEPENDENCIES: &[&str] = &[ - #[cfg(windows)] - "bcrypt", - ]; - println!("cargo:rerun-if-changed=upstream"); - println!("Compiling SymCrypt..."); - - // Compile and Build SymCrypt with provided SymCryptOptions - compile_symcrypt_static(LIB_NAME, &options)?; - println!("cargo:rustc-link-lib=static={LIB_NAME}"); - - // Link additional dependencies - for dep in ADDITIONAL_DEPENDENCIES { - println!("cargo:rustc-link-lib=dylib={dep}"); - } - - Ok(()) -} - -// TODO: update -symcrypt_fips_build comment - -/// Holds configuration options for compiling SymCrypt. -/// -/// - `triple`: The target triple -/// - `symcrypt_use_asm`: Whether to enable assembly optimizations. -/// - `symcrypt_fips_build`: Whether to build in FIPS mode PLACEHOLDER -/// - `preconfiged_cc`: Returns a Pre-configured `cc` object for the target triple. -#[derive(Debug)] -struct SymCryptOptions { - triple: Triple, - symcrypt_use_asm: bool, - //symcrypt_fips_build: bool, // TODO: Determine if we should expose FIPS build option? -} - -impl SymCryptOptions { - fn new() -> Self { - Self { - triple: Triple::get_target_triple(), - symcrypt_use_asm: false, // FIXME: Turn this to true when we get ASM checked in - //symcrypt_fips_build: false, // TODO: Determine if we should expose FIPS build option? - } - } - fn use_asm(&self) -> bool { - self.symcrypt_use_asm - } - fn triple(&self) -> Triple { - self.triple.clone() - } - - // Returns a cc object that has been preconfigured for the target triple - fn preconfigure_cc(&self) -> cc::Build { - let mut cc = cc::Build::new(); - cc.target(self.triple.to_triple()) - .include("inc") - .include("symcrypt/inc") - .include("symcrypt/lib") - .warnings(false); // Ignore noisy warnings from SymCrypt - - if !self.symcrypt_use_asm { - cc.define("SYMCRYPT_IGNORE_PLATFORM", None); // TODO: Fix when we get ASM - } - - // Set specific flags for operating system - - match self.triple { - // Target all Windows targets - Triple::x86_64_pc_windows_msvc | Triple::aarch64_pc_windows_msvc => { - // From SymCrypt-Platforms.cmake - cc.flag("/MP") // Multi-threaded compilation - .flag("/Zp8") // Structure packing alignment - .flag("/WX") // Treat warnings as errors - .flag("/guard:cf") // Control Flow Guard - .flag("/wd5105") // Disable warning caused by Windows SDK headers - .flag("/EHsc"); // Exception handling - // .flag("/dynamicbase"); // Enabling ASLR produces lots of warnings - - // From lib/CmakeLists.txt - // cc.asm_flag("/DSYMCRYPT_MASM"); // TODO: enable for ASM - } - - // Target all Linux targets - Triple::x86_64_unknown_linux_gnu | Triple::aarch64_unknown_linux_gnu => { - // From lib/CmakeLists.txt - // Stack Protection ON by default for linux - cc.flag("-fstack-protector-strong") - .flag("-Wstack-protector") - .flag("--param=ssp-buffer-size=4") - .flag("-fstack-clash-protection") - .flag("-Wno-incompatible-pointer-types"); // Ignore noisy SymCrypt errors - - // From lib/CmakeLists.txt - // cc.flag("-x assembler-with-cpp"); // TODO: enable for ASM - - // From SymCrypt-Platforms.cmake - cc.flag("-Wno-unknown-pragmas") - .flag("-Werror") - .flag("-Wno-deprecated-declarations") - .flag("-Wno-deprecated") - .flag("-g") - .flag("-Wno-multichar") - .flag("-fPIC") // PIC is enabled by default on Linux - .flag("-fno-plt") - .flag("-fno-builtin-bcmp") - .flag("-fno-unroll-loops"); - } - } - - // Set specific flags for each triple - match self.triple { - Triple::x86_64_pc_windows_msvc => { - // From SymCrypt-Platforms.cmake - cc.define("_AMD64_", None).flag("/Gz"); // Set default to __stdcall, only for X86 - } - Triple::aarch64_pc_windows_msvc => { - cc.define("_ARM64_", None); - } - Triple::x86_64_unknown_linux_gnu => { - // From SymCrypt-Platforms.cmake - // Only for x86_64_unknown_linux_gnu - cc.flag("-mssse3") - .flag("-mxsave") - .flag("-maes") - .flag("-mpclmul") - .flag("-msha") - .flag("-mrdrnd") - .flag("-mrdseed"); - } - Triple::aarch64_unknown_linux_gnu => { - // From SymCrypt-Platforms.cmake - cc.flag("-march=armv8-a+simd+crypto") // Enable a baseline of features for the compiler to support everywhere. - .flag("-flax-vector-conversions"); // Setting -flax-vector-conversions to build Arm64 intrinsics code with GCC. - } - } - - cc - } -} - -const SOURCE_DIR: &str = "symcrypt/lib"; -const SOURCES_COMMON: &str = " -3des.c -a_dispatch.c -aes-asm.c -aes-c.c -aes-default-bc.c -aes-default.c -aes-key.c -aes-neon.c -aes-selftest.c -aes-xmm.c -aes-ymm.c -aescmac.c -aesCtrDrbg.c -aeskw.c -AesTables.c -blockciphermodes.c -ccm.c -chacha20_poly1305.c -chacha20.c -cpuid_notry.c -cpuid_um.c -cpuid.c -crt.c -DesTables.c -desx.c -dh.c -dl_internal_groups.c -dlgroup.c -dlkey.c -dsa.c -ec_dh.c -ec_dispatch.c -ec_dsa.c -ec_internal_curves.c -ec_montgomery.c -ec_mul.c -ec_short_weierstrass.c -ec_twisted_edwards.c -eckey.c -ecpoint.c -ecurve.c -equal.c -FatalIntercept.c -fdef_general.c -fdef_int.c -fdef_mod.c -fdef369_mod.c -fips_selftest.c -gcm.c -gen_int.c -ghash.c -hash.c -hkdf_selftest.c -hkdf.c -hmac.c -hmacmd5.c -hmacsha1.c -hmacsha224.c -hmacsha256.c -hmacsha384.c -hmacsha512.c -hmacsha512_224.c -hmacsha512_256.c -hmacsha3_224.c -hmacsha3_256.c -hmacsha3_384.c -hmacsha3_512.c -kmac.c -libmain.c -lms.c -marvin32.c -md2.c -md4.c -md5.c -mldsa.c -mldsa_primitives.c -mlkem.c -mlkem_primitives.c -modexp.c -paddingPkcs7.c -parhash.c -pbkdf2_hmacsha1.c -pbkdf2_hmacsha256.c -pbkdf2.c -poly1305.c -primes.c -rc2.c -rc4.c -rdrand.c -rdseed.c -recoding.c -rsa_enc.c -rsa_padding.c -rsakey.c -ScsTable.c -scsTools.c -selftest.c -service_indicator.c -session.c -sha1.c -sha256.c -sha256Par.c -sha256Par-ymm.c -sha256-xmm.c -sha256-ymm.c -sha512.c -sha512Par.c -sha512Par-ymm.c -sha512-ymm.c -sha3.c -sha3_224.c -sha3_256.c -sha3_384.c -sha3_512.c -shake.c -sp800_108_hmacsha1.c -sp800_108_hmacsha256.c -sp800_108_hmacsha512.c -sp800_108.c -srtp_kdf.c -srtp_kdf_selftest.c -ssh_kdf.c -ssh_kdf_sha256.c -ssh_kdf_sha512.c -sskdf.c -sskdf_selftest.c -tlsCbcVerify.c -tlsprf_selftest.c -tlsprf.c -xmss.c -xtsaes.c -"; - -fn compile_symcrypt_static(lib_name: &str, options: &SymCryptOptions) -> std::io::Result<()> { - // Compile intermediates required this is currently only required for x86_64_unknown_linux_gnu - let (already_compiled_files, intermediates) = compile_symcrypt_intermediates(options); - - // Convert already compiled files to a HashSet for faster lookups - let already_compiled_set: HashSet<&str> = already_compiled_files.iter().cloned().collect(); - - // Prepares list of files to be compiled, excluding already compiled files for x86_64_unknown_linux_gnu - let mut base_files: Vec<&'static str> = SOURCES_COMMON - .lines() - .map(str::trim) // Trim once instead of inside filter - .filter(|line| { - !line.is_empty() && !line.starts_with("#") && !already_compiled_set.contains(line) - }) - .collect(); - - base_files.push("env_generic.c"); // symcrypt_generic - - // Add module-specific files for each target - let mut module_files = vec![]; - - match options.triple() { - Triple::x86_64_pc_windows_msvc | Triple::aarch64_pc_windows_msvc => { - base_files.push("env_windowsUserModeWin8_1.c"); - base_files.push("IEEE802_11SaeCustom.c"); - module_files.push("inc/static_WindowsDefault.c"); - } - Triple::x86_64_unknown_linux_gnu => { - base_files.push("linux/intrinsics.c"); // Only needed for x86_64_unknown_linux_gnu - base_files.push("env_posixUserMode.c"); - module_files.push("inc/static_LinuxDefault.c"); - } - Triple::aarch64_unknown_linux_gnu => { - base_files.push("env_posixUserMode.c"); - module_files.push("inc/static_LinuxDefault.c"); - } - } - - // Add assembly pre generated ASM files to be compiled - // ASM files come from lib/CMakeLists.txt - let asm_files = match options.triple() { - Triple::x86_64_pc_windows_msvc => vec![ - "aesasm-gas.asm", - "fdef_asm-gas.asm", - "fdef369_asm-gas.asm", - "fdef_mulx-gas.asm", - "wipe-gas.asm", - "sha256xmm_asm-gas.asm", - "sha256ymm_asm-gas.asm", - "sha512ymm_asm-gas.asm", - "sha512ymm_avx512vl_asm-gas.asm", - ], - Triple::aarch64_pc_windows_msvc => { - vec!["fdef_asm-gas.asm", "fdef369_asm-gas.asm", "wipe-gas.asm"] - } - Triple::x86_64_unknown_linux_gnu => vec![ - "aesasm-gas.asm", - "fdef_asm-gas.asm", - "fdef369_asm-gas.asm", - "fdef_mulx-gas.asm", - "wipe-gas.asm", - "sha256xmm_asm-gas.asm", - "sha256ymm_asm-gas.asm", - "sha512ymm_asm-gas.asm", - "sha512ymm_avx512vl_asm-gas.asm", - ], - Triple::aarch64_unknown_linux_gnu => { - vec!["fdef_asm-gas.asm", "fdef369_asm-gas.asm", "wipe-gas.asm"] - } - }; - - // Pre-Configure the cc compiler based on the target triple - let mut cc = options.preconfigure_cc(); - - // Add in the intermediates that were previously compiled, will be empty for most targets - cc.objects(intermediates); - - // Add base files to be compiled - for file in base_files { - cc.file(format!("{SOURCE_DIR}/{file}")); - } - - // Add assembly files to be compiled - if options.use_asm() { - for file in asm_files { - cc.file(format!( - "{SOURCE_DIR}/asm/{}/{file}", // TODO: replace with right file path when ASM checked in. - options.triple.to_triple() - )); - } - } - - // Add module-specific files to be compiled - cc.files(module_files); - - println!("Files to compile: {}", cc.get_files().count()); - - // Compiles all files and returns the compiled library - cc.compile(lib_name); - - Ok(()) -} - -// Special compile files for x86_64_unknown_linux_gnu -const X86_64_LINUX_CUSTOM_COMPILE_FILES: &str = r#" -aes-ymm.c "-mavx;-mavx2;-mvaes;-mvpclmulqdq" -sha256Par-ymm.c "-mavx;-mavx2" -sha512Par-ymm.c "-mavx;-mavx2" -sha256-xmm.c "-mssse3" -sha256-ymm.c "-mavx;-mavx2;-mbmi2" -sha512-ymm.c "-mavx;-mavx2;-mbmi2" -"#; - -//set_source_files_properties(sha512-ymm.c PROPERTIES COMPILE_OPTIONS "-mavx;-mavx2;-mbmi2") - -/// Compiles the SymCrypt custom intermediates -/// -/// Currently this is only required for x86_64_unknown_linux_gnu, -/// but can be modified to include other targets as needed. -/// -/// If the target is not `x86_64_unknown_linux_gnu`, it returns empty vectors -fn compile_symcrypt_intermediates( - symcrypt_options: &SymCryptOptions, -) -> (Vec<&'static str>, Vec) { - let mut files = vec![]; - let mut intermediates = vec![]; - - // Only compile intermediates for x86_64_unknown_linux_gnu. - // Can modify with additional targets as needed. - if symcrypt_options.triple() != Triple::x86_64_unknown_linux_gnu { - return (files, intermediates); // No intermediates to compile - } - - // Fetch preconfigured cc based on the target triple. - let mut cc = symcrypt_options.preconfigure_cc(); - - for line in X86_64_LINUX_CUSTOM_COMPILE_FILES.lines() { - if line.trim().is_empty() || line.trim().starts_with("#") { - continue; - } - - // Example of parts: - // [aes-ymm.c, "-mavx;-mavx2;-mvaes;-mvpclmulqdq"] - let parts: Vec<&str> = line.split_whitespace().collect(); - if parts.len() < 2 { - continue; - } - - let file = parts[0]; - println!("Compiling {file} with custom options: {}", parts[1]); - - // Isolate the compile options - let options = parts[1] - .trim_matches('"') - .split(';') - .filter(|s| !s.is_empty()); - - // Push intermediates to the cc object to be compiled - cc.file(format!("{SOURCE_DIR}/{file}")); - for option in options { - cc.flag(option); - } - - // Add the file to the list of files to be replaced by compiled intermediates. - files.push(file); - } - - // Use cc's compile_intermediates() to batch generate intermediate files without linking - let mut result = cc.compile_intermediates(); - intermediates.append(&mut result); - - // Return files to be replaced by intermediates. - (files, intermediates) -} diff --git a/symcrypt-sys/build/triple.rs b/symcrypt-sys/build/triple.rs deleted file mode 100644 index 590a45a3..00000000 --- a/symcrypt-sys/build/triple.rs +++ /dev/null @@ -1,34 +0,0 @@ -#[allow(non_camel_case_types)] -#[derive(Debug, PartialEq, Eq, Clone)] - -/// The `Triple` enum represents the target architecture and operating system. -pub enum Triple { - x86_64_pc_windows_msvc, - aarch64_pc_windows_msvc, - x86_64_unknown_linux_gnu, - aarch64_unknown_linux_gnu, -} - -impl Triple { - pub fn get_target_triple() -> Self { - // Extract target OS and architecture from environment variables - let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap(); - let target_arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap(); - - match (target_os.as_str(), target_arch.as_str()) { - ("windows", "x86_64") => Triple::x86_64_pc_windows_msvc, - ("windows", "aarch64") => Triple::aarch64_pc_windows_msvc, - ("linux", "x86_64") => Triple::x86_64_unknown_linux_gnu, - ("linux", "aarch64") => Triple::aarch64_unknown_linux_gnu, - _ => panic!("unsupported target. OS: {target_os}, Arch: {target_arch}"), - } - } - pub fn to_triple(&self) -> &'static str { - match self { - Triple::x86_64_pc_windows_msvc => "x86_64-pc-windows-msvc", - Triple::aarch64_pc_windows_msvc => "aarch64-pc-windows-msvc", - Triple::x86_64_unknown_linux_gnu => "x86_64-unknown-linux-gnu", - Triple::aarch64_unknown_linux_gnu => "aarch64-unknown-linux-gnu", - } - } -} diff --git a/symcrypt-sys/inc/buildInfo.h b/symcrypt-sys/inc/buildInfo.h deleted file mode 100644 index c93659e2..00000000 --- a/symcrypt-sys/inc/buildInfo.h +++ /dev/null @@ -1,8 +0,0 @@ -#include "symcrypt_internal_shared.inc" - -#define _SYMCRYPT_STRING_INT(a) #a -#define _SYMCRYPT_STRING(a) _SYMCRYPT_STRING_INT(a) -#define SYMCRYPT_BUILD_INFO_BRANCH "" -#define SYMCRYPT_BUILD_INFO_COMMIT "2025-01-28T01:44:15+01:00_53be637" -#define SYMCRYPT_BUILD_INFO_VERSION _SYMCRYPT_STRING(SYMCRYPT_CODE_VERSION_API) "." _SYMCRYPT_STRING(SYMCRYPT_CODE_VERSION_MINOR) "." _SYMCRYPT_STRING(SYMCRYPT_CODE_VERSION_PATCH) -#define SYMCRYPT_BUILD_INFO_TIMESTAMP "2025-02-07T14:10:46" diff --git a/symcrypt-sys/inc/static_LinuxDefault.c b/symcrypt-sys/inc/static_LinuxDefault.c deleted file mode 100644 index 7f0a9bad..00000000 --- a/symcrypt-sys/inc/static_LinuxDefault.c +++ /dev/null @@ -1,63 +0,0 @@ -// -// static_LinuxDefault.c -// Default implementation for Linux static shared object. -// -// Copyright (c) Microsoft Corporation. Licensed under the MIT license. -// - -#include -#include -#include -#include - -#include "wrapper.h" -#include -#include - -SYMCRYPT_ENVIRONMENT_POSIX_USERMODE; - -PVOID -SYMCRYPT_CALL -SymCryptCallbackAlloc( SIZE_T nBytes ) -{ - // aligned_alloc requires size to be integer multiple of alignment - SIZE_T cbAllocation = (nBytes + (SYMCRYPT_ASYM_ALIGN_VALUE - 1)) & ~(SYMCRYPT_ASYM_ALIGN_VALUE - 1); - - return aligned_alloc(SYMCRYPT_ASYM_ALIGN_VALUE, cbAllocation); -} - -VOID -SYMCRYPT_CALL -SymCryptCallbackFree( VOID * pMem ) -{ - free( pMem ); -} - -// From Linux docs on getrandom: -// RETURN VALUE top -// On success, getrandom() returns the number of bytes that were -// copied to the buffer buf. This may be less than the number of -// bytes requested via buflen if either GRND_RANDOM was specified in -// flags and insufficient entropy was present in the random source or -// the system call was interrupted by a signal. -// On error, -1 is returned, and errno is set to indicate the error. -SYMCRYPT_ERROR -SYMCRYPT_CALL -SymCryptCallbackRandom(unsigned char *pbBuffer, size_t cbBuffer) -{ - size_t total_received = 0; - ssize_t result; - - while (total_received < cbBuffer) { - result = getrandom(pbBuffer + total_received, cbBuffer - total_received, 0); - if (result < 0) { - if (errno == EINTR) { - // Buffer is not yet full, continue to get more entropy - continue; - } - return SYMCRYPT_EXTERNAL_FAILURE; - } - total_received += (size_t)result; - } - return SYMCRYPT_NO_ERROR; -} diff --git a/symcrypt-sys/inc/static_WindowsDefault.c b/symcrypt-sys/inc/static_WindowsDefault.c deleted file mode 100644 index 6d9e618c..00000000 --- a/symcrypt-sys/inc/static_WindowsDefault.c +++ /dev/null @@ -1,43 +0,0 @@ -// -// static_WindowsDefault.c -// Default implementation for Windows static shared object. -// -// Copyright (c) Microsoft Corporation. Licensed under the MIT license. -// - -#define NT_SUCCESS(Status) (((NTSTATUS)(Status)) >= 0) - -// Ensure that windows.h doesn't re-define the status_* symbols -#define WIN32_NO_STATUS -#include -#include -#include -#include -#include - -SYMCRYPT_ENVIRONMENT_WINDOWS_USERMODE_LATEST; - -PVOID -SYMCRYPT_CALL -SymCryptCallbackAlloc( SIZE_T nBytes ) -{ - return _aligned_malloc( nBytes, SYMCRYPT_ASYM_ALIGN_VALUE ); -} - -VOID -SYMCRYPT_CALL -SymCryptCallbackFree(PVOID ptr) -{ - _aligned_free( ptr ); -} - -SYMCRYPT_ERROR -SYMCRYPT_CALL -SymCryptCallbackRandom( - _Out_writes_bytes_( cbBuffer ) PBYTE pbBuffer, - SIZE_T cbBuffer ) -{ - NTSTATUS status = BCryptGenRandom( BCRYPT_RNG_ALG_HANDLE, pbBuffer, (ULONG) cbBuffer, 0 ); - - return NT_SUCCESS( status ) ? SYMCRYPT_NO_ERROR : SYMCRYPT_EXTERNAL_FAILURE; -} diff --git a/symcrypt-sys/inc/symcrypt_internal_shared.inc b/symcrypt-sys/inc/symcrypt_internal_shared.inc index f60f9924..f89b662f 100644 --- a/symcrypt-sys/inc/symcrypt_internal_shared.inc +++ b/symcrypt-sys/inc/symcrypt_internal_shared.inc @@ -1,33 +1,33 @@ -// -// symcrypt_internal_shared.inc -// Copyright (c) Microsoft Corporation. Licensed under the MIT license. -// -// This is the file that contains the SymCrypt version information and defines SYMCRYPT_DEBUG. -// It is included in both C and ASM such that the values are the same on both sides. -// We use the C preprocessor to set ASM constants, as we already need to use the C preprocessor for -// symcryptasm processing (see scripts/symcryptasm_processor.py). -// -// In previous releases we had a numbering system with major/minor version number. -// This worked well with the sequential servicing imposed by SourceDepot. -// With the switch to Git this no longer works due to having multiple branches. -// We move to having the version here only specify the API and minor version number -// These will NOT be changed for every build. The API version only changes when there are -// breaking changes to the API in symcrypt.h. (Note: symcrypt_low_level.h is not stable and can change -// at any time.) The minor version is changed at regular intervals, but not necessarily at -// every build of the library. -// -// Separate from these numbers the build system includes information about the branch, -// last commit, build time, etc. -// -// The API numbering starts at 100 to avoid number conflicts with the old system. -// - -#define SYMCRYPT_CODE_VERSION_API 103 -#define SYMCRYPT_CODE_VERSION_MINOR 8 -#define SYMCRYPT_CODE_VERSION_PATCH 0 - -#if defined(DBG) -#define SYMCRYPT_DEBUG 1 -#else -#define SYMCRYPT_DEBUG 0 -#endif +// +// symcrypt_internal_shared.inc +// Copyright (c) Microsoft Corporation. Licensed under the MIT license. +// +// This is the file that contains the SymCrypt version information and defines SYMCRYPT_DEBUG. +// It is included in both C and ASM such that the values are the same on both sides. +// We use the C preprocessor to set ASM constants, as we already need to use the C preprocessor for +// symcryptasm processing (see scripts/symcryptasm_processor.py). +// +// In previous releases we had a numbering system with major/minor version number. +// This worked well with the sequential servicing imposed by SourceDepot. +// With the switch to Git this no longer works due to having multiple branches. +// We move to having the version here only specify the API and minor version number +// These will NOT be changed for every build. The API version only changes when there are +// breaking changes to the API in symcrypt.h. (Note: symcrypt_low_level.h is not stable and can change +// at any time.) The minor version is changed at regular intervals, but not necessarily at +// every build of the library. +// +// Separate from these numbers the build system includes information about the branch, +// last commit, build time, etc. +// +// The API numbering starts at 100 to avoid number conflicts with the old system. +// + +#define SYMCRYPT_CODE_VERSION_API 103 +#define SYMCRYPT_CODE_VERSION_MINOR 8 +#define SYMCRYPT_CODE_VERSION_PATCH 0 + +#if defined(DBG) +#define SYMCRYPT_DEBUG 1 +#else +#define SYMCRYPT_DEBUG 0 +#endif diff --git a/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs b/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs index 4e013c7e..66e65596 100644 --- a/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs +++ b/symcrypt-sys/src/bindings/aarch64_pc_windows_msvc.rs @@ -71,32 +71,17 @@ pub struct _SYMCRYPT_MD2_CHAINING_STATE { pub C: [BYTE; 16usize], pub X: [BYTE; 48usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_MD2_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD2_CHAINING_STATE>(), - 64usize, - "Size of _SYMCRYPT_MD2_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD2_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD2_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).C) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::C" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::X" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MD2_CHAINING_STATE"] + [::std::mem::size_of::<_SYMCRYPT_MD2_CHAINING_STATE>() - 64usize]; + ["Alignment of _SYMCRYPT_MD2_CHAINING_STATE"] + [::std::mem::align_of::<_SYMCRYPT_MD2_CHAINING_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::C"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_CHAINING_STATE, C) - 0usize]; + ["Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::X"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_CHAINING_STATE, X) - 16usize]; +}; impl Default for _SYMCRYPT_MD2_CHAINING_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -118,51 +103,23 @@ pub struct _SYMCRYPT_MD2_STATE { pub buffer: [BYTE; 16usize], pub chain: SYMCRYPT_MD2_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MD2_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD2_STATE>(), - 112usize, - "Size of _SYMCRYPT_MD2_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD2_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD2_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD2_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MD2_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MD2_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MD2_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MD2_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_MD2_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MD2_STATE"][::std::mem::size_of::<_SYMCRYPT_MD2_STATE>() - 112usize]; + ["Alignment of _SYMCRYPT_MD2_STATE"][::std::mem::align_of::<_SYMCRYPT_MD2_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_MD2_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_MD2_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_MD2_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_MD2_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_MD2_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_MD2_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_STATE, chain) - 48usize]; +}; impl Default for _SYMCRYPT_MD2_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -179,27 +136,15 @@ pub type SYMCRYPT_MD2_STATE = _SYMCRYPT_MD2_STATE; pub struct _SYMCRYPT_MD4_CHAINING_STATE { pub H: [UINT32; 4usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_MD4_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD4_CHAINING_STATE>(), - 16usize, - "Size of _SYMCRYPT_MD4_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD4_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD4_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD4_CHAINING_STATE::H" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MD4_CHAINING_STATE"] + [::std::mem::size_of::<_SYMCRYPT_MD4_CHAINING_STATE>() - 16usize]; + ["Alignment of _SYMCRYPT_MD4_CHAINING_STATE"] + [::std::mem::align_of::<_SYMCRYPT_MD4_CHAINING_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_MD4_CHAINING_STATE::H"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_CHAINING_STATE, H) - 0usize]; +}; pub type SYMCRYPT_MD4_CHAINING_STATE = _SYMCRYPT_MD4_CHAINING_STATE; #[repr(C)] #[repr(align(16))] @@ -212,51 +157,23 @@ pub struct _SYMCRYPT_MD4_STATE { pub buffer: [BYTE; 64usize], pub chain: SYMCRYPT_MD4_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MD4_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD4_STATE>(), - 112usize, - "Size of _SYMCRYPT_MD4_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD4_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD4_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD4_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MD4_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MD4_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MD4_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MD4_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_MD4_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MD4_STATE"][::std::mem::size_of::<_SYMCRYPT_MD4_STATE>() - 112usize]; + ["Alignment of _SYMCRYPT_MD4_STATE"][::std::mem::align_of::<_SYMCRYPT_MD4_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_MD4_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_MD4_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_MD4_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_MD4_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_MD4_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_MD4_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_STATE, chain) - 96usize]; +}; impl Default for _SYMCRYPT_MD4_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -273,27 +190,15 @@ pub type SYMCRYPT_MD4_STATE = _SYMCRYPT_MD4_STATE; pub struct _SYMCRYPT_MD5_CHAINING_STATE { pub H: [UINT32; 4usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_MD5_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD5_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD5_CHAINING_STATE>(), - 16usize, - "Size of _SYMCRYPT_MD5_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD5_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD5_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD5_CHAINING_STATE::H" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MD5_CHAINING_STATE"] + [::std::mem::size_of::<_SYMCRYPT_MD5_CHAINING_STATE>() - 16usize]; + ["Alignment of _SYMCRYPT_MD5_CHAINING_STATE"] + [::std::mem::align_of::<_SYMCRYPT_MD5_CHAINING_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_MD5_CHAINING_STATE::H"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_CHAINING_STATE, H) - 0usize]; +}; pub type SYMCRYPT_MD5_CHAINING_STATE = _SYMCRYPT_MD5_CHAINING_STATE; #[repr(C)] #[repr(align(16))] @@ -306,51 +211,23 @@ pub struct _SYMCRYPT_MD5_STATE { pub buffer: [BYTE; 64usize], pub chain: SYMCRYPT_MD5_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MD5_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD5_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD5_STATE>(), - 112usize, - "Size of _SYMCRYPT_MD5_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD5_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD5_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD5_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MD5_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MD5_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MD5_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MD5_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_MD5_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MD5_STATE"][::std::mem::size_of::<_SYMCRYPT_MD5_STATE>() - 112usize]; + ["Alignment of _SYMCRYPT_MD5_STATE"][::std::mem::align_of::<_SYMCRYPT_MD5_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_MD5_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_MD5_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_MD5_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_MD5_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_MD5_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_MD5_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_STATE, chain) - 96usize]; +}; impl Default for _SYMCRYPT_MD5_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -369,27 +246,15 @@ pub type PCSYMCRYPT_MD5_STATE = *const SYMCRYPT_MD5_STATE; pub struct _SYMCRYPT_SHA1_CHAINING_STATE { pub H: [UINT32; 5usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA1_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA1_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA1_CHAINING_STATE>(), - 32usize, - "Size of _SYMCRYPT_SHA1_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA1_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA1_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA1_CHAINING_STATE::H" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA1_CHAINING_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA1_CHAINING_STATE>() - 32usize]; + ["Alignment of _SYMCRYPT_SHA1_CHAINING_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA1_CHAINING_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA1_CHAINING_STATE::H"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_CHAINING_STATE, H) - 0usize]; +}; pub type SYMCRYPT_SHA1_CHAINING_STATE = _SYMCRYPT_SHA1_CHAINING_STATE; #[repr(C)] #[repr(align(16))] @@ -402,51 +267,23 @@ pub struct _SYMCRYPT_SHA1_STATE { pub buffer: [BYTE; 64usize], pub chain: SYMCRYPT_SHA1_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA1_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA1_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA1_STATE>(), - 128usize, - "Size of _SYMCRYPT_SHA1_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA1_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA1_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA1_STATE"][::std::mem::size_of::<_SYMCRYPT_SHA1_STATE>() - 128usize]; + ["Alignment of _SYMCRYPT_SHA1_STATE"][::std::mem::align_of::<_SYMCRYPT_SHA1_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA1_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA1_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA1_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA1_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA1_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA1_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_STATE, chain) - 96usize]; +}; impl Default for _SYMCRYPT_SHA1_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -465,27 +302,15 @@ pub type PCSYMCRYPT_SHA1_STATE = *const SYMCRYPT_SHA1_STATE; pub struct _SYMCRYPT_SHA256_CHAINING_STATE { pub H: [UINT32; 8usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA256_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA256_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA256_CHAINING_STATE>(), - 32usize, - "Size of _SYMCRYPT_SHA256_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA256_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA256_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA256_CHAINING_STATE::H" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA256_CHAINING_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA256_CHAINING_STATE>() - 32usize]; + ["Alignment of _SYMCRYPT_SHA256_CHAINING_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA256_CHAINING_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA256_CHAINING_STATE::H"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_CHAINING_STATE, H) - 0usize]; +}; pub type SYMCRYPT_SHA256_CHAINING_STATE = _SYMCRYPT_SHA256_CHAINING_STATE; #[repr(C)] #[repr(align(16))] @@ -498,52 +323,24 @@ pub struct _SYMCRYPT_SHA256_STATE { pub buffer: [BYTE; 64usize], pub chain: SYMCRYPT_SHA256_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA256_STATE>(), - 128usize, - "Size of _SYMCRYPT_SHA256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA256_STATE"][::std::mem::size_of::<_SYMCRYPT_SHA256_STATE>() - 128usize]; + ["Alignment of _SYMCRYPT_SHA256_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA256_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA256_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA256_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA256_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA256_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA256_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA256_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_STATE, chain) - 96usize]; +}; impl Default for _SYMCRYPT_SHA256_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -567,52 +364,24 @@ pub struct _SYMCRYPT_SHA224_STATE { pub buffer: [BYTE; 64usize], pub chain: SYMCRYPT_SHA256_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA224_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA224_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA224_STATE>(), - 128usize, - "Size of _SYMCRYPT_SHA224_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA224_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA224_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA224_STATE"][::std::mem::size_of::<_SYMCRYPT_SHA224_STATE>() - 128usize]; + ["Alignment of _SYMCRYPT_SHA224_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA224_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA224_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA224_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA224_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA224_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA224_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA224_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA224_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA224_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA224_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA224_STATE, chain) - 96usize]; +}; impl Default for _SYMCRYPT_SHA224_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -629,27 +398,15 @@ pub type SYMCRYPT_SHA224_STATE = _SYMCRYPT_SHA224_STATE; pub struct _SYMCRYPT_SHA512_CHAINING_STATE { pub H: [UINT64; 8usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_CHAINING_STATE>(), - 64usize, - "Size of _SYMCRYPT_SHA512_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_CHAINING_STATE::H" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA512_CHAINING_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA512_CHAINING_STATE>() - 64usize]; + ["Alignment of _SYMCRYPT_SHA512_CHAINING_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA512_CHAINING_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_CHAINING_STATE::H"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_CHAINING_STATE, H) - 0usize]; +}; pub type SYMCRYPT_SHA512_CHAINING_STATE = _SYMCRYPT_SHA512_CHAINING_STATE; #[repr(C)] #[repr(align(16))] @@ -662,52 +419,24 @@ pub struct _SYMCRYPT_SHA512_STATE { pub buffer: [BYTE; 128usize], pub chain: SYMCRYPT_SHA512_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA512_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA512_STATE"][::std::mem::size_of::<_SYMCRYPT_SHA512_STATE>() - 224usize]; + ["Alignment of _SYMCRYPT_SHA512_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA512_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA512_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA512_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA512_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA512_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_STATE, chain) - 160usize]; +}; impl Default for _SYMCRYPT_SHA512_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -731,52 +460,24 @@ pub struct _SYMCRYPT_SHA384_STATE { pub buffer: [BYTE; 128usize], pub chain: SYMCRYPT_SHA512_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA384_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA384_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA384_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA384_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA384_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA384_STATE"][::std::mem::size_of::<_SYMCRYPT_SHA384_STATE>() - 224usize]; + ["Alignment of _SYMCRYPT_SHA384_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA384_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA384_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA384_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA384_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA384_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA384_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA384_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA384_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA384_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA384_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA384_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA384_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA384_STATE, chain) - 160usize]; +}; impl Default for _SYMCRYPT_SHA384_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -800,52 +501,25 @@ pub struct _SYMCRYPT_SHA512_224_STATE { pub buffer: [BYTE; 128usize], pub chain: SYMCRYPT_SHA512_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_224_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_224_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_224_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA512_224_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_224_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_224_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA512_224_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA512_224_STATE>() - 224usize]; + ["Alignment of _SYMCRYPT_SHA512_224_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA512_224_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_224_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_224_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA512_224_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_224_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_224_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_224_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA512_224_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_224_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA512_224_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_224_STATE, chain) - 160usize]; +}; impl Default for _SYMCRYPT_SHA512_224_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -867,52 +541,25 @@ pub struct _SYMCRYPT_SHA512_256_STATE { pub buffer: [BYTE; 128usize], pub chain: SYMCRYPT_SHA512_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_256_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA512_256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA512_256_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA512_256_STATE>() - 224usize]; + ["Alignment of _SYMCRYPT_SHA512_256_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA512_256_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_256_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_256_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA512_256_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_256_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_256_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_256_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA512_256_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_256_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA512_256_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_256_STATE, chain) - 160usize]; +}; impl Default for _SYMCRYPT_SHA512_256_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -933,47 +580,22 @@ pub struct _SYMCRYPT_KECCAK_STATE { pub paddingValue: UINT8, pub squeezeMode: BOOLEAN, } -#[test] -fn bindgen_test_layout__SYMCRYPT_KECCAK_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KECCAK_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KECCAK_STATE>(), - 224usize, - "Size of _SYMCRYPT_KECCAK_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KECCAK_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_KECCAK_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::state" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, - 200usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::inputBlockSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateIndex) as usize - ptr as usize }, - 204usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::stateIndex" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).paddingValue) as usize - ptr as usize }, - 208usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::paddingValue" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).squeezeMode) as usize - ptr as usize }, - 209usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::squeezeMode" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_KECCAK_STATE"][::std::mem::size_of::<_SYMCRYPT_KECCAK_STATE>() - 224usize]; + ["Alignment of _SYMCRYPT_KECCAK_STATE"] + [::std::mem::align_of::<_SYMCRYPT_KECCAK_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_KECCAK_STATE::state"] + [::std::mem::offset_of!(_SYMCRYPT_KECCAK_STATE, state) - 0usize]; + ["Offset of field: _SYMCRYPT_KECCAK_STATE::inputBlockSize"] + [::std::mem::offset_of!(_SYMCRYPT_KECCAK_STATE, inputBlockSize) - 200usize]; + ["Offset of field: _SYMCRYPT_KECCAK_STATE::stateIndex"] + [::std::mem::offset_of!(_SYMCRYPT_KECCAK_STATE, stateIndex) - 204usize]; + ["Offset of field: _SYMCRYPT_KECCAK_STATE::paddingValue"] + [::std::mem::offset_of!(_SYMCRYPT_KECCAK_STATE, paddingValue) - 208usize]; + ["Offset of field: _SYMCRYPT_KECCAK_STATE::squeezeMode"] + [::std::mem::offset_of!(_SYMCRYPT_KECCAK_STATE, squeezeMode) - 209usize]; +}; pub type SYMCRYPT_KECCAK_STATE = _SYMCRYPT_KECCAK_STATE; #[repr(C)] #[repr(align(16))] @@ -982,32 +604,17 @@ pub struct _SYMCRYPT_SHA3_224_STATE { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_224_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_224_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_224_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_224_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_224_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_224_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_224_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_224_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA3_224_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA3_224_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_SHA3_224_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA3_224_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA3_224_STATE::ks"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_224_STATE, ks) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA3_224_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_224_STATE, magic) - 224usize]; +}; pub type SYMCRYPT_SHA3_224_STATE = _SYMCRYPT_SHA3_224_STATE; #[repr(C)] #[repr(align(16))] @@ -1016,32 +623,17 @@ pub struct _SYMCRYPT_SHA3_256_STATE { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_256_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_256_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_256_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA3_256_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA3_256_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_SHA3_256_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA3_256_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA3_256_STATE::ks"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_256_STATE, ks) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA3_256_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_256_STATE, magic) - 224usize]; +}; pub type SYMCRYPT_SHA3_256_STATE = _SYMCRYPT_SHA3_256_STATE; pub type PSYMCRYPT_SHA3_256_STATE = *mut _SYMCRYPT_SHA3_256_STATE; pub type PCSYMCRYPT_SHA3_256_STATE = *const SYMCRYPT_SHA3_256_STATE; @@ -1052,32 +644,17 @@ pub struct _SYMCRYPT_SHA3_384_STATE { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_384_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_384_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_384_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_384_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_384_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_384_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_384_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA3_384_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA3_384_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_SHA3_384_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA3_384_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA3_384_STATE::ks"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_384_STATE, ks) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA3_384_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_384_STATE, magic) - 224usize]; +}; pub type SYMCRYPT_SHA3_384_STATE = _SYMCRYPT_SHA3_384_STATE; pub type PSYMCRYPT_SHA3_384_STATE = *mut _SYMCRYPT_SHA3_384_STATE; pub type PCSYMCRYPT_SHA3_384_STATE = *const SYMCRYPT_SHA3_384_STATE; @@ -1088,32 +665,17 @@ pub struct _SYMCRYPT_SHA3_512_STATE { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_512_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_512_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_512_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_512_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_512_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_512_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_512_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA3_512_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA3_512_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_SHA3_512_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA3_512_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA3_512_STATE::ks"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_512_STATE, ks) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA3_512_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_512_STATE, magic) - 224usize]; +}; pub type SYMCRYPT_SHA3_512_STATE = _SYMCRYPT_SHA3_512_STATE; pub type PSYMCRYPT_SHA3_512_STATE = *mut _SYMCRYPT_SHA3_512_STATE; pub type PCSYMCRYPT_SHA3_512_STATE = *const SYMCRYPT_SHA3_512_STATE; @@ -1124,32 +686,17 @@ pub struct _SYMCRYPT_KMAC128_EXPANDED_KEY { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_KMAC128_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC128_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(), - 240usize, - "Size of _SYMCRYPT_KMAC128_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_KMAC128_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_KMAC128_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>() - 240usize]; + ["Alignment of _SYMCRYPT_KMAC128_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::ks"] + [::std::mem::offset_of!(_SYMCRYPT_KMAC128_EXPANDED_KEY, ks) - 0usize]; + ["Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_KMAC128_EXPANDED_KEY, magic) - 224usize]; +}; pub type SYMCRYPT_KMAC128_EXPANDED_KEY = _SYMCRYPT_KMAC128_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] @@ -1158,32 +705,17 @@ pub struct _SYMCRYPT_KMAC256_EXPANDED_KEY { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_KMAC256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(), - 240usize, - "Size of _SYMCRYPT_KMAC256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_KMAC256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_KMAC256_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>() - 240usize]; + ["Alignment of _SYMCRYPT_KMAC256_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::ks"] + [::std::mem::offset_of!(_SYMCRYPT_KMAC256_EXPANDED_KEY, ks) - 0usize]; + ["Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_KMAC256_EXPANDED_KEY, magic) - 224usize]; +}; pub type SYMCRYPT_KMAC256_EXPANDED_KEY = _SYMCRYPT_KMAC256_EXPANDED_KEY; #[repr(C)] #[derive(Debug, Copy, Clone)] @@ -1191,31 +723,15 @@ pub struct _SYMCRYPT_OID { pub cbOID: UINT32, pub pbOID: PCBYTE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_OID() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_OID> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_OID>(), - 16usize, - "Size of _SYMCRYPT_OID" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_OID>(), - 8usize, - "Alignment of _SYMCRYPT_OID" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbOID) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_OID::cbOID" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbOID) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_OID::pbOID" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_OID"][::std::mem::size_of::<_SYMCRYPT_OID>() - 16usize]; + ["Alignment of _SYMCRYPT_OID"][::std::mem::align_of::<_SYMCRYPT_OID>() - 8usize]; + ["Offset of field: _SYMCRYPT_OID::cbOID"] + [::std::mem::offset_of!(_SYMCRYPT_OID, cbOID) - 0usize]; + ["Offset of field: _SYMCRYPT_OID::pbOID"] + [::std::mem::offset_of!(_SYMCRYPT_OID, pbOID) - 8usize]; +}; impl Default for _SYMCRYPT_OID { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1227,36 +743,36 @@ impl Default for _SYMCRYPT_OID { } pub type SYMCRYPT_OID = _SYMCRYPT_OID; pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID; -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize]; } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize]; } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize]; } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize]; } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize]; } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize]; } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize]; } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize]; } #[repr(C)] @@ -1278,91 +794,39 @@ pub union _SYMCRYPT_HASH_STATE { pub sha3_384State: SYMCRYPT_SHA3_384_STATE, pub sha3_512State: SYMCRYPT_SHA3_512_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HASH_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HASH_STATE>(), - 240usize, - "Size of _SYMCRYPT_HASH_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HASH_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HASH_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md2State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::md2State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md4State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::md4State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md5State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::md5State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha1State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha1State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha224State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha224State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha256State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha256State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha384State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha384State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha512State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_224State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha512_224State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_256State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha512_256State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_224State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_224State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_256State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_256State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_384State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_384State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_512State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_512State" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HASH_STATE"][::std::mem::size_of::<_SYMCRYPT_HASH_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_HASH_STATE"][::std::mem::align_of::<_SYMCRYPT_HASH_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::md2State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, md2State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::md4State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, md4State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::md5State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, md5State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha1State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha1State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha224State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha224State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha256State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha256State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha384State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha384State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha512State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha512State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha512_224State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha512_224State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha512_256State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha512_256State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha3_224State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha3_224State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha3_256State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha3_256State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha3_384State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha3_384State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha3_512State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha3_512State) - 0usize]; +}; impl Default for _SYMCRYPT_HASH_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1400,71 +864,31 @@ pub struct _SYMCRYPT_HASH { pub chainOffset: UINT32, pub chainSize: UINT32, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HASH() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HASH>(), - 64usize, - "Size of _SYMCRYPT_HASH" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HASH>(), - 16usize, - "Alignment of _SYMCRYPT_HASH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).initFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH::initFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_HASH::appendFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_HASH::resultFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendBlockFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_HASH::appendBlockFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateCopyFunc) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HASH::stateCopyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateSize) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_HASH::stateSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultSize) as usize - ptr as usize }, - 44usize, - "Offset of field: _SYMCRYPT_HASH::resultSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_HASH::inputBlockSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chainOffset) as usize - ptr as usize }, - 52usize, - "Offset of field: _SYMCRYPT_HASH::chainOffset" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chainSize) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_HASH::chainSize" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HASH"][::std::mem::size_of::<_SYMCRYPT_HASH>() - 64usize]; + ["Alignment of _SYMCRYPT_HASH"][::std::mem::align_of::<_SYMCRYPT_HASH>() - 16usize]; + ["Offset of field: _SYMCRYPT_HASH::initFunc"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, initFunc) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH::appendFunc"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, appendFunc) - 8usize]; + ["Offset of field: _SYMCRYPT_HASH::resultFunc"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, resultFunc) - 16usize]; + ["Offset of field: _SYMCRYPT_HASH::appendBlockFunc"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, appendBlockFunc) - 24usize]; + ["Offset of field: _SYMCRYPT_HASH::stateCopyFunc"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, stateCopyFunc) - 32usize]; + ["Offset of field: _SYMCRYPT_HASH::stateSize"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, stateSize) - 40usize]; + ["Offset of field: _SYMCRYPT_HASH::resultSize"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, resultSize) - 44usize]; + ["Offset of field: _SYMCRYPT_HASH::inputBlockSize"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, inputBlockSize) - 48usize]; + ["Offset of field: _SYMCRYPT_HASH::chainOffset"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, chainOffset) - 52usize]; + ["Offset of field: _SYMCRYPT_HASH::chainSize"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, chainSize) - 56usize]; +}; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] @@ -1473,37 +897,19 @@ pub struct _SYMCRYPT_HMAC_MD5_EXPANDED_KEY { pub outerState: SYMCRYPT_MD5_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), - 48usize, - "Size of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>() - 48usize]; + ["Alignment of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_MD5_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_MD5_EXPANDED_KEY, outerState) - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_MD5_EXPANDED_KEY, magic) - 32usize]; +}; pub type SYMCRYPT_HMAC_MD5_EXPANDED_KEY = _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; pub type PSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; pub type PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *const SYMCRYPT_HMAC_MD5_EXPANDED_KEY; @@ -1515,37 +921,19 @@ pub struct _SYMCRYPT_HMAC_MD5_STATE { pub pKey: PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_MD5_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_STATE>(), - 128usize, - "Size of _SYMCRYPT_HMAC_MD5_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_MD5_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 112usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 120usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_MD5_STATE"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_STATE>() - 128usize]; + ["Alignment of _SYMCRYPT_HMAC_MD5_STATE"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_MD5_STATE::hash"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_MD5_STATE, hash) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_MD5_STATE::pKey"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_MD5_STATE, pKey) - 112usize]; + ["Offset of field: _SYMCRYPT_HMAC_MD5_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_MD5_STATE, magic) - 120usize]; +}; impl Default for _SYMCRYPT_HMAC_MD5_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1566,37 +954,19 @@ pub struct _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA1_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(), - 80usize, - "Size of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>() - 80usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY, outerState) - 32usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY, magic) - 64usize]; +}; pub type SYMCRYPT_HMAC_SHA1_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; pub type PSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; pub type PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; @@ -1608,37 +978,19 @@ pub struct _SYMCRYPT_HMAC_SHA1_STATE { pub pKey: PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA1_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_STATE>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA1_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA1_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 136usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA1_STATE"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_STATE>() - 144usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA1_STATE"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::hash"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA1_STATE, hash) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::pKey"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA1_STATE, pKey) - 128usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA1_STATE, magic) - 136usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA1_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1659,37 +1011,19 @@ pub struct _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA256_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA224_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>(), - 80usize, - "Size of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>() - 80usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY, outerState) - 32usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY, magic) - 64usize]; +}; pub type SYMCRYPT_HMAC_SHA224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] @@ -1699,37 +1033,19 @@ pub struct _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA256_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(), - 80usize, - "Size of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>() - 80usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY, outerState) - 32usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY, magic) - 64usize]; +}; pub type SYMCRYPT_HMAC_SHA256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; pub type PSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; pub type PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; @@ -1741,37 +1057,19 @@ pub struct _SYMCRYPT_HMAC_SHA256_STATE { pub pKey: PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_STATE>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 136usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA256_STATE"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_STATE>() - 144usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA256_STATE"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::hash"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA256_STATE, hash) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::pKey"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA256_STATE, pKey) - 128usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA256_STATE, magic) - 136usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA256_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1792,37 +1090,19 @@ pub struct _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>() - 144usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY, outerState) - 64usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY, magic) - 128usize]; +}; pub type SYMCRYPT_HMAC_SHA384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; pub type PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; pub type PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; @@ -1834,37 +1114,19 @@ pub struct _SYMCRYPT_HMAC_SHA384_STATE { pub pKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), - 240usize, - "Size of _SYMCRYPT_HMAC_SHA384_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA384_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 232usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA384_STATE"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA384_STATE"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::hash"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA384_STATE, hash) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::pKey"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA384_STATE, pKey) - 224usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA384_STATE, magic) - 232usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA384_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1885,37 +1147,19 @@ pub struct _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>() - 144usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY, outerState) - 64usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY, magic) - 128usize]; +}; pub type SYMCRYPT_HMAC_SHA512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; pub type PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; pub type PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; @@ -1927,37 +1171,19 @@ pub struct _SYMCRYPT_HMAC_SHA512_STATE { pub pKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), - 240usize, - "Size of _SYMCRYPT_HMAC_SHA512_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 232usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA512_STATE"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA512_STATE"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::hash"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_STATE, hash) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::pKey"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_STATE, pKey) - 224usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_STATE, magic) - 232usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA512_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1978,37 +1204,19 @@ pub struct _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>() - 144usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY, outerState) - 64usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY, magic) - 128usize]; +}; pub type SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] @@ -2018,37 +1226,19 @@ pub struct _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>() - 144usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY, outerState) - 64usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY, magic) - 128usize]; +}; pub type SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] @@ -2060,42 +1250,21 @@ pub struct _SYMCRYPT_HMAC_EXPANDED_KEY { pub outerState: SYMCRYPT_HASH_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pHash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::pHash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 256usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 496usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>() - 512usize]; + ["Alignment of _SYMCRYPT_HMAC_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::pHash"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_EXPANDED_KEY, pHash) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_EXPANDED_KEY, innerState) - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_EXPANDED_KEY, outerState) - 256usize]; + ["Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_EXPANDED_KEY, magic) - 496usize]; +}; impl Default for _SYMCRYPT_HMAC_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2112,27 +1281,15 @@ pub type SYMCRYPT_HMAC_EXPANDED_KEY = _SYMCRYPT_HMAC_EXPANDED_KEY; pub struct _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY { pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY::generic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>() - 512usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY::generic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY, generic) - 0usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2149,27 +1306,15 @@ pub type SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_224_EXPANDED_ pub struct _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY { pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY::generic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>() - 512usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY::generic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY, generic) - 0usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2186,27 +1331,15 @@ pub type SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_256_EXPANDED_ pub struct _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY { pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY::generic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>() - 512usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY::generic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY, generic) - 0usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2223,27 +1356,15 @@ pub type SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_384_EXPANDED_ pub struct _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY { pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY::generic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>() - 512usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY::generic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY, generic) - 0usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2263,42 +1384,21 @@ pub struct _SYMCRYPT_AES_EXPANDED_KEY { pub lastDecRoundKey: *mut [[BYTE; 4usize]; 4usize], pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_AES_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_AES_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_AES_EXPANDED_KEY>(), - 496usize, - "Size of _SYMCRYPT_AES_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_AES_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_AES_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).RoundKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::RoundKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).lastEncRoundKey) as usize - ptr as usize }, - 464usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::lastEncRoundKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).lastDecRoundKey) as usize - ptr as usize }, - 472usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::lastDecRoundKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 480usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_AES_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_AES_EXPANDED_KEY>() - 496usize]; + ["Alignment of _SYMCRYPT_AES_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_AES_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::RoundKey"] + [::std::mem::offset_of!(_SYMCRYPT_AES_EXPANDED_KEY, RoundKey) - 0usize]; + ["Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::lastEncRoundKey"] + [::std::mem::offset_of!(_SYMCRYPT_AES_EXPANDED_KEY, lastEncRoundKey) - 464usize]; + ["Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::lastDecRoundKey"] + [::std::mem::offset_of!(_SYMCRYPT_AES_EXPANDED_KEY, lastDecRoundKey) - 472usize]; + ["Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_AES_EXPANDED_KEY, magic) - 480usize]; +}; impl Default for _SYMCRYPT_AES_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2320,42 +1420,21 @@ pub struct _SYMCRYPT_AES_CMAC_EXPANDED_KEY { pub K2: [BYTE; 16usize], pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_AES_CMAC_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_AES_CMAC_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>(), - 544usize, - "Size of _SYMCRYPT_AES_CMAC_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_AES_CMAC_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).aesKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::aesKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).K1) as usize - ptr as usize }, - 496usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::K1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).K2) as usize - ptr as usize }, - 512usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::K2" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 528usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_AES_CMAC_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>() - 544usize]; + ["Alignment of _SYMCRYPT_AES_CMAC_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::aesKey"] + [::std::mem::offset_of!(_SYMCRYPT_AES_CMAC_EXPANDED_KEY, aesKey) - 0usize]; + ["Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::K1"] + [::std::mem::offset_of!(_SYMCRYPT_AES_CMAC_EXPANDED_KEY, K1) - 496usize]; + ["Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::K2"] + [::std::mem::offset_of!(_SYMCRYPT_AES_CMAC_EXPANDED_KEY, K2) - 512usize]; + ["Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_AES_CMAC_EXPANDED_KEY, magic) - 528usize]; +}; impl Default for _SYMCRYPT_AES_CMAC_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2368,6 +1447,36 @@ impl Default for _SYMCRYPT_AES_CMAC_EXPANDED_KEY { pub type SYMCRYPT_AES_CMAC_EXPANDED_KEY = _SYMCRYPT_AES_CMAC_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_XTS_AES_EXPANDED_KEY { + pub key1: SYMCRYPT_AES_EXPANDED_KEY, + pub key2: SYMCRYPT_AES_EXPANDED_KEY, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_XTS_AES_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_XTS_AES_EXPANDED_KEY>() - 992usize]; + ["Alignment of _SYMCRYPT_XTS_AES_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_XTS_AES_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_XTS_AES_EXPANDED_KEY::key1"] + [::std::mem::offset_of!(_SYMCRYPT_XTS_AES_EXPANDED_KEY, key1) - 0usize]; + ["Offset of field: _SYMCRYPT_XTS_AES_EXPANDED_KEY::key2"] + [::std::mem::offset_of!(_SYMCRYPT_XTS_AES_EXPANDED_KEY, key2) - 496usize]; +}; +impl Default for _SYMCRYPT_XTS_AES_EXPANDED_KEY { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type SYMCRYPT_XTS_AES_EXPANDED_KEY = _SYMCRYPT_XTS_AES_EXPANDED_KEY; +pub type PSYMCRYPT_XTS_AES_EXPANDED_KEY = *mut _SYMCRYPT_XTS_AES_EXPANDED_KEY; +pub type PCSYMCRYPT_XTS_AES_EXPANDED_KEY = *const SYMCRYPT_XTS_AES_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] #[derive(Copy, Clone)] pub union _SYMCRYPT_MAC_EXPANDED_KEY { pub md5Key: SYMCRYPT_HMAC_MD5_EXPANDED_KEY, @@ -2386,97 +1495,43 @@ pub union _SYMCRYPT_MAC_EXPANDED_KEY { pub kmac128Key: SYMCRYPT_KMAC128_EXPANDED_KEY, pub kmac256Key: SYMCRYPT_KMAC256_EXPANDED_KEY, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MAC_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MAC_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MAC_EXPANDED_KEY>(), - 544usize, - "Size of _SYMCRYPT_MAC_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MAC_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_MAC_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md5Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::md5Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha1Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha1Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha224Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha224Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha256Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha384Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha384Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_224Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_224Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_256Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_224Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_224Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_256Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_384Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_384Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_512Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_512Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).aescmacKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::aescmacKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).kmac128Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac128Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).kmac256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac256Key" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MAC_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_MAC_EXPANDED_KEY>() - 544usize]; + ["Alignment of _SYMCRYPT_MAC_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_MAC_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::md5Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, md5Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha1Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha1Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha224Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha224Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha256Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha256Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha384Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha384Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha512Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_224Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha512_224Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_256Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha512_256Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_224Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha3_224Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_256Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha3_256Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_384Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha3_384Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_512Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha3_512Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::aescmacKey"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, aescmacKey) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac128Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, kmac128Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac256Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, kmac256Key) - 0usize]; +}; impl Default for _SYMCRYPT_MAC_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2509,66 +1564,29 @@ pub struct _SYMCRYPT_MAC { pub ppHashAlgorithm: *const PCSYMCRYPT_HASH, pub outerChainingStateOffset: UINT32, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MAC() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MAC> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MAC>(), - 72usize, - "Size of _SYMCRYPT_MAC" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MAC>(), - 8usize, - "Alignment of _SYMCRYPT_MAC" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandKeyFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC::expandKeyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).initFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MAC::initFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MAC::appendFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MAC::resultFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandedKeySize) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MAC::expandedKeySize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateSize) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_MAC::stateSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultSize) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_MAC::resultSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ppHashAlgorithm) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_MAC::ppHashAlgorithm" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerChainingStateOffset) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_MAC::outerChainingStateOffset" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MAC"][::std::mem::size_of::<_SYMCRYPT_MAC>() - 72usize]; + ["Alignment of _SYMCRYPT_MAC"][::std::mem::align_of::<_SYMCRYPT_MAC>() - 8usize]; + ["Offset of field: _SYMCRYPT_MAC::expandKeyFunc"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, expandKeyFunc) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC::initFunc"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, initFunc) - 8usize]; + ["Offset of field: _SYMCRYPT_MAC::appendFunc"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, appendFunc) - 16usize]; + ["Offset of field: _SYMCRYPT_MAC::resultFunc"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, resultFunc) - 24usize]; + ["Offset of field: _SYMCRYPT_MAC::expandedKeySize"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, expandedKeySize) - 32usize]; + ["Offset of field: _SYMCRYPT_MAC::stateSize"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, stateSize) - 40usize]; + ["Offset of field: _SYMCRYPT_MAC::resultSize"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, resultSize) - 48usize]; + ["Offset of field: _SYMCRYPT_MAC::ppHashAlgorithm"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, ppHashAlgorithm) - 56usize]; + ["Offset of field: _SYMCRYPT_MAC::outerChainingStateOffset"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, outerChainingStateOffset) - 64usize]; +}; impl Default for _SYMCRYPT_MAC { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2586,27 +1604,15 @@ pub type PCSYMCRYPT_MAC = *const SYMCRYPT_MAC; pub union _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS { pub aes: SYMCRYPT_AES_EXPANDED_KEY, } -#[test] -fn bindgen_test_layout__SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>(), - 496usize, - "Size of _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>(), - 16usize, - "Alignment of _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).aes) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS::aes" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS"] + [::std::mem::size_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>() - 496usize]; + ["Alignment of _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS"] + [::std::mem::align_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>() - 16usize]; + ["Offset of field: _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS::aes"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS, aes) - 0usize]; +}; impl Default for _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2639,87 +1645,25 @@ pub union __n64 { pub n64_f32: [f32; 2usize], pub n64_f64: [f64; 1usize], } -#[test] -fn bindgen_test_layout___n64() { - const UNINIT: ::std::mem::MaybeUninit<__n64> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!(::std::mem::size_of::<__n64>(), 8usize, "Size of __n64"); - assert_eq!( - ::std::mem::align_of::<__n64>(), - 8usize, - "Alignment of __n64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_u64) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_u64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_u32) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_u32" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_u16) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_u16" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_u8) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_u8" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_i64) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_i64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_i32) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_i32" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_i16) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_i16" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_i8) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_i8" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_p64) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_p64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_p32) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_p32" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_p16) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_p16" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_p8) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_p8" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_f32) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_f32" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n64_f64) as usize - ptr as usize }, - 0usize, - "Offset of field: __n64::n64_f64" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of __n64"][::std::mem::size_of::<__n64>() - 8usize]; + ["Alignment of __n64"][::std::mem::align_of::<__n64>() - 8usize]; + ["Offset of field: __n64::n64_u64"][::std::mem::offset_of!(__n64, n64_u64) - 0usize]; + ["Offset of field: __n64::n64_u32"][::std::mem::offset_of!(__n64, n64_u32) - 0usize]; + ["Offset of field: __n64::n64_u16"][::std::mem::offset_of!(__n64, n64_u16) - 0usize]; + ["Offset of field: __n64::n64_u8"][::std::mem::offset_of!(__n64, n64_u8) - 0usize]; + ["Offset of field: __n64::n64_i64"][::std::mem::offset_of!(__n64, n64_i64) - 0usize]; + ["Offset of field: __n64::n64_i32"][::std::mem::offset_of!(__n64, n64_i32) - 0usize]; + ["Offset of field: __n64::n64_i16"][::std::mem::offset_of!(__n64, n64_i16) - 0usize]; + ["Offset of field: __n64::n64_i8"][::std::mem::offset_of!(__n64, n64_i8) - 0usize]; + ["Offset of field: __n64::n64_p64"][::std::mem::offset_of!(__n64, n64_p64) - 0usize]; + ["Offset of field: __n64::n64_p32"][::std::mem::offset_of!(__n64, n64_p32) - 0usize]; + ["Offset of field: __n64::n64_p16"][::std::mem::offset_of!(__n64, n64_p16) - 0usize]; + ["Offset of field: __n64::n64_p8"][::std::mem::offset_of!(__n64, n64_p8) - 0usize]; + ["Offset of field: __n64::n64_f32"][::std::mem::offset_of!(__n64, n64_f32) - 0usize]; + ["Offset of field: __n64::n64_f64"][::std::mem::offset_of!(__n64, n64_f64) - 0usize]; +}; impl Default for __n64 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2755,31 +1699,15 @@ pub struct __n128__bindgen_ty_1 { pub low64: __n64, pub high64: __n64, } -#[test] -fn bindgen_test_layout___n128__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<__n128__bindgen_ty_1> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<__n128__bindgen_ty_1>(), - 16usize, - "Size of __n128__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<__n128__bindgen_ty_1>(), - 8usize, - "Alignment of __n128__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).low64) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128__bindgen_ty_1::low64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).high64) as usize - ptr as usize }, - 8usize, - "Offset of field: __n128__bindgen_ty_1::high64" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of __n128__bindgen_ty_1"][::std::mem::size_of::<__n128__bindgen_ty_1>() - 16usize]; + ["Alignment of __n128__bindgen_ty_1"][::std::mem::align_of::<__n128__bindgen_ty_1>() - 8usize]; + ["Offset of field: __n128__bindgen_ty_1::low64"] + [::std::mem::offset_of!(__n128__bindgen_ty_1, low64) - 0usize]; + ["Offset of field: __n128__bindgen_ty_1::high64"] + [::std::mem::offset_of!(__n128__bindgen_ty_1, high64) - 8usize]; +}; impl Default for __n128__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2789,92 +1717,26 @@ impl Default for __n128__bindgen_ty_1 { } } } -#[test] -fn bindgen_test_layout___n128() { - const UNINIT: ::std::mem::MaybeUninit<__n128> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!(::std::mem::size_of::<__n128>(), 16usize, "Size of __n128"); - assert_eq!( - ::std::mem::align_of::<__n128>(), - 16usize, - "Alignment of __n128" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_u64) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_u64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_u32) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_u32" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_u16) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_u16" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_u8) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_u8" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_i64) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_i64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_i32) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_i32" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_i16) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_i16" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_i8) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_i8" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_p64) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_p64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_p32) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_p32" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_p16) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_p16" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_p8) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_p8" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_f32) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_f32" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128_f64) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::n128_f64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).s) as usize - ptr as usize }, - 0usize, - "Offset of field: __n128::s" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of __n128"][::std::mem::size_of::<__n128>() - 16usize]; + ["Alignment of __n128"][::std::mem::align_of::<__n128>() - 16usize]; + ["Offset of field: __n128::n128_u64"][::std::mem::offset_of!(__n128, n128_u64) - 0usize]; + ["Offset of field: __n128::n128_u32"][::std::mem::offset_of!(__n128, n128_u32) - 0usize]; + ["Offset of field: __n128::n128_u16"][::std::mem::offset_of!(__n128, n128_u16) - 0usize]; + ["Offset of field: __n128::n128_u8"][::std::mem::offset_of!(__n128, n128_u8) - 0usize]; + ["Offset of field: __n128::n128_i64"][::std::mem::offset_of!(__n128, n128_i64) - 0usize]; + ["Offset of field: __n128::n128_i32"][::std::mem::offset_of!(__n128, n128_i32) - 0usize]; + ["Offset of field: __n128::n128_i16"][::std::mem::offset_of!(__n128, n128_i16) - 0usize]; + ["Offset of field: __n128::n128_i8"][::std::mem::offset_of!(__n128, n128_i8) - 0usize]; + ["Offset of field: __n128::n128_p64"][::std::mem::offset_of!(__n128, n128_p64) - 0usize]; + ["Offset of field: __n128::n128_p32"][::std::mem::offset_of!(__n128, n128_p32) - 0usize]; + ["Offset of field: __n128::n128_p16"][::std::mem::offset_of!(__n128, n128_p16) - 0usize]; + ["Offset of field: __n128::n128_p8"][::std::mem::offset_of!(__n128, n128_p8) - 0usize]; + ["Offset of field: __n128::n128_f32"][::std::mem::offset_of!(__n128, n128_f32) - 0usize]; + ["Offset of field: __n128::n128_f64"][::std::mem::offset_of!(__n128, n128_f64) - 0usize]; + ["Offset of field: __n128::s"][::std::mem::offset_of!(__n128, s) - 0usize]; +}; impl Default for __n128 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2892,37 +1754,18 @@ pub union _SYMCRYPT_GF128_ELEMENT { pub n128: __n128, pub ul: [UINT32; 4usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_GF128_ELEMENT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GF128_ELEMENT> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GF128_ELEMENT>(), - 16usize, - "Size of _SYMCRYPT_GF128_ELEMENT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GF128_ELEMENT>(), - 16usize, - "Alignment of _SYMCRYPT_GF128_ELEMENT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ull) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GF128_ELEMENT::ull" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GF128_ELEMENT::n128" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ul) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GF128_ELEMENT::ul" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_GF128_ELEMENT"][::std::mem::size_of::<_SYMCRYPT_GF128_ELEMENT>() - 16usize]; + ["Alignment of _SYMCRYPT_GF128_ELEMENT"] + [::std::mem::align_of::<_SYMCRYPT_GF128_ELEMENT>() - 16usize]; + ["Offset of field: _SYMCRYPT_GF128_ELEMENT::ull"] + [::std::mem::offset_of!(_SYMCRYPT_GF128_ELEMENT, ull) - 0usize]; + ["Offset of field: _SYMCRYPT_GF128_ELEMENT::n128"] + [::std::mem::offset_of!(_SYMCRYPT_GF128_ELEMENT, n128) - 0usize]; + ["Offset of field: _SYMCRYPT_GF128_ELEMENT::ul"] + [::std::mem::offset_of!(_SYMCRYPT_GF128_ELEMENT, ul) - 0usize]; +}; impl Default for _SYMCRYPT_GF128_ELEMENT { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2939,27 +1782,15 @@ pub type SYMCRYPT_GF128_ELEMENT = _SYMCRYPT_GF128_ELEMENT; pub struct _SYMCRYPT_GHASH_EXPANDED_KEY { pub table: [SYMCRYPT_GF128_ELEMENT; 128usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_GHASH_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GHASH_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>(), - 2048usize, - "Size of _SYMCRYPT_GHASH_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_GHASH_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).table) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GHASH_EXPANDED_KEY::table" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_GHASH_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>() - 2048usize]; + ["Alignment of _SYMCRYPT_GHASH_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_GHASH_EXPANDED_KEY::table"] + [::std::mem::offset_of!(_SYMCRYPT_GHASH_EXPANDED_KEY, table) - 0usize]; +}; impl Default for _SYMCRYPT_GHASH_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2982,52 +1813,25 @@ pub struct _SYMCRYPT_GCM_EXPANDED_KEY { pub abKey: [BYTE; 32usize], pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_GCM_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GCM_EXPANDED_KEY>(), - 2608usize, - "Size of _SYMCRYPT_GCM_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GCM_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_GCM_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ghashKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::ghashKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pBlockCipher) as usize - ptr as usize }, - 2048usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::pBlockCipher" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).blockcipherKey) as usize - ptr as usize }, - 2064usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::blockcipherKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbKey) as usize - ptr as usize }, - 2560usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::cbKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).abKey) as usize - ptr as usize }, - 2568usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::abKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 2600usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_GCM_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_GCM_EXPANDED_KEY>() - 2608usize]; + ["Alignment of _SYMCRYPT_GCM_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_GCM_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::ghashKey"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_EXPANDED_KEY, ghashKey) - 0usize]; + ["Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::pBlockCipher"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_EXPANDED_KEY, pBlockCipher) - 2048usize]; + ["Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::blockcipherKey"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_EXPANDED_KEY, blockcipherKey) - 2064usize]; + ["Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::cbKey"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_EXPANDED_KEY, cbKey) - 2560usize]; + ["Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::abKey"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_EXPANDED_KEY, abKey) - 2568usize]; + ["Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_EXPANDED_KEY, magic) - 2600usize]; +}; impl Default for _SYMCRYPT_GCM_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3054,66 +1858,29 @@ pub struct _SYMCRYPT_GCM_STATE { pub keystreamBlock: [BYTE; 16usize], pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_GCM_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GCM_STATE>(), - 112usize, - "Size of _SYMCRYPT_GCM_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GCM_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_GCM_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GCM_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbData) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_GCM_STATE::cbData" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbAuthData) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_GCM_STATE::cbAuthData" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInMacBlock) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_GCM_STATE::bytesInMacBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ghashState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_GCM_STATE::ghashState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).counterBlock) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_GCM_STATE::counterBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macBlock) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_GCM_STATE::macBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).keystreamBlock) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_GCM_STATE::keystreamBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_GCM_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_GCM_STATE"][::std::mem::size_of::<_SYMCRYPT_GCM_STATE>() - 112usize]; + ["Alignment of _SYMCRYPT_GCM_STATE"][::std::mem::align_of::<_SYMCRYPT_GCM_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::pKey"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, pKey) - 0usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::cbData"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, cbData) - 8usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::cbAuthData"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, cbAuthData) - 16usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::bytesInMacBlock"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, bytesInMacBlock) - 24usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::ghashState"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, ghashState) - 32usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::counterBlock"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, counterBlock) - 48usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::macBlock"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, macBlock) - 64usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::keystreamBlock"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, keystreamBlock) - 80usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, magic) - 96usize]; +}; impl Default for _SYMCRYPT_GCM_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3171,120 +1938,86 @@ pub struct _SYMCRYPT_BLOCKCIPHER { pub blockSize: SIZE_T, pub expandedKeySize: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_BLOCKCIPHER() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_BLOCKCIPHER> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_BLOCKCIPHER>(), - 104usize, - "Size of _SYMCRYPT_BLOCKCIPHER" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_BLOCKCIPHER>(), - 8usize, - "Alignment of _SYMCRYPT_BLOCKCIPHER" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandKeyFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::expandKeyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).encryptFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::encryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).decryptFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::decryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ecbEncryptFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::ecbEncryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ecbDecryptFunc) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::ecbDecryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbcEncryptFunc) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcEncryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbcDecryptFunc) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcDecryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbcMacFunc) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcMacFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ctrMsb64Func) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::ctrMsb64Func" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).gcmEncryptPartFunc) as usize - ptr as usize }, - 72usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::gcmEncryptPartFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).gcmDecryptPartFunc) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::gcmDecryptPartFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).blockSize) as usize - ptr as usize }, - 88usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::blockSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandedKeySize) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::expandedKeySize" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_BLOCKCIPHER"][::std::mem::size_of::<_SYMCRYPT_BLOCKCIPHER>() - 104usize]; + ["Alignment of _SYMCRYPT_BLOCKCIPHER"] + [::std::mem::align_of::<_SYMCRYPT_BLOCKCIPHER>() - 8usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::expandKeyFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, expandKeyFunc) - 0usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::encryptFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, encryptFunc) - 8usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::decryptFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, decryptFunc) - 16usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::ecbEncryptFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, ecbEncryptFunc) - 24usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::ecbDecryptFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, ecbDecryptFunc) - 32usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcEncryptFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, cbcEncryptFunc) - 40usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcDecryptFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, cbcDecryptFunc) - 48usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcMacFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, cbcMacFunc) - 56usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::ctrMsb64Func"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, ctrMsb64Func) - 64usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::gcmEncryptPartFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, gcmEncryptPartFunc) - 72usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::gcmDecryptPartFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, gcmDecryptPartFunc) - 80usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::blockSize"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, blockSize) - 88usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::expandedKeySize"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, expandedKeySize) - 96usize]; +}; #[repr(C)] #[repr(align(16))] #[derive(Copy, Clone)] -pub struct _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY { +pub struct _SYMCRYPT_SP800_108_EXPANDED_KEY { pub macKey: SYMCRYPT_MAC_EXPANDED_KEY, pub macAlg: PCSYMCRYPT_MAC, } -#[test] -fn bindgen_test_layout__SYMCRYPT_TLSPRF1_2_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY>(), - 560usize, - "Size of _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY::macKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macAlg) as usize - ptr as usize }, - 544usize, - "Offset of field: _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY::macAlg" - ); +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SP800_108_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_SP800_108_EXPANDED_KEY>() - 560usize]; + ["Alignment of _SYMCRYPT_SP800_108_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_SP800_108_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_SP800_108_EXPANDED_KEY::macKey"] + [::std::mem::offset_of!(_SYMCRYPT_SP800_108_EXPANDED_KEY, macKey) - 0usize]; + ["Offset of field: _SYMCRYPT_SP800_108_EXPANDED_KEY::macAlg"] + [::std::mem::offset_of!(_SYMCRYPT_SP800_108_EXPANDED_KEY, macAlg) - 544usize]; +}; +impl Default for _SYMCRYPT_SP800_108_EXPANDED_KEY { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type SYMCRYPT_SP800_108_EXPANDED_KEY = _SYMCRYPT_SP800_108_EXPANDED_KEY; +pub type PSYMCRYPT_SP800_108_EXPANDED_KEY = *mut _SYMCRYPT_SP800_108_EXPANDED_KEY; +pub type PCSYMCRYPT_SP800_108_EXPANDED_KEY = *const SYMCRYPT_SP800_108_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Copy, Clone)] +pub struct _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY { + pub macKey: SYMCRYPT_MAC_EXPANDED_KEY, + pub macAlg: PCSYMCRYPT_MAC, } +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY>() - 560usize]; + ["Alignment of _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY::macKey"] + [::std::mem::offset_of!(_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY, macKey) - 0usize]; + ["Offset of field: _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY::macAlg"] + [::std::mem::offset_of!(_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY, macAlg) - 544usize]; +}; impl Default for _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3304,32 +2037,17 @@ pub struct _SYMCRYPT_HKDF_EXPANDED_KEY { pub macKey: SYMCRYPT_MAC_EXPANDED_KEY, pub macAlg: PCSYMCRYPT_MAC, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HKDF_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HKDF_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HKDF_EXPANDED_KEY>(), - 560usize, - "Size of _SYMCRYPT_HKDF_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HKDF_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HKDF_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HKDF_EXPANDED_KEY::macKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macAlg) as usize - ptr as usize }, - 544usize, - "Offset of field: _SYMCRYPT_HKDF_EXPANDED_KEY::macAlg" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HKDF_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HKDF_EXPANDED_KEY>() - 560usize]; + ["Alignment of _SYMCRYPT_HKDF_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HKDF_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HKDF_EXPANDED_KEY::macKey"] + [::std::mem::offset_of!(_SYMCRYPT_HKDF_EXPANDED_KEY, macKey) - 0usize]; + ["Offset of field: _SYMCRYPT_HKDF_EXPANDED_KEY::macAlg"] + [::std::mem::offset_of!(_SYMCRYPT_HKDF_EXPANDED_KEY, macAlg) - 544usize]; +}; impl Default for _SYMCRYPT_HKDF_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3373,48 +2091,24 @@ pub union _SYMCRYPT_INT__bindgen_ty_1 { pub struct _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1 { pub uint32: [UINT32; 1usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>(), - 4usize, - "Size of _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>(), - 4usize, - "Alignment of _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).uint32) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1::uint32" - ); -} -#[test] -fn bindgen_test_layout__SYMCRYPT_INT__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1>(), - 32usize, - "Size of _SYMCRYPT_INT__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1>(), - 32usize, - "Alignment of _SYMCRYPT_INT__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fdef) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_INT__bindgen_ty_1::fdef" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>() - 4usize]; + ["Alignment of _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>() - 4usize]; + ["Offset of field: _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1::uint32"] + [::std::mem::offset_of!(_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1, uint32) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_INT__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1>() - 32usize]; + ["Alignment of _SYMCRYPT_INT__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1>() - 32usize]; + ["Offset of field: _SYMCRYPT_INT__bindgen_ty_1::fdef"] + [::std::mem::offset_of!(_SYMCRYPT_INT__bindgen_ty_1, fdef) - 0usize]; +}; impl Default for _SYMCRYPT_INT__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3424,46 +2118,20 @@ impl Default for _SYMCRYPT_INT__bindgen_ty_1 { } } } -#[test] -fn bindgen_test_layout__SYMCRYPT_INT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_INT>(), - 64usize, - "Size of _SYMCRYPT_INT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_INT>(), - 32usize, - "Alignment of _SYMCRYPT_INT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_INT::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_INT::nDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_INT::cbSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_INT::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ti) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_INT::ti" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_INT"][::std::mem::size_of::<_SYMCRYPT_INT>() - 64usize]; + ["Alignment of _SYMCRYPT_INT"][::std::mem::align_of::<_SYMCRYPT_INT>() - 32usize]; + ["Offset of field: _SYMCRYPT_INT::type_"] + [::std::mem::offset_of!(_SYMCRYPT_INT, type_) - 0usize]; + ["Offset of field: _SYMCRYPT_INT::nDigits"] + [::std::mem::offset_of!(_SYMCRYPT_INT, nDigits) - 4usize]; + ["Offset of field: _SYMCRYPT_INT::cbSize"] + [::std::mem::offset_of!(_SYMCRYPT_INT, cbSize) - 8usize]; + ["Offset of field: _SYMCRYPT_INT::magic"] + [::std::mem::offset_of!(_SYMCRYPT_INT, magic) - 16usize]; + ["Offset of field: _SYMCRYPT_INT::ti"][::std::mem::offset_of!(_SYMCRYPT_INT, ti) - 32usize]; +}; impl Default for _SYMCRYPT_INT { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3495,48 +2163,24 @@ pub union _SYMCRYPT_DIVISOR__bindgen_ty_1 { pub struct _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1 { pub W: UINT64, } -#[test] -fn bindgen_test_layout__SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).W) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1::W" - ); -} -#[test] -fn bindgen_test_layout__SYMCRYPT_DIVISOR__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_DIVISOR__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_DIVISOR__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fdef) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_DIVISOR__bindgen_ty_1::fdef" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>() - 8usize]; + ["Alignment of _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>() - 8usize]; + ["Offset of field: _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1::W"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1, W) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_DIVISOR__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>() - 8usize]; + ["Alignment of _SYMCRYPT_DIVISOR__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>() - 8usize]; + ["Offset of field: _SYMCRYPT_DIVISOR__bindgen_ty_1::fdef"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR__bindgen_ty_1, fdef) - 0usize]; +}; impl Default for _SYMCRYPT_DIVISOR__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3546,56 +2190,25 @@ impl Default for _SYMCRYPT_DIVISOR__bindgen_ty_1 { } } } -#[test] -fn bindgen_test_layout__SYMCRYPT_DIVISOR() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_DIVISOR>(), - 96usize, - "Size of _SYMCRYPT_DIVISOR" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_DIVISOR>(), - 32usize, - "Alignment of _SYMCRYPT_DIVISOR" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_DIVISOR::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_DIVISOR::nDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_DIVISOR::cbSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBits) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_DIVISOR::nBits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_DIVISOR::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).td) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_DIVISOR::td" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).Int) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_DIVISOR::Int" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_DIVISOR"][::std::mem::size_of::<_SYMCRYPT_DIVISOR>() - 96usize]; + ["Alignment of _SYMCRYPT_DIVISOR"][::std::mem::align_of::<_SYMCRYPT_DIVISOR>() - 32usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::type_"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, type_) - 0usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::nDigits"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, nDigits) - 4usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::cbSize"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, cbSize) - 8usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::nBits"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, nBits) - 12usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::magic"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, magic) - 16usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::td"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, td) - 24usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::Int"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, Int) - 32usize]; +}; impl Default for _SYMCRYPT_DIVISOR { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3631,27 +2244,15 @@ pub union _SYMCRYPT_MODULUS__bindgen_ty_1 { pub struct _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1 { pub Rsqr: PCUINT32, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).Rsqr) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1::Rsqr" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>() - 8usize]; + ["Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>() - 8usize]; + ["Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1::Rsqr"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1, Rsqr) - 0usize]; +}; impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3666,53 +2267,26 @@ impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1 { pub struct _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2 { pub k: UINT32, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>(), - 4usize, - "Size of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>(), - 4usize, - "Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).k) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2::k" - ); -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_MODULUS__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).montgomery) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1::montgomery" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pseudoMersenne) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1::pseudoMersenne" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2"] + [::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>() - 4usize]; + ["Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2"] + [::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>() - 4usize]; + ["Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2::k"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2, k) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MODULUS__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>() - 8usize]; + ["Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>() - 8usize]; + ["Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1::montgomery"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS__bindgen_ty_1, montgomery) - 0usize]; + ["Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1::pseudoMersenne"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS__bindgen_ty_1, pseudoMersenne) - 0usize]; +}; impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3722,66 +2296,29 @@ impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1 { } } } -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS>(), - 160usize, - "Size of _SYMCRYPT_MODULUS" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS>(), - 32usize, - "Alignment of _SYMCRYPT_MODULUS" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_MODULUS::nDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MODULUS::cbSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_MODULUS::flags" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbModElement) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MODULUS::cbModElement" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inv64) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MODULUS::inv64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MODULUS::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).tm) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_MODULUS::tm" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).Divisor) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_MODULUS::Divisor" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MODULUS"][::std::mem::size_of::<_SYMCRYPT_MODULUS>() - 160usize]; + ["Alignment of _SYMCRYPT_MODULUS"][::std::mem::align_of::<_SYMCRYPT_MODULUS>() - 32usize]; + ["Offset of field: _SYMCRYPT_MODULUS::type_"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, type_) - 0usize]; + ["Offset of field: _SYMCRYPT_MODULUS::nDigits"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, nDigits) - 4usize]; + ["Offset of field: _SYMCRYPT_MODULUS::cbSize"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, cbSize) - 8usize]; + ["Offset of field: _SYMCRYPT_MODULUS::flags"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, flags) - 12usize]; + ["Offset of field: _SYMCRYPT_MODULUS::cbModElement"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, cbModElement) - 16usize]; + ["Offset of field: _SYMCRYPT_MODULUS::inv64"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, inv64) - 24usize]; + ["Offset of field: _SYMCRYPT_MODULUS::magic"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, magic) - 32usize]; + ["Offset of field: _SYMCRYPT_MODULUS::tm"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, tm) - 40usize]; + ["Offset of field: _SYMCRYPT_MODULUS::Divisor"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, Divisor) - 64usize]; +}; impl Default for _SYMCRYPT_MODULUS { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3802,27 +2339,15 @@ pub struct _SYMCRYPT_MODELEMENT { pub union _SYMCRYPT_MODELEMENT__bindgen_ty_1 { pub uint32: [UINT32; 1usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_MODELEMENT__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODELEMENT__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>(), - 4usize, - "Size of _SYMCRYPT_MODELEMENT__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>(), - 4usize, - "Alignment of _SYMCRYPT_MODELEMENT__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).uint32) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODELEMENT__bindgen_ty_1::uint32" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MODELEMENT__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>() - 4usize]; + ["Alignment of _SYMCRYPT_MODELEMENT__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>() - 4usize]; + ["Offset of field: _SYMCRYPT_MODELEMENT__bindgen_ty_1::uint32"] + [::std::mem::offset_of!(_SYMCRYPT_MODELEMENT__bindgen_ty_1, uint32) - 0usize]; +}; impl Default for _SYMCRYPT_MODELEMENT__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3832,26 +2357,13 @@ impl Default for _SYMCRYPT_MODELEMENT__bindgen_ty_1 { } } } -#[test] -fn bindgen_test_layout__SYMCRYPT_MODELEMENT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODELEMENT> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODELEMENT>(), - 32usize, - "Size of _SYMCRYPT_MODELEMENT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODELEMENT>(), - 32usize, - "Alignment of _SYMCRYPT_MODELEMENT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODELEMENT::d" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MODELEMENT"][::std::mem::size_of::<_SYMCRYPT_MODELEMENT>() - 32usize]; + ["Alignment of _SYMCRYPT_MODELEMENT"][::std::mem::align_of::<_SYMCRYPT_MODELEMENT>() - 32usize]; + ["Offset of field: _SYMCRYPT_MODELEMENT::d"] + [::std::mem::offset_of!(_SYMCRYPT_MODELEMENT, d) - 0usize]; +}; impl Default for _SYMCRYPT_MODELEMENT { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3888,131 +2400,55 @@ pub struct _SYMCRYPT_RSAKEY { pub piCrtPrivExps: [PSYMCRYPT_INT; 2usize], pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_RSAKEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_RSAKEY> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_RSAKEY>(), - 192usize, - "Size of _SYMCRYPT_RSAKEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_RSAKEY>(), - 32usize, - "Alignment of _SYMCRYPT_RSAKEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fAlgorithmInfo) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_RSAKEY::fAlgorithmInfo" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbTotalSize) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_RSAKEY::cbTotalSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hasPrivateKey) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_RSAKEY::hasPrivateKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nSetBitsOfModulus) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_RSAKEY::nSetBitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBitsOfModulus) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_RSAKEY::nBitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigitsOfModulus) as usize - ptr as usize }, - 20usize, - "Offset of field: _SYMCRYPT_RSAKEY::nDigitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPubExp) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_RSAKEY::nPubExp" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPrimes) as usize - ptr as usize }, - 28usize, - "Offset of field: _SYMCRYPT_RSAKEY::nPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBitsOfPrimes) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_RSAKEY::nBitsOfPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigitsOfPrimes) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_RSAKEY::nDigitsOfPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nMaxDigitsOfPrimes) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_RSAKEY::nMaxDigitsOfPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).au64PubExp) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_RSAKEY::au64PubExp" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbPrimes) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbCrtInverses) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbCrtInverses" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbPrivExps) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbCrtPrivExps) as usize - ptr as usize }, - 104usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbCrtPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pmModulus) as usize - ptr as usize }, - 120usize, - "Offset of field: _SYMCRYPT_RSAKEY::pmModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pmPrimes) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_RSAKEY::pmPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).peCrtInverses) as usize - ptr as usize }, - 144usize, - "Offset of field: _SYMCRYPT_RSAKEY::peCrtInverses" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).piPrivExps) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_RSAKEY::piPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).piCrtPrivExps) as usize - ptr as usize }, - 168usize, - "Offset of field: _SYMCRYPT_RSAKEY::piCrtPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 184usize, - "Offset of field: _SYMCRYPT_RSAKEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_RSAKEY"][::std::mem::size_of::<_SYMCRYPT_RSAKEY>() - 192usize]; + ["Alignment of _SYMCRYPT_RSAKEY"][::std::mem::align_of::<_SYMCRYPT_RSAKEY>() - 32usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::fAlgorithmInfo"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, fAlgorithmInfo) - 0usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::cbTotalSize"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, cbTotalSize) - 4usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::hasPrivateKey"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, hasPrivateKey) - 8usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nSetBitsOfModulus"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nSetBitsOfModulus) - 12usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nBitsOfModulus"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nBitsOfModulus) - 16usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nDigitsOfModulus"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nDigitsOfModulus) - 20usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nPubExp"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nPubExp) - 24usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nPrimes) - 28usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nBitsOfPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nBitsOfPrimes) - 32usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nDigitsOfPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nDigitsOfPrimes) - 40usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nMaxDigitsOfPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nMaxDigitsOfPrimes) - 48usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::au64PubExp"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, au64PubExp) - 56usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::pbPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, pbPrimes) - 64usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::pbCrtInverses"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, pbCrtInverses) - 80usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::pbPrivExps"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, pbPrivExps) - 96usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::pbCrtPrivExps"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, pbCrtPrivExps) - 104usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::pmModulus"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, pmModulus) - 120usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::pmPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, pmPrimes) - 128usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::peCrtInverses"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, peCrtInverses) - 144usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::piPrivExps"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, piPrivExps) - 160usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::piCrtPrivExps"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, piCrtPrivExps) - 168usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, magic) - 184usize]; +}; impl Default for _SYMCRYPT_RSAKEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -4049,42 +2485,21 @@ pub struct _SYMCRYPT_ECURVE_INFO_PRECOMP { pub nRecodedDigits: UINT32, pub poPrecompPoints: [PSYMCRYPT_ECPOINT; 64usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE_INFO_PRECOMP() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE_INFO_PRECOMP> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(), - 528usize, - "Size of _SYMCRYPT_ECURVE_INFO_PRECOMP" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(), - 8usize, - "Alignment of _SYMCRYPT_ECURVE_INFO_PRECOMP" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::window" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPrecompPoints) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nPrecompPoints" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nRecodedDigits) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nRecodedDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).poPrecompPoints) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::poPrecompPoints" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_ECURVE_INFO_PRECOMP"] + [::std::mem::size_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>() - 528usize]; + ["Alignment of _SYMCRYPT_ECURVE_INFO_PRECOMP"] + [::std::mem::align_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>() - 8usize]; + ["Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::window"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_INFO_PRECOMP, window) - 0usize]; + ["Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nPrecompPoints"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_INFO_PRECOMP, nPrecompPoints) - 4usize]; + ["Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nRecodedDigits"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_INFO_PRECOMP, nRecodedDigits) - 8usize]; + ["Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::poPrecompPoints"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_INFO_PRECOMP, poPrecompPoints) - 16usize]; +}; impl Default for _SYMCRYPT_ECURVE_INFO_PRECOMP { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -4144,27 +2559,15 @@ pub struct _SYMCRYPT_ECURVE { pub union _SYMCRYPT_ECURVE__bindgen_ty_1 { pub sw: SYMCRYPT_ECURVE_INFO_PRECOMP, } -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(), - 528usize, - "Size of _SYMCRYPT_ECURVE__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_ECURVE__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sw) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE__bindgen_ty_1::sw" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_ECURVE__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>() - 528usize]; + ["Alignment of _SYMCRYPT_ECURVE__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>() - 8usize]; + ["Offset of field: _SYMCRYPT_ECURVE__bindgen_ty_1::sw"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE__bindgen_ty_1, sw) - 0usize]; +}; impl Default for _SYMCRYPT_ECURVE__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -4174,166 +2577,69 @@ impl Default for _SYMCRYPT_ECURVE__bindgen_ty_1 { } } } -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE>(), - 672usize, - "Size of _SYMCRYPT_ECURVE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE>(), - 32usize, - "Alignment of _SYMCRYPT_ECURVE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE::version" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECURVE::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).eCoordinates) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECURVE::eCoordinates" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FModBitsize) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_ECURVE::FModBitsize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FModDigits) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECURVE::FModDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FModBytesize) as usize - ptr as usize }, - 20usize, - "Offset of field: _SYMCRYPT_ECURVE::FModBytesize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrdBitsize) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrdBitsize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrdDigits) as usize - ptr as usize }, - 28usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrdDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrdBytesize) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrdBytesize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbModElement) as usize - ptr as usize }, - 36usize, - "Offset of field: _SYMCRYPT_ECURVE::cbModElement" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbAlloc) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_ECURVE::cbAlloc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchCommon) as usize - ptr as usize }, - 44usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchCommon" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchScalar) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchScalar" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchScalarMulti) as usize - ptr as usize }, - 52usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchScalarMulti" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchGetSetValue) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchGetSetValue" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchEckey) as usize - ptr as usize }, - 60usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchEckey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).coFactorPower) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_ECURVE::coFactorPower" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).PrivateKeyDefaultFormat) as usize - ptr as usize }, - 68usize, - "Offset of field: _SYMCRYPT_ECURVE::PrivateKeyDefaultFormat" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionNumOfBits) as usize - ptr as usize }, - 72usize, - "Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionNumOfBits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionPosition) as usize - ptr as usize }, - 76usize, - "Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionPosition" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionValue) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionValue" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).info) as usize - ptr as usize }, - 88usize, - "Offset of field: _SYMCRYPT_ECURVE::info" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FMod) as usize - ptr as usize }, - 616usize, - "Offset of field: _SYMCRYPT_ECURVE::FMod" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrd) as usize - ptr as usize }, - 624usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrd" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).A) as usize - ptr as usize }, - 632usize, - "Offset of field: _SYMCRYPT_ECURVE::A" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).B) as usize - ptr as usize }, - 640usize, - "Offset of field: _SYMCRYPT_ECURVE::B" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).G) as usize - ptr as usize }, - 648usize, - "Offset of field: _SYMCRYPT_ECURVE::G" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 656usize, - "Offset of field: _SYMCRYPT_ECURVE::H" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 664usize, - "Offset of field: _SYMCRYPT_ECURVE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_ECURVE"][::std::mem::size_of::<_SYMCRYPT_ECURVE>() - 672usize]; + ["Alignment of _SYMCRYPT_ECURVE"][::std::mem::align_of::<_SYMCRYPT_ECURVE>() - 32usize]; + ["Offset of field: _SYMCRYPT_ECURVE::version"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, version) - 0usize]; + ["Offset of field: _SYMCRYPT_ECURVE::type_"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, type_) - 4usize]; + ["Offset of field: _SYMCRYPT_ECURVE::eCoordinates"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, eCoordinates) - 8usize]; + ["Offset of field: _SYMCRYPT_ECURVE::FModBitsize"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, FModBitsize) - 12usize]; + ["Offset of field: _SYMCRYPT_ECURVE::FModDigits"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, FModDigits) - 16usize]; + ["Offset of field: _SYMCRYPT_ECURVE::FModBytesize"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, FModBytesize) - 20usize]; + ["Offset of field: _SYMCRYPT_ECURVE::GOrdBitsize"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, GOrdBitsize) - 24usize]; + ["Offset of field: _SYMCRYPT_ECURVE::GOrdDigits"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, GOrdDigits) - 28usize]; + ["Offset of field: _SYMCRYPT_ECURVE::GOrdBytesize"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, GOrdBytesize) - 32usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbModElement"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbModElement) - 36usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbAlloc"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbAlloc) - 40usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbScratchCommon"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbScratchCommon) - 44usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbScratchScalar"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbScratchScalar) - 48usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbScratchScalarMulti"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbScratchScalarMulti) - 52usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbScratchGetSetValue"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbScratchGetSetValue) - 56usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbScratchEckey"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbScratchEckey) - 60usize]; + ["Offset of field: _SYMCRYPT_ECURVE::coFactorPower"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, coFactorPower) - 64usize]; + ["Offset of field: _SYMCRYPT_ECURVE::PrivateKeyDefaultFormat"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, PrivateKeyDefaultFormat) - 68usize]; + ["Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionNumOfBits"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, HighBitRestrictionNumOfBits) - 72usize]; + ["Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionPosition"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, HighBitRestrictionPosition) - 76usize]; + ["Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionValue"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, HighBitRestrictionValue) - 80usize]; + ["Offset of field: _SYMCRYPT_ECURVE::info"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, info) - 88usize]; + ["Offset of field: _SYMCRYPT_ECURVE::FMod"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, FMod) - 616usize]; + ["Offset of field: _SYMCRYPT_ECURVE::GOrd"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, GOrd) - 624usize]; + ["Offset of field: _SYMCRYPT_ECURVE::A"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, A) - 632usize]; + ["Offset of field: _SYMCRYPT_ECURVE::B"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, B) - 640usize]; + ["Offset of field: _SYMCRYPT_ECURVE::G"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, G) - 648usize]; + ["Offset of field: _SYMCRYPT_ECURVE::H"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, H) - 656usize]; + ["Offset of field: _SYMCRYPT_ECURVE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, magic) - 664usize]; +}; impl Default for _SYMCRYPT_ECURVE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -4354,36 +2660,17 @@ pub struct _SYMCRYPT_ECPOINT { pub pCurve: PCSYMCRYPT_ECURVE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_ECPOINT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECPOINT> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECPOINT>(), - 32usize, - "Size of _SYMCRYPT_ECPOINT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECPOINT>(), - 32usize, - "Alignment of _SYMCRYPT_ECPOINT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).normalized) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECPOINT::normalized" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pCurve) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECPOINT::pCurve" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECPOINT::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_ECPOINT"][::std::mem::size_of::<_SYMCRYPT_ECPOINT>() - 32usize]; + ["Alignment of _SYMCRYPT_ECPOINT"][::std::mem::align_of::<_SYMCRYPT_ECPOINT>() - 32usize]; + ["Offset of field: _SYMCRYPT_ECPOINT::normalized"] + [::std::mem::offset_of!(_SYMCRYPT_ECPOINT, normalized) - 0usize]; + ["Offset of field: _SYMCRYPT_ECPOINT::pCurve"] + [::std::mem::offset_of!(_SYMCRYPT_ECPOINT, pCurve) - 8usize]; + ["Offset of field: _SYMCRYPT_ECPOINT::magic"] + [::std::mem::offset_of!(_SYMCRYPT_ECPOINT, magic) - 16usize]; +}; impl Default for _SYMCRYPT_ECPOINT { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -4404,51 +2691,23 @@ pub struct _SYMCRYPT_ECKEY { pub piPrivateKey: PSYMCRYPT_INT, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_ECKEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECKEY> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECKEY>(), - 64usize, - "Size of _SYMCRYPT_ECKEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECKEY>(), - 32usize, - "Alignment of _SYMCRYPT_ECKEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fAlgorithmInfo) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECKEY::fAlgorithmInfo" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hasPrivateKey) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECKEY::hasPrivateKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pCurve) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECKEY::pCurve" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).poPublicKey) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECKEY::poPublicKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).piPrivateKey) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_ECKEY::piPrivateKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_ECKEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_ECKEY"][::std::mem::size_of::<_SYMCRYPT_ECKEY>() - 64usize]; + ["Alignment of _SYMCRYPT_ECKEY"][::std::mem::align_of::<_SYMCRYPT_ECKEY>() - 32usize]; + ["Offset of field: _SYMCRYPT_ECKEY::fAlgorithmInfo"] + [::std::mem::offset_of!(_SYMCRYPT_ECKEY, fAlgorithmInfo) - 0usize]; + ["Offset of field: _SYMCRYPT_ECKEY::hasPrivateKey"] + [::std::mem::offset_of!(_SYMCRYPT_ECKEY, hasPrivateKey) - 4usize]; + ["Offset of field: _SYMCRYPT_ECKEY::pCurve"] + [::std::mem::offset_of!(_SYMCRYPT_ECKEY, pCurve) - 8usize]; + ["Offset of field: _SYMCRYPT_ECKEY::poPublicKey"] + [::std::mem::offset_of!(_SYMCRYPT_ECKEY, poPublicKey) - 16usize]; + ["Offset of field: _SYMCRYPT_ECKEY::piPrivateKey"] + [::std::mem::offset_of!(_SYMCRYPT_ECKEY, piPrivateKey) - 24usize]; + ["Offset of field: _SYMCRYPT_ECKEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_ECKEY, magic) - 32usize]; +}; impl Default for _SYMCRYPT_ECKEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -4461,196 +2720,191 @@ impl Default for _SYMCRYPT_ECKEY { pub type SYMCRYPT_ECKEY = _SYMCRYPT_ECKEY; pub type PSYMCRYPT_ECKEY = *mut SYMCRYPT_ECKEY; pub type PCSYMCRYPT_ECKEY = *const SYMCRYPT_ECKEY; -extern "C" { +unsafe extern "C" { pub fn SymCryptWipe(pbData: PVOID, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptLoadMsbFirstUint64( pbSrc: PCBYTE, cbSrc: SIZE_T, pDst: PUINT64, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptStoreMsbFirstUint64(src: UINT64, pbDst: PBYTE, cbDst: SIZE_T) -> SYMCRYPT_ERROR; } -#[cfg(not(feature = "dynamic"))] -extern "C" { - pub fn SymCryptInit(); -} -#[cfg(feature = "dynamic")] -extern "C" { +unsafe extern "C" { pub fn SymCryptModuleInit(api: UINT32, minor: UINT32); } -extern "C" { +unsafe extern "C" { pub fn SymCryptMd5(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptMd5Init(pState: PSYMCRYPT_MD5_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptMd5Append(pState: PSYMCRYPT_MD5_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptMd5Result(pState: PSYMCRYPT_MD5_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptMd5StateCopy(pSrc: PCSYMCRYPT_MD5_STATE, pDst: PSYMCRYPT_MD5_STATE); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptMd5Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha1(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha1Init(pState: PSYMCRYPT_SHA1_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha1Append(pState: PSYMCRYPT_SHA1_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha1Result(pState: PSYMCRYPT_SHA1_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha1StateCopy(pSrc: PCSYMCRYPT_SHA1_STATE, pDst: PSYMCRYPT_SHA1_STATE); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha1Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha256(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha256Init(pState: PSYMCRYPT_SHA256_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha256Append(pState: PSYMCRYPT_SHA256_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha256Result(pState: PSYMCRYPT_SHA256_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha256StateCopy(pSrc: PCSYMCRYPT_SHA256_STATE, pDst: PSYMCRYPT_SHA256_STATE); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha256Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha384(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha384Init(pState: PSYMCRYPT_SHA384_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha384Append(pState: PSYMCRYPT_SHA384_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha384Result(pState: PSYMCRYPT_SHA384_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha384StateCopy(pSrc: PCSYMCRYPT_SHA384_STATE, pDst: PSYMCRYPT_SHA384_STATE); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha384Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha512(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha512Init(pState: PSYMCRYPT_SHA512_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha512Append(pState: PSYMCRYPT_SHA512_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha512Result(pState: PSYMCRYPT_SHA512_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha512StateCopy(pSrc: PCSYMCRYPT_SHA512_STATE, pDst: PSYMCRYPT_SHA512_STATE); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha512Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_256(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_256Init(pState: PSYMCRYPT_SHA3_256_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_256Append(pState: PSYMCRYPT_SHA3_256_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_256Result(pState: PSYMCRYPT_SHA3_256_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_256StateCopy( pSrc: PCSYMCRYPT_SHA3_256_STATE, pDst: PSYMCRYPT_SHA3_256_STATE, ); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha3_256Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_384(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_384Init(pState: PSYMCRYPT_SHA3_384_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_384Append(pState: PSYMCRYPT_SHA3_384_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_384Result(pState: PSYMCRYPT_SHA3_384_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_384StateCopy( pSrc: PCSYMCRYPT_SHA3_384_STATE, pDst: PSYMCRYPT_SHA3_384_STATE, ); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha3_384Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_512(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_512Init(pState: PSYMCRYPT_SHA3_512_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_512Append(pState: PSYMCRYPT_SHA3_512_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_512Result(pState: PSYMCRYPT_SHA3_512_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_512StateCopy( pSrc: PCSYMCRYPT_SHA3_512_STATE, pDst: PSYMCRYPT_SHA3_512_STATE, ); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha3_512Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacMd5ExpandKey( pExpandedKey: PSYMCRYPT_HMAC_MD5_EXPANDED_KEY, pbKey: PCBYTE, cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacMd5( pExpandedKey: PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY, pbData: PCBYTE, @@ -4658,37 +2912,37 @@ extern "C" { pbResult: PBYTE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacMd5StateCopy( pSrc: PCSYMCRYPT_HMAC_MD5_STATE, pExpandedKey: PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY, pDst: PSYMCRYPT_HMAC_MD5_STATE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacMd5Init( pState: PSYMCRYPT_HMAC_MD5_STATE, pExpandedKey: PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacMd5Append(pState: PSYMCRYPT_HMAC_MD5_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacMd5Result(pState: PSYMCRYPT_HMAC_MD5_STATE, pbResult: PBYTE); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptHmacMd5Algorithm: PCSYMCRYPT_MAC; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha1ExpandKey( pExpandedKey: PSYMCRYPT_HMAC_SHA1_EXPANDED_KEY, pbKey: PCBYTE, cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha1( pExpandedKey: PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY, pbData: PCBYTE, @@ -4696,41 +2950,41 @@ extern "C" { pbResult: PBYTE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha1StateCopy( pSrc: PCSYMCRYPT_HMAC_SHA1_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY, pDst: PSYMCRYPT_HMAC_SHA1_STATE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha1Init( pState: PSYMCRYPT_HMAC_SHA1_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha1Append( pState: PSYMCRYPT_HMAC_SHA1_STATE, pbData: PCBYTE, cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha1Result(pState: PSYMCRYPT_HMAC_SHA1_STATE, pbResult: PBYTE); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptHmacSha1Algorithm: PCSYMCRYPT_MAC; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha256ExpandKey( pExpandedKey: PSYMCRYPT_HMAC_SHA256_EXPANDED_KEY, pbKey: PCBYTE, cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha256( pExpandedKey: PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY, pbData: PCBYTE, @@ -4738,41 +2992,41 @@ extern "C" { pbResult: PBYTE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha256StateCopy( pSrc: PCSYMCRYPT_HMAC_SHA256_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY, pDst: PSYMCRYPT_HMAC_SHA256_STATE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha256Init( pState: PSYMCRYPT_HMAC_SHA256_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha256Append( pState: PSYMCRYPT_HMAC_SHA256_STATE, pbData: PCBYTE, cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha256Result(pState: PSYMCRYPT_HMAC_SHA256_STATE, pbResult: PBYTE); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptHmacSha256Algorithm: PCSYMCRYPT_MAC; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha384ExpandKey( pExpandedKey: PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, pbKey: PCBYTE, cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha384( pExpandedKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, pbData: PCBYTE, @@ -4780,41 +3034,41 @@ extern "C" { pbResult: PBYTE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha384StateCopy( pSrc: PCSYMCRYPT_HMAC_SHA384_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, pDst: PSYMCRYPT_HMAC_SHA384_STATE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha384Init( pState: PSYMCRYPT_HMAC_SHA384_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha384Append( pState: PSYMCRYPT_HMAC_SHA384_STATE, pbData: PCBYTE, cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha384Result(pState: PSYMCRYPT_HMAC_SHA384_STATE, pbResult: PBYTE); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptHmacSha384Algorithm: PCSYMCRYPT_MAC; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha512ExpandKey( pExpandedKey: PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, pbKey: PCBYTE, cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha512( pExpandedKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, pbData: PCBYTE, @@ -4822,34 +3076,34 @@ extern "C" { pbResult: PBYTE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha512StateCopy( pSrc: PCSYMCRYPT_HMAC_SHA512_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, pDst: PSYMCRYPT_HMAC_SHA512_STATE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha512Init( pState: PSYMCRYPT_HMAC_SHA512_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha512Append( pState: PSYMCRYPT_HMAC_SHA512_STATE, pbData: PCBYTE, cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha512Result(pState: PSYMCRYPT_HMAC_SHA512_STATE, pbResult: PBYTE); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptHmacSha512Algorithm: PCSYMCRYPT_MAC; } -extern "C" { +unsafe extern "C" { pub fn SymCryptChaCha20Poly1305Encrypt( pbKey: PCBYTE, cbKey: SIZE_T, @@ -4864,7 +3118,7 @@ extern "C" { cbTag: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptChaCha20Poly1305Decrypt( pbKey: PCBYTE, cbKey: SIZE_T, @@ -4879,14 +3133,14 @@ extern "C" { cbTag: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptAesExpandKey( pExpandedKey: PSYMCRYPT_AES_EXPANDED_KEY, pbKey: PCBYTE, cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptAesCbcEncrypt( pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY, pbChainingValue: PBYTE, @@ -4895,7 +3149,7 @@ extern "C" { cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptAesCbcDecrypt( pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY, pbChainingValue: PBYTE, @@ -4904,11 +3158,11 @@ extern "C" { cbData: SIZE_T, ); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptAesBlockCipher: PCSYMCRYPT_BLOCKCIPHER; } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmValidateParameters( pBlockCipher: PCSYMCRYPT_BLOCKCIPHER, cbNonce: SIZE_T, @@ -4917,7 +3171,7 @@ extern "C" { cbTag: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmExpandKey( pExpandedKey: PSYMCRYPT_GCM_EXPANDED_KEY, pBlockCipher: PCSYMCRYPT_BLOCKCIPHER, @@ -4925,7 +3179,7 @@ extern "C" { cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmEncrypt( pExpandedKey: PCSYMCRYPT_GCM_EXPANDED_KEY, pbNonce: PCBYTE, @@ -4939,7 +3193,7 @@ extern "C" { cbTag: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmDecrypt( pExpandedKey: PCSYMCRYPT_GCM_EXPANDED_KEY, pbNonce: PCBYTE, @@ -4953,7 +3207,7 @@ extern "C" { cbTag: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmInit( pState: PSYMCRYPT_GCM_STATE, pExpandedKey: PCSYMCRYPT_GCM_EXPANDED_KEY, @@ -4961,17 +3215,17 @@ extern "C" { cbNonce: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmStateCopy( pSrc: PCSYMCRYPT_GCM_STATE, pExpandedKeyCopy: PCSYMCRYPT_GCM_EXPANDED_KEY, pDst: PSYMCRYPT_GCM_STATE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmAuthPart(pState: PSYMCRYPT_GCM_STATE, pbAuthData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmEncryptPart( pState: PSYMCRYPT_GCM_STATE, pbSrc: PCBYTE, @@ -4979,10 +3233,10 @@ extern "C" { cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmEncryptFinal(pState: PSYMCRYPT_GCM_STATE, pbTag: PBYTE, cbTag: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmDecryptPart( pState: PSYMCRYPT_GCM_STATE, pbSrc: PCBYTE, @@ -4990,14 +3244,58 @@ extern "C" { cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmDecryptFinal( pState: PSYMCRYPT_GCM_STATE, pbTag: PCBYTE, cbTag: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { + pub fn SymCryptSp800_108ExpandKey( + pExpandedKey: PSYMCRYPT_SP800_108_EXPANDED_KEY, + macAlgorithm: PCSYMCRYPT_MAC, + pbKey: PCBYTE, + cbKey: SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptSp800_108Derive( + pExpandedKey: PCSYMCRYPT_SP800_108_EXPANDED_KEY, + pbLabel: PCBYTE, + cbLabel: SIZE_T, + pbContext: PCBYTE, + cbContext: SIZE_T, + pbResult: PBYTE, + cbResult: SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptSp800_108( + macAlgorithm: PCSYMCRYPT_MAC, + pbKey: PCBYTE, + cbKey: SIZE_T, + pbLabel: PCBYTE, + cbLabel: SIZE_T, + pbContext: PCBYTE, + cbContext: SIZE_T, + pbResult: PBYTE, + cbResult: SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptSp800_108_HmacSha1SelfTest(); +} +unsafe extern "C" { + pub fn SymCryptSp800_108_HmacSha256SelfTest(); +} +unsafe extern "C" { + pub fn SymCryptSp800_108_HmacSha384SelfTest(); +} +unsafe extern "C" { + pub fn SymCryptSp800_108_HmacSha512SelfTest(); +} +unsafe extern "C" { pub fn SymCryptTlsPrf1_2ExpandKey( pExpandedKey: PSYMCRYPT_TLSPRF1_2_EXPANDED_KEY, macAlgorithm: PCSYMCRYPT_MAC, @@ -5005,7 +3303,7 @@ extern "C" { cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptTlsPrf1_2Derive( pExpandedKey: PCSYMCRYPT_TLSPRF1_2_EXPANDED_KEY, pbLabel: PCBYTE, @@ -5016,7 +3314,7 @@ extern "C" { cbResult: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptTlsPrf1_2( macAlgorithm: PCSYMCRYPT_MAC, pbKey: PCBYTE, @@ -5029,7 +3327,7 @@ extern "C" { cbResult: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHkdfExpandKey( pExpandedKey: PSYMCRYPT_HKDF_EXPANDED_KEY, macAlgorithm: PCSYMCRYPT_MAC, @@ -5039,7 +3337,7 @@ extern "C" { cbSalt: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHkdfExtractPrk( macAlgorithm: PCSYMCRYPT_MAC, pbIkm: PCBYTE, @@ -5050,7 +3348,7 @@ extern "C" { cbPrk: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHkdfPrkExpandKey( pExpandedKey: PSYMCRYPT_HKDF_EXPANDED_KEY, macAlgorithm: PCSYMCRYPT_MAC, @@ -5058,7 +3356,7 @@ extern "C" { cbPrk: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHkdfDerive( pExpandedKey: PCSYMCRYPT_HKDF_EXPANDED_KEY, pbInfo: PCBYTE, @@ -5067,7 +3365,7 @@ extern "C" { cbResult: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHkdf( macAlgorithm: PCSYMCRYPT_MAC, pbIkm: PCBYTE, @@ -5080,16 +3378,112 @@ extern "C" { cbResult: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHkdfSelfTest(); } -#[cfg(feature = "dynamic")] -extern "C" { +unsafe extern "C" { pub fn SymCryptRandom(pbRandom: PBYTE, cbRandom: SIZE_T); } -#[cfg(not(feature = "dynamic"))] -extern "C" { - pub fn SymCryptCallbackRandom(pbBuffer: PBYTE, cbBuffer: SIZE_T) -> SYMCRYPT_ERROR; +unsafe extern "C" { + pub fn SymCryptXtsAesExpandKey( + pExpandedKey: PSYMCRYPT_XTS_AES_EXPANDED_KEY, + pbKey: PCBYTE, + cbKey: SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptXtsAesExpandKeyEx( + pExpandedKey: PSYMCRYPT_XTS_AES_EXPANDED_KEY, + pbKey: PCBYTE, + cbKey: SIZE_T, + flags: UINT32, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptXtsAesKeyCopy( + pSrc: PCSYMCRYPT_XTS_AES_EXPANDED_KEY, + pDst: PSYMCRYPT_XTS_AES_EXPANDED_KEY, + ); +} +unsafe extern "C" { + pub fn SymCryptXtsAesEncrypt( + pExpandedKey: PCSYMCRYPT_XTS_AES_EXPANDED_KEY, + cbDataUnit: SIZE_T, + tweak: UINT64, + pbSrc: PCBYTE, + pbDst: PBYTE, + cbData: SIZE_T, + ); +} +unsafe extern "C" { + pub fn SymCryptXtsAesDecrypt( + pExpandedKey: PCSYMCRYPT_XTS_AES_EXPANDED_KEY, + cbDataUnit: SIZE_T, + tweak: UINT64, + pbSrc: PCBYTE, + pbDst: PBYTE, + cbData: SIZE_T, + ); +} +unsafe extern "C" { + pub fn SymCryptXtsAesEncryptWith128bTweak( + pExpandedKey: PCSYMCRYPT_XTS_AES_EXPANDED_KEY, + cbDataUnit: SIZE_T, + pbTweak: PCBYTE, + pbSrc: PCBYTE, + pbDst: PBYTE, + cbData: SIZE_T, + ); +} +unsafe extern "C" { + pub fn SymCryptXtsAesDecryptWith128bTweak( + pExpandedKey: PCSYMCRYPT_XTS_AES_EXPANDED_KEY, + cbDataUnit: SIZE_T, + pbTweak: PCBYTE, + pbSrc: PCBYTE, + pbDst: PBYTE, + cbData: SIZE_T, + ); +} +unsafe extern "C" { + pub fn SymCryptAesKwEncrypt( + pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY, + pbSrc: PCBYTE, + cbSrc: SIZE_T, + pbDst: PBYTE, + cbDst: SIZE_T, + pcbResult: *mut SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptAesKwDecrypt( + pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY, + pbSrc: PCBYTE, + cbSrc: SIZE_T, + pbDst: PBYTE, + cbDst: SIZE_T, + pcbResult: *mut SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptAesKwpEncrypt( + pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY, + pbSrc: PCBYTE, + cbSrc: SIZE_T, + pbDst: PBYTE, + cbDst: SIZE_T, + pcbResult: *mut SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptAesKwpDecrypt( + pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY, + pbSrc: PCBYTE, + cbSrc: SIZE_T, + pbDst: PBYTE, + cbDst: SIZE_T, + pcbResult: *mut SIZE_T, + ) -> SYMCRYPT_ERROR; } pub const _SYMCRYPT_NUMBER_FORMAT_SYMCRYPT_NUMBER_FORMAT_LSB_FIRST: _SYMCRYPT_NUMBER_FORMAT = 1; pub const _SYMCRYPT_NUMBER_FORMAT_SYMCRYPT_NUMBER_FORMAT_MSB_FIRST: _SYMCRYPT_NUMBER_FORMAT = 2; @@ -5103,41 +3497,19 @@ pub struct _SYMCRYPT_RSA_PARAMS { pub nPrimes: UINT32, pub nPubExp: UINT32, } -#[test] -fn bindgen_test_layout__SYMCRYPT_RSA_PARAMS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_RSA_PARAMS> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_RSA_PARAMS>(), - 16usize, - "Size of _SYMCRYPT_RSA_PARAMS" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_RSA_PARAMS>(), - 4usize, - "Alignment of _SYMCRYPT_RSA_PARAMS" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_RSA_PARAMS::version" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBitsOfModulus) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_RSA_PARAMS::nBitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPrimes) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_RSA_PARAMS::nPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPubExp) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_RSA_PARAMS::nPubExp" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_RSA_PARAMS"][::std::mem::size_of::<_SYMCRYPT_RSA_PARAMS>() - 16usize]; + ["Alignment of _SYMCRYPT_RSA_PARAMS"][::std::mem::align_of::<_SYMCRYPT_RSA_PARAMS>() - 4usize]; + ["Offset of field: _SYMCRYPT_RSA_PARAMS::version"] + [::std::mem::offset_of!(_SYMCRYPT_RSA_PARAMS, version) - 0usize]; + ["Offset of field: _SYMCRYPT_RSA_PARAMS::nBitsOfModulus"] + [::std::mem::offset_of!(_SYMCRYPT_RSA_PARAMS, nBitsOfModulus) - 4usize]; + ["Offset of field: _SYMCRYPT_RSA_PARAMS::nPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSA_PARAMS, nPrimes) - 8usize]; + ["Offset of field: _SYMCRYPT_RSA_PARAMS::nPubExp"] + [::std::mem::offset_of!(_SYMCRYPT_RSA_PARAMS, nPubExp) - 12usize]; +}; pub type SYMCRYPT_RSA_PARAMS = _SYMCRYPT_RSA_PARAMS; pub type PCSYMCRYPT_RSA_PARAMS = *const SYMCRYPT_RSA_PARAMS; pub const _SYMCRYPT_ECURVE_GEN_ALG_ID_SYMCRYPT_ECURVE_GEN_ALG_ID_NULL: _SYMCRYPT_ECURVE_GEN_ALG_ID = @@ -5155,57 +3527,26 @@ pub struct _SYMCRYPT_ECURVE_PARAMS { pub cbCofactor: UINT32, pub cbSeed: UINT32, } -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE_PARAMS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE_PARAMS> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE_PARAMS>(), - 28usize, - "Size of _SYMCRYPT_ECURVE_PARAMS" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE_PARAMS>(), - 4usize, - "Alignment of _SYMCRYPT_ECURVE_PARAMS" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::version" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).algId) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::algId" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbFieldLength) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbFieldLength" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSubgroupOrder) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbSubgroupOrder" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbCofactor) as usize - ptr as usize }, - 20usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbCofactor" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSeed) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbSeed" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_ECURVE_PARAMS"][::std::mem::size_of::<_SYMCRYPT_ECURVE_PARAMS>() - 28usize]; + ["Alignment of _SYMCRYPT_ECURVE_PARAMS"] + [::std::mem::align_of::<_SYMCRYPT_ECURVE_PARAMS>() - 4usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::version"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, version) - 0usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::type_"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, type_) - 4usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::algId"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, algId) - 8usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbFieldLength"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, cbFieldLength) - 12usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbSubgroupOrder"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, cbSubgroupOrder) - 16usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbCofactor"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, cbCofactor) - 20usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbSeed"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, cbSeed) - 24usize]; +}; impl Default for _SYMCRYPT_ECURVE_PARAMS { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -5221,52 +3562,52 @@ pub const _SYMCRYPT_ECPOINT_FORMAT_SYMCRYPT_ECPOINT_FORMAT_X: _SYMCRYPT_ECPOINT_ pub const _SYMCRYPT_ECPOINT_FORMAT_SYMCRYPT_ECPOINT_FORMAT_XY: _SYMCRYPT_ECPOINT_FORMAT = 2; pub type _SYMCRYPT_ECPOINT_FORMAT = ::std::os::raw::c_int; pub use self::_SYMCRYPT_ECPOINT_FORMAT as SYMCRYPT_ECPOINT_FORMAT; -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyAllocate( pParams: PCSYMCRYPT_RSA_PARAMS, flags: UINT32, ) -> PSYMCRYPT_RSAKEY; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyFree(pkObj: PSYMCRYPT_RSAKEY); } -extern "C" { +unsafe extern "C" { pub fn SymCryptEcurveAllocate( pParams: PCSYMCRYPT_ECURVE_PARAMS, flags: UINT32, ) -> PSYMCRYPT_ECURVE; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEcurveFree(pCurve: PSYMCRYPT_ECURVE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeyAllocate(pCurve: PCSYMCRYPT_ECURVE) -> PSYMCRYPT_ECKEY; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeyFree(pkObj: PSYMCRYPT_ECKEY); } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyHasPrivateKey(pkRsakey: PCSYMCRYPT_RSAKEY) -> BOOLEAN; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeySizeofModulus(pkRsakey: PCSYMCRYPT_RSAKEY) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyModulusBits(pkRsakey: PCSYMCRYPT_RSAKEY) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeySizeofPublicExponent(pRsakey: PCSYMCRYPT_RSAKEY, index: UINT32) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeySizeofPrime(pkRsakey: PCSYMCRYPT_RSAKEY, index: UINT32) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyGetNumberOfPublicExponents(pkRsakey: PCSYMCRYPT_RSAKEY) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyGetNumberOfPrimes(pkRsakey: PCSYMCRYPT_RSAKEY) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyGenerate( pkRsakey: PSYMCRYPT_RSAKEY, pu64PubExp: PCUINT64, @@ -5274,7 +3615,7 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeySetValue( pbModulus: PCBYTE, cbModulus: SIZE_T, @@ -5288,7 +3629,7 @@ extern "C" { pkRsakey: PSYMCRYPT_RSAKEY, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeySetValueFromPrivateExponent( pbModulus: PCBYTE, cbModulus: SIZE_T, @@ -5300,7 +3641,7 @@ extern "C" { pkRsakey: PSYMCRYPT_RSAKEY, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyGetValue( pkRsakey: PCSYMCRYPT_RSAKEY, pbModulus: PBYTE, @@ -5314,7 +3655,7 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyGetCrtValue( pkRsakey: PCSYMCRYPT_RSAKEY, ppCrtExponents: *mut PBYTE, @@ -5328,41 +3669,41 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyExtendKeyUsage( pkRsakey: PSYMCRYPT_RSAKEY, flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEcurveSizeofFieldElement(pCurve: PCSYMCRYPT_ECURVE) -> UINT32; } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptEcurveParamsNistP256: PCSYMCRYPT_ECURVE_PARAMS; } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptEcurveParamsNistP384: PCSYMCRYPT_ECURVE_PARAMS; } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptEcurveParamsNistP521: PCSYMCRYPT_ECURVE_PARAMS; } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptEcurveParamsCurve25519: PCSYMCRYPT_ECURVE_PARAMS; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeySizeofPublicKey( pkEckey: PCSYMCRYPT_ECKEY, ecPointFormat: SYMCRYPT_ECPOINT_FORMAT, ) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeySizeofPrivateKey(pkEckey: PCSYMCRYPT_ECKEY) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeySetValue( pbPrivateKey: PCBYTE, cbPrivateKey: SIZE_T, @@ -5374,10 +3715,10 @@ extern "C" { pEckey: PSYMCRYPT_ECKEY, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeySetRandom(flags: UINT32, pEckey: PSYMCRYPT_ECKEY) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeyGetValue( pEckey: PCSYMCRYPT_ECKEY, pbPrivateKey: PBYTE, @@ -5389,7 +3730,7 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaPkcs1Encrypt( pkRsakey: PCSYMCRYPT_RSAKEY, pbSrc: PCBYTE, @@ -5401,7 +3742,7 @@ extern "C" { pcbDst: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaPkcs1Decrypt( pkRsakey: PCSYMCRYPT_RSAKEY, pbSrc: PCBYTE, @@ -5413,7 +3754,7 @@ extern "C" { pcbDst: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaOaepEncrypt( pkRsakey: PCSYMCRYPT_RSAKEY, pbSrc: PCBYTE, @@ -5428,7 +3769,7 @@ extern "C" { pcbDst: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaOaepDecrypt( pkRsakey: PCSYMCRYPT_RSAKEY, pbSrc: PCBYTE, @@ -5443,7 +3784,7 @@ extern "C" { pcbDst: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaPkcs1Sign( pkRsakey: PCSYMCRYPT_RSAKEY, pbHashValue: PCBYTE, @@ -5457,7 +3798,7 @@ extern "C" { pcbSignature: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaPkcs1Verify( pkRsakey: PCSYMCRYPT_RSAKEY, pbHashValue: PCBYTE, @@ -5470,7 +3811,7 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaPssSign( pkRsakey: PCSYMCRYPT_RSAKEY, pbHashValue: PCBYTE, @@ -5484,7 +3825,7 @@ extern "C" { pcbSignature: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaPssVerify( pkRsakey: PCSYMCRYPT_RSAKEY, pbHashValue: PCBYTE, @@ -5497,7 +3838,7 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEcDsaSign( pKey: PCSYMCRYPT_ECKEY, pbHashValue: PCBYTE, @@ -5508,7 +3849,7 @@ extern "C" { cbSignature: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEcDsaVerify( pKey: PCSYMCRYPT_ECKEY, pbHashValue: PCBYTE, @@ -5519,7 +3860,7 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEcDhSecretAgreement( pkPrivate: PCSYMCRYPT_ECKEY, pkPublic: PCSYMCRYPT_ECKEY, diff --git a/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs b/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs index ff90d93e..58587356 100644 --- a/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs +++ b/symcrypt-sys/src/bindings/aarch64_unknown_linux_gnu.rs @@ -70,32 +70,17 @@ pub struct _SYMCRYPT_MD2_CHAINING_STATE { pub C: [BYTE; 16usize], pub X: [BYTE; 48usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_MD2_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD2_CHAINING_STATE>(), - 64usize, - "Size of _SYMCRYPT_MD2_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD2_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD2_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).C) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::C" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::X" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MD2_CHAINING_STATE"] + [::std::mem::size_of::<_SYMCRYPT_MD2_CHAINING_STATE>() - 64usize]; + ["Alignment of _SYMCRYPT_MD2_CHAINING_STATE"] + [::std::mem::align_of::<_SYMCRYPT_MD2_CHAINING_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::C"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_CHAINING_STATE, C) - 0usize]; + ["Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::X"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_CHAINING_STATE, X) - 16usize]; +}; impl Default for _SYMCRYPT_MD2_CHAINING_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -117,51 +102,23 @@ pub struct _SYMCRYPT_MD2_STATE { pub buffer: [BYTE; 16usize], pub chain: SYMCRYPT_MD2_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MD2_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD2_STATE>(), - 112usize, - "Size of _SYMCRYPT_MD2_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD2_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD2_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD2_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MD2_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MD2_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MD2_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MD2_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_MD2_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MD2_STATE"][::std::mem::size_of::<_SYMCRYPT_MD2_STATE>() - 112usize]; + ["Alignment of _SYMCRYPT_MD2_STATE"][::std::mem::align_of::<_SYMCRYPT_MD2_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_MD2_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_MD2_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_MD2_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_MD2_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_MD2_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_MD2_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_STATE, chain) - 48usize]; +}; impl Default for _SYMCRYPT_MD2_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -178,27 +135,15 @@ pub type SYMCRYPT_MD2_STATE = _SYMCRYPT_MD2_STATE; pub struct _SYMCRYPT_MD4_CHAINING_STATE { pub H: [UINT32; 4usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_MD4_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD4_CHAINING_STATE>(), - 16usize, - "Size of _SYMCRYPT_MD4_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD4_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD4_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD4_CHAINING_STATE::H" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MD4_CHAINING_STATE"] + [::std::mem::size_of::<_SYMCRYPT_MD4_CHAINING_STATE>() - 16usize]; + ["Alignment of _SYMCRYPT_MD4_CHAINING_STATE"] + [::std::mem::align_of::<_SYMCRYPT_MD4_CHAINING_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_MD4_CHAINING_STATE::H"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_CHAINING_STATE, H) - 0usize]; +}; pub type SYMCRYPT_MD4_CHAINING_STATE = _SYMCRYPT_MD4_CHAINING_STATE; #[repr(C)] #[repr(align(16))] @@ -211,51 +156,23 @@ pub struct _SYMCRYPT_MD4_STATE { pub buffer: [BYTE; 64usize], pub chain: SYMCRYPT_MD4_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MD4_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD4_STATE>(), - 112usize, - "Size of _SYMCRYPT_MD4_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD4_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD4_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD4_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MD4_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MD4_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MD4_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MD4_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_MD4_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MD4_STATE"][::std::mem::size_of::<_SYMCRYPT_MD4_STATE>() - 112usize]; + ["Alignment of _SYMCRYPT_MD4_STATE"][::std::mem::align_of::<_SYMCRYPT_MD4_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_MD4_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_MD4_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_MD4_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_MD4_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_MD4_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_MD4_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_STATE, chain) - 96usize]; +}; impl Default for _SYMCRYPT_MD4_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -272,27 +189,15 @@ pub type SYMCRYPT_MD4_STATE = _SYMCRYPT_MD4_STATE; pub struct _SYMCRYPT_MD5_CHAINING_STATE { pub H: [UINT32; 4usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_MD5_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD5_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD5_CHAINING_STATE>(), - 16usize, - "Size of _SYMCRYPT_MD5_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD5_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD5_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD5_CHAINING_STATE::H" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MD5_CHAINING_STATE"] + [::std::mem::size_of::<_SYMCRYPT_MD5_CHAINING_STATE>() - 16usize]; + ["Alignment of _SYMCRYPT_MD5_CHAINING_STATE"] + [::std::mem::align_of::<_SYMCRYPT_MD5_CHAINING_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_MD5_CHAINING_STATE::H"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_CHAINING_STATE, H) - 0usize]; +}; pub type SYMCRYPT_MD5_CHAINING_STATE = _SYMCRYPT_MD5_CHAINING_STATE; #[repr(C)] #[repr(align(16))] @@ -305,51 +210,23 @@ pub struct _SYMCRYPT_MD5_STATE { pub buffer: [BYTE; 64usize], pub chain: SYMCRYPT_MD5_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MD5_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD5_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD5_STATE>(), - 112usize, - "Size of _SYMCRYPT_MD5_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD5_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD5_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD5_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MD5_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MD5_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MD5_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MD5_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_MD5_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MD5_STATE"][::std::mem::size_of::<_SYMCRYPT_MD5_STATE>() - 112usize]; + ["Alignment of _SYMCRYPT_MD5_STATE"][::std::mem::align_of::<_SYMCRYPT_MD5_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_MD5_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_MD5_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_MD5_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_MD5_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_MD5_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_MD5_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_STATE, chain) - 96usize]; +}; impl Default for _SYMCRYPT_MD5_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -368,27 +245,15 @@ pub type PCSYMCRYPT_MD5_STATE = *const SYMCRYPT_MD5_STATE; pub struct _SYMCRYPT_SHA1_CHAINING_STATE { pub H: [UINT32; 5usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA1_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA1_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA1_CHAINING_STATE>(), - 32usize, - "Size of _SYMCRYPT_SHA1_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA1_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA1_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA1_CHAINING_STATE::H" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA1_CHAINING_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA1_CHAINING_STATE>() - 32usize]; + ["Alignment of _SYMCRYPT_SHA1_CHAINING_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA1_CHAINING_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA1_CHAINING_STATE::H"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_CHAINING_STATE, H) - 0usize]; +}; pub type SYMCRYPT_SHA1_CHAINING_STATE = _SYMCRYPT_SHA1_CHAINING_STATE; #[repr(C)] #[repr(align(16))] @@ -401,51 +266,23 @@ pub struct _SYMCRYPT_SHA1_STATE { pub buffer: [BYTE; 64usize], pub chain: SYMCRYPT_SHA1_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA1_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA1_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA1_STATE>(), - 128usize, - "Size of _SYMCRYPT_SHA1_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA1_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA1_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA1_STATE"][::std::mem::size_of::<_SYMCRYPT_SHA1_STATE>() - 128usize]; + ["Alignment of _SYMCRYPT_SHA1_STATE"][::std::mem::align_of::<_SYMCRYPT_SHA1_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA1_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA1_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA1_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA1_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA1_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA1_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_STATE, chain) - 96usize]; +}; impl Default for _SYMCRYPT_SHA1_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -464,27 +301,15 @@ pub type PCSYMCRYPT_SHA1_STATE = *const SYMCRYPT_SHA1_STATE; pub struct _SYMCRYPT_SHA256_CHAINING_STATE { pub H: [UINT32; 8usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA256_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA256_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA256_CHAINING_STATE>(), - 32usize, - "Size of _SYMCRYPT_SHA256_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA256_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA256_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA256_CHAINING_STATE::H" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA256_CHAINING_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA256_CHAINING_STATE>() - 32usize]; + ["Alignment of _SYMCRYPT_SHA256_CHAINING_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA256_CHAINING_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA256_CHAINING_STATE::H"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_CHAINING_STATE, H) - 0usize]; +}; pub type SYMCRYPT_SHA256_CHAINING_STATE = _SYMCRYPT_SHA256_CHAINING_STATE; #[repr(C)] #[repr(align(16))] @@ -497,52 +322,24 @@ pub struct _SYMCRYPT_SHA256_STATE { pub buffer: [BYTE; 64usize], pub chain: SYMCRYPT_SHA256_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA256_STATE>(), - 128usize, - "Size of _SYMCRYPT_SHA256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA256_STATE"][::std::mem::size_of::<_SYMCRYPT_SHA256_STATE>() - 128usize]; + ["Alignment of _SYMCRYPT_SHA256_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA256_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA256_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA256_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA256_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA256_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA256_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA256_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_STATE, chain) - 96usize]; +}; impl Default for _SYMCRYPT_SHA256_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -566,52 +363,24 @@ pub struct _SYMCRYPT_SHA224_STATE { pub buffer: [BYTE; 64usize], pub chain: SYMCRYPT_SHA256_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA224_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA224_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA224_STATE>(), - 128usize, - "Size of _SYMCRYPT_SHA224_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA224_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA224_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA224_STATE"][::std::mem::size_of::<_SYMCRYPT_SHA224_STATE>() - 128usize]; + ["Alignment of _SYMCRYPT_SHA224_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA224_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA224_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA224_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA224_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA224_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA224_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA224_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA224_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA224_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA224_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA224_STATE, chain) - 96usize]; +}; impl Default for _SYMCRYPT_SHA224_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -628,27 +397,15 @@ pub type SYMCRYPT_SHA224_STATE = _SYMCRYPT_SHA224_STATE; pub struct _SYMCRYPT_SHA512_CHAINING_STATE { pub H: [UINT64; 8usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_CHAINING_STATE>(), - 64usize, - "Size of _SYMCRYPT_SHA512_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_CHAINING_STATE::H" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA512_CHAINING_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA512_CHAINING_STATE>() - 64usize]; + ["Alignment of _SYMCRYPT_SHA512_CHAINING_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA512_CHAINING_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_CHAINING_STATE::H"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_CHAINING_STATE, H) - 0usize]; +}; pub type SYMCRYPT_SHA512_CHAINING_STATE = _SYMCRYPT_SHA512_CHAINING_STATE; #[repr(C)] #[repr(align(16))] @@ -661,52 +418,24 @@ pub struct _SYMCRYPT_SHA512_STATE { pub buffer: [BYTE; 128usize], pub chain: SYMCRYPT_SHA512_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA512_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA512_STATE"][::std::mem::size_of::<_SYMCRYPT_SHA512_STATE>() - 224usize]; + ["Alignment of _SYMCRYPT_SHA512_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA512_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA512_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA512_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA512_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA512_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_STATE, chain) - 160usize]; +}; impl Default for _SYMCRYPT_SHA512_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -730,52 +459,24 @@ pub struct _SYMCRYPT_SHA384_STATE { pub buffer: [BYTE; 128usize], pub chain: SYMCRYPT_SHA512_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA384_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA384_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA384_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA384_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA384_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA384_STATE"][::std::mem::size_of::<_SYMCRYPT_SHA384_STATE>() - 224usize]; + ["Alignment of _SYMCRYPT_SHA384_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA384_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA384_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA384_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA384_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA384_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA384_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA384_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA384_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA384_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA384_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA384_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA384_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA384_STATE, chain) - 160usize]; +}; impl Default for _SYMCRYPT_SHA384_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -799,52 +500,25 @@ pub struct _SYMCRYPT_SHA512_224_STATE { pub buffer: [BYTE; 128usize], pub chain: SYMCRYPT_SHA512_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_224_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_224_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_224_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA512_224_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_224_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_224_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA512_224_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA512_224_STATE>() - 224usize]; + ["Alignment of _SYMCRYPT_SHA512_224_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA512_224_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_224_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_224_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA512_224_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_224_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_224_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_224_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA512_224_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_224_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA512_224_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_224_STATE, chain) - 160usize]; +}; impl Default for _SYMCRYPT_SHA512_224_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -866,52 +540,25 @@ pub struct _SYMCRYPT_SHA512_256_STATE { pub buffer: [BYTE; 128usize], pub chain: SYMCRYPT_SHA512_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_256_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA512_256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA512_256_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA512_256_STATE>() - 224usize]; + ["Alignment of _SYMCRYPT_SHA512_256_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA512_256_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_256_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_256_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA512_256_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_256_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_256_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_256_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA512_256_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_256_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA512_256_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_256_STATE, chain) - 160usize]; +}; impl Default for _SYMCRYPT_SHA512_256_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -932,47 +579,22 @@ pub struct _SYMCRYPT_KECCAK_STATE { pub paddingValue: UINT8, pub squeezeMode: BOOLEAN, } -#[test] -fn bindgen_test_layout__SYMCRYPT_KECCAK_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KECCAK_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KECCAK_STATE>(), - 224usize, - "Size of _SYMCRYPT_KECCAK_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KECCAK_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_KECCAK_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::state" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, - 200usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::inputBlockSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateIndex) as usize - ptr as usize }, - 204usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::stateIndex" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).paddingValue) as usize - ptr as usize }, - 208usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::paddingValue" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).squeezeMode) as usize - ptr as usize }, - 209usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::squeezeMode" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_KECCAK_STATE"][::std::mem::size_of::<_SYMCRYPT_KECCAK_STATE>() - 224usize]; + ["Alignment of _SYMCRYPT_KECCAK_STATE"] + [::std::mem::align_of::<_SYMCRYPT_KECCAK_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_KECCAK_STATE::state"] + [::std::mem::offset_of!(_SYMCRYPT_KECCAK_STATE, state) - 0usize]; + ["Offset of field: _SYMCRYPT_KECCAK_STATE::inputBlockSize"] + [::std::mem::offset_of!(_SYMCRYPT_KECCAK_STATE, inputBlockSize) - 200usize]; + ["Offset of field: _SYMCRYPT_KECCAK_STATE::stateIndex"] + [::std::mem::offset_of!(_SYMCRYPT_KECCAK_STATE, stateIndex) - 204usize]; + ["Offset of field: _SYMCRYPT_KECCAK_STATE::paddingValue"] + [::std::mem::offset_of!(_SYMCRYPT_KECCAK_STATE, paddingValue) - 208usize]; + ["Offset of field: _SYMCRYPT_KECCAK_STATE::squeezeMode"] + [::std::mem::offset_of!(_SYMCRYPT_KECCAK_STATE, squeezeMode) - 209usize]; +}; pub type SYMCRYPT_KECCAK_STATE = _SYMCRYPT_KECCAK_STATE; #[repr(C)] #[repr(align(16))] @@ -981,32 +603,17 @@ pub struct _SYMCRYPT_SHA3_224_STATE { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_224_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_224_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_224_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_224_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_224_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_224_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_224_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_224_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA3_224_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA3_224_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_SHA3_224_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA3_224_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA3_224_STATE::ks"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_224_STATE, ks) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA3_224_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_224_STATE, magic) - 224usize]; +}; pub type SYMCRYPT_SHA3_224_STATE = _SYMCRYPT_SHA3_224_STATE; #[repr(C)] #[repr(align(16))] @@ -1015,32 +622,17 @@ pub struct _SYMCRYPT_SHA3_256_STATE { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_256_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_256_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_256_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA3_256_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA3_256_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_SHA3_256_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA3_256_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA3_256_STATE::ks"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_256_STATE, ks) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA3_256_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_256_STATE, magic) - 224usize]; +}; pub type SYMCRYPT_SHA3_256_STATE = _SYMCRYPT_SHA3_256_STATE; pub type PSYMCRYPT_SHA3_256_STATE = *mut _SYMCRYPT_SHA3_256_STATE; pub type PCSYMCRYPT_SHA3_256_STATE = *const SYMCRYPT_SHA3_256_STATE; @@ -1051,32 +643,17 @@ pub struct _SYMCRYPT_SHA3_384_STATE { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_384_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_384_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_384_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_384_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_384_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_384_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_384_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA3_384_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA3_384_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_SHA3_384_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA3_384_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA3_384_STATE::ks"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_384_STATE, ks) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA3_384_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_384_STATE, magic) - 224usize]; +}; pub type SYMCRYPT_SHA3_384_STATE = _SYMCRYPT_SHA3_384_STATE; pub type PSYMCRYPT_SHA3_384_STATE = *mut _SYMCRYPT_SHA3_384_STATE; pub type PCSYMCRYPT_SHA3_384_STATE = *const SYMCRYPT_SHA3_384_STATE; @@ -1087,32 +664,17 @@ pub struct _SYMCRYPT_SHA3_512_STATE { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_512_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_512_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_512_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_512_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_512_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_512_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_512_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA3_512_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA3_512_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_SHA3_512_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA3_512_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA3_512_STATE::ks"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_512_STATE, ks) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA3_512_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_512_STATE, magic) - 224usize]; +}; pub type SYMCRYPT_SHA3_512_STATE = _SYMCRYPT_SHA3_512_STATE; pub type PSYMCRYPT_SHA3_512_STATE = *mut _SYMCRYPT_SHA3_512_STATE; pub type PCSYMCRYPT_SHA3_512_STATE = *const SYMCRYPT_SHA3_512_STATE; @@ -1123,32 +685,17 @@ pub struct _SYMCRYPT_KMAC128_EXPANDED_KEY { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_KMAC128_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC128_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(), - 240usize, - "Size of _SYMCRYPT_KMAC128_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_KMAC128_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_KMAC128_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>() - 240usize]; + ["Alignment of _SYMCRYPT_KMAC128_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::ks"] + [::std::mem::offset_of!(_SYMCRYPT_KMAC128_EXPANDED_KEY, ks) - 0usize]; + ["Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_KMAC128_EXPANDED_KEY, magic) - 224usize]; +}; pub type SYMCRYPT_KMAC128_EXPANDED_KEY = _SYMCRYPT_KMAC128_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] @@ -1157,32 +704,17 @@ pub struct _SYMCRYPT_KMAC256_EXPANDED_KEY { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_KMAC256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(), - 240usize, - "Size of _SYMCRYPT_KMAC256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_KMAC256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_KMAC256_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>() - 240usize]; + ["Alignment of _SYMCRYPT_KMAC256_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::ks"] + [::std::mem::offset_of!(_SYMCRYPT_KMAC256_EXPANDED_KEY, ks) - 0usize]; + ["Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_KMAC256_EXPANDED_KEY, magic) - 224usize]; +}; pub type SYMCRYPT_KMAC256_EXPANDED_KEY = _SYMCRYPT_KMAC256_EXPANDED_KEY; #[repr(C)] #[derive(Debug, Copy, Clone)] @@ -1190,31 +722,15 @@ pub struct _SYMCRYPT_OID { pub cbOID: UINT32, pub pbOID: PCBYTE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_OID() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_OID> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_OID>(), - 16usize, - "Size of _SYMCRYPT_OID" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_OID>(), - 8usize, - "Alignment of _SYMCRYPT_OID" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbOID) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_OID::cbOID" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbOID) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_OID::pbOID" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_OID"][::std::mem::size_of::<_SYMCRYPT_OID>() - 16usize]; + ["Alignment of _SYMCRYPT_OID"][::std::mem::align_of::<_SYMCRYPT_OID>() - 8usize]; + ["Offset of field: _SYMCRYPT_OID::cbOID"] + [::std::mem::offset_of!(_SYMCRYPT_OID, cbOID) - 0usize]; + ["Offset of field: _SYMCRYPT_OID::pbOID"] + [::std::mem::offset_of!(_SYMCRYPT_OID, pbOID) - 8usize]; +}; impl Default for _SYMCRYPT_OID { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1226,28 +742,28 @@ impl Default for _SYMCRYPT_OID { } pub type SYMCRYPT_OID = _SYMCRYPT_OID; pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID; -extern "C" { +unsafe extern "C" { pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize]; } -extern "C" { +unsafe extern "C" { pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize]; } -extern "C" { +unsafe extern "C" { pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize]; } -extern "C" { +unsafe extern "C" { pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize]; } -extern "C" { +unsafe extern "C" { pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize]; } -extern "C" { +unsafe extern "C" { pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize]; } -extern "C" { +unsafe extern "C" { pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize]; } -extern "C" { +unsafe extern "C" { pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize]; } #[repr(C)] @@ -1269,91 +785,39 @@ pub union _SYMCRYPT_HASH_STATE { pub sha3_384State: SYMCRYPT_SHA3_384_STATE, pub sha3_512State: SYMCRYPT_SHA3_512_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HASH_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HASH_STATE>(), - 240usize, - "Size of _SYMCRYPT_HASH_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HASH_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HASH_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md2State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::md2State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md4State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::md4State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md5State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::md5State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha1State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha1State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha224State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha224State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha256State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha256State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha384State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha384State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha512State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_224State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha512_224State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_256State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha512_256State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_224State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_224State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_256State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_256State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_384State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_384State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_512State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_512State" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HASH_STATE"][::std::mem::size_of::<_SYMCRYPT_HASH_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_HASH_STATE"][::std::mem::align_of::<_SYMCRYPT_HASH_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::md2State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, md2State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::md4State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, md4State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::md5State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, md5State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha1State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha1State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha224State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha224State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha256State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha256State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha384State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha384State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha512State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha512State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha512_224State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha512_224State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha512_256State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha512_256State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha3_224State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha3_224State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha3_256State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha3_256State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha3_384State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha3_384State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha3_512State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha3_512State) - 0usize]; +}; impl Default for _SYMCRYPT_HASH_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1391,71 +855,31 @@ pub struct _SYMCRYPT_HASH { pub chainOffset: UINT32, pub chainSize: UINT32, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HASH() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HASH>(), - 64usize, - "Size of _SYMCRYPT_HASH" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HASH>(), - 16usize, - "Alignment of _SYMCRYPT_HASH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).initFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH::initFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_HASH::appendFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_HASH::resultFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendBlockFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_HASH::appendBlockFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateCopyFunc) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HASH::stateCopyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateSize) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_HASH::stateSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultSize) as usize - ptr as usize }, - 44usize, - "Offset of field: _SYMCRYPT_HASH::resultSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_HASH::inputBlockSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chainOffset) as usize - ptr as usize }, - 52usize, - "Offset of field: _SYMCRYPT_HASH::chainOffset" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chainSize) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_HASH::chainSize" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HASH"][::std::mem::size_of::<_SYMCRYPT_HASH>() - 64usize]; + ["Alignment of _SYMCRYPT_HASH"][::std::mem::align_of::<_SYMCRYPT_HASH>() - 16usize]; + ["Offset of field: _SYMCRYPT_HASH::initFunc"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, initFunc) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH::appendFunc"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, appendFunc) - 8usize]; + ["Offset of field: _SYMCRYPT_HASH::resultFunc"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, resultFunc) - 16usize]; + ["Offset of field: _SYMCRYPT_HASH::appendBlockFunc"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, appendBlockFunc) - 24usize]; + ["Offset of field: _SYMCRYPT_HASH::stateCopyFunc"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, stateCopyFunc) - 32usize]; + ["Offset of field: _SYMCRYPT_HASH::stateSize"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, stateSize) - 40usize]; + ["Offset of field: _SYMCRYPT_HASH::resultSize"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, resultSize) - 44usize]; + ["Offset of field: _SYMCRYPT_HASH::inputBlockSize"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, inputBlockSize) - 48usize]; + ["Offset of field: _SYMCRYPT_HASH::chainOffset"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, chainOffset) - 52usize]; + ["Offset of field: _SYMCRYPT_HASH::chainSize"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, chainSize) - 56usize]; +}; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] @@ -1464,37 +888,19 @@ pub struct _SYMCRYPT_HMAC_MD5_EXPANDED_KEY { pub outerState: SYMCRYPT_MD5_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), - 48usize, - "Size of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>() - 48usize]; + ["Alignment of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_MD5_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_MD5_EXPANDED_KEY, outerState) - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_MD5_EXPANDED_KEY, magic) - 32usize]; +}; pub type SYMCRYPT_HMAC_MD5_EXPANDED_KEY = _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; pub type PSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; pub type PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *const SYMCRYPT_HMAC_MD5_EXPANDED_KEY; @@ -1506,37 +912,19 @@ pub struct _SYMCRYPT_HMAC_MD5_STATE { pub pKey: PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_MD5_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_STATE>(), - 128usize, - "Size of _SYMCRYPT_HMAC_MD5_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_MD5_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 112usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 120usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_MD5_STATE"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_STATE>() - 128usize]; + ["Alignment of _SYMCRYPT_HMAC_MD5_STATE"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_MD5_STATE::hash"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_MD5_STATE, hash) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_MD5_STATE::pKey"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_MD5_STATE, pKey) - 112usize]; + ["Offset of field: _SYMCRYPT_HMAC_MD5_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_MD5_STATE, magic) - 120usize]; +}; impl Default for _SYMCRYPT_HMAC_MD5_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1557,37 +945,19 @@ pub struct _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA1_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(), - 80usize, - "Size of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>() - 80usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY, outerState) - 32usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY, magic) - 64usize]; +}; pub type SYMCRYPT_HMAC_SHA1_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; pub type PSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; pub type PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; @@ -1599,37 +969,19 @@ pub struct _SYMCRYPT_HMAC_SHA1_STATE { pub pKey: PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA1_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_STATE>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA1_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA1_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 136usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA1_STATE"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_STATE>() - 144usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA1_STATE"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::hash"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA1_STATE, hash) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::pKey"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA1_STATE, pKey) - 128usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA1_STATE, magic) - 136usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA1_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1650,37 +1002,19 @@ pub struct _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA256_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA224_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>(), - 80usize, - "Size of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>() - 80usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY, outerState) - 32usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY, magic) - 64usize]; +}; pub type SYMCRYPT_HMAC_SHA224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] @@ -1690,37 +1024,19 @@ pub struct _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA256_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(), - 80usize, - "Size of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>() - 80usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY, outerState) - 32usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY, magic) - 64usize]; +}; pub type SYMCRYPT_HMAC_SHA256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; pub type PSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; pub type PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; @@ -1732,37 +1048,19 @@ pub struct _SYMCRYPT_HMAC_SHA256_STATE { pub pKey: PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_STATE>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 136usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA256_STATE"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_STATE>() - 144usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA256_STATE"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::hash"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA256_STATE, hash) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::pKey"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA256_STATE, pKey) - 128usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA256_STATE, magic) - 136usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA256_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1783,37 +1081,19 @@ pub struct _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>() - 144usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY, outerState) - 64usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY, magic) - 128usize]; +}; pub type SYMCRYPT_HMAC_SHA384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; pub type PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; pub type PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; @@ -1825,37 +1105,19 @@ pub struct _SYMCRYPT_HMAC_SHA384_STATE { pub pKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), - 240usize, - "Size of _SYMCRYPT_HMAC_SHA384_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA384_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 232usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA384_STATE"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA384_STATE"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::hash"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA384_STATE, hash) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::pKey"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA384_STATE, pKey) - 224usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA384_STATE, magic) - 232usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA384_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1876,37 +1138,19 @@ pub struct _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>() - 144usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY, outerState) - 64usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY, magic) - 128usize]; +}; pub type SYMCRYPT_HMAC_SHA512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; pub type PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; pub type PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; @@ -1918,37 +1162,19 @@ pub struct _SYMCRYPT_HMAC_SHA512_STATE { pub pKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), - 240usize, - "Size of _SYMCRYPT_HMAC_SHA512_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 232usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA512_STATE"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA512_STATE"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::hash"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_STATE, hash) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::pKey"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_STATE, pKey) - 224usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_STATE, magic) - 232usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA512_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1969,37 +1195,19 @@ pub struct _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>() - 144usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY, outerState) - 64usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY, magic) - 128usize]; +}; pub type SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] @@ -2009,37 +1217,19 @@ pub struct _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>() - 144usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY, outerState) - 64usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY, magic) - 128usize]; +}; pub type SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] @@ -2051,42 +1241,21 @@ pub struct _SYMCRYPT_HMAC_EXPANDED_KEY { pub outerState: SYMCRYPT_HASH_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pHash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::pHash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 256usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 496usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>() - 512usize]; + ["Alignment of _SYMCRYPT_HMAC_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::pHash"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_EXPANDED_KEY, pHash) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_EXPANDED_KEY, innerState) - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_EXPANDED_KEY, outerState) - 256usize]; + ["Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_EXPANDED_KEY, magic) - 496usize]; +}; impl Default for _SYMCRYPT_HMAC_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2103,27 +1272,15 @@ pub type SYMCRYPT_HMAC_EXPANDED_KEY = _SYMCRYPT_HMAC_EXPANDED_KEY; pub struct _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY { pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY::generic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>() - 512usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY::generic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY, generic) - 0usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2140,27 +1297,15 @@ pub type SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_224_EXPANDED_ pub struct _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY { pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY::generic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>() - 512usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY::generic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY, generic) - 0usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2177,27 +1322,15 @@ pub type SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_256_EXPANDED_ pub struct _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY { pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY::generic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>() - 512usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY::generic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY, generic) - 0usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2214,27 +1347,15 @@ pub type SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_384_EXPANDED_ pub struct _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY { pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY::generic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>() - 512usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY::generic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY, generic) - 0usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2254,42 +1375,21 @@ pub struct _SYMCRYPT_AES_EXPANDED_KEY { pub lastDecRoundKey: *mut [[BYTE; 4usize]; 4usize], pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_AES_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_AES_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_AES_EXPANDED_KEY>(), - 496usize, - "Size of _SYMCRYPT_AES_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_AES_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_AES_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).RoundKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::RoundKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).lastEncRoundKey) as usize - ptr as usize }, - 464usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::lastEncRoundKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).lastDecRoundKey) as usize - ptr as usize }, - 472usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::lastDecRoundKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 480usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_AES_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_AES_EXPANDED_KEY>() - 496usize]; + ["Alignment of _SYMCRYPT_AES_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_AES_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::RoundKey"] + [::std::mem::offset_of!(_SYMCRYPT_AES_EXPANDED_KEY, RoundKey) - 0usize]; + ["Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::lastEncRoundKey"] + [::std::mem::offset_of!(_SYMCRYPT_AES_EXPANDED_KEY, lastEncRoundKey) - 464usize]; + ["Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::lastDecRoundKey"] + [::std::mem::offset_of!(_SYMCRYPT_AES_EXPANDED_KEY, lastDecRoundKey) - 472usize]; + ["Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_AES_EXPANDED_KEY, magic) - 480usize]; +}; impl Default for _SYMCRYPT_AES_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2311,42 +1411,21 @@ pub struct _SYMCRYPT_AES_CMAC_EXPANDED_KEY { pub K2: [BYTE; 16usize], pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_AES_CMAC_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_AES_CMAC_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>(), - 544usize, - "Size of _SYMCRYPT_AES_CMAC_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_AES_CMAC_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).aesKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::aesKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).K1) as usize - ptr as usize }, - 496usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::K1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).K2) as usize - ptr as usize }, - 512usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::K2" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 528usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_AES_CMAC_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>() - 544usize]; + ["Alignment of _SYMCRYPT_AES_CMAC_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::aesKey"] + [::std::mem::offset_of!(_SYMCRYPT_AES_CMAC_EXPANDED_KEY, aesKey) - 0usize]; + ["Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::K1"] + [::std::mem::offset_of!(_SYMCRYPT_AES_CMAC_EXPANDED_KEY, K1) - 496usize]; + ["Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::K2"] + [::std::mem::offset_of!(_SYMCRYPT_AES_CMAC_EXPANDED_KEY, K2) - 512usize]; + ["Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_AES_CMAC_EXPANDED_KEY, magic) - 528usize]; +}; impl Default for _SYMCRYPT_AES_CMAC_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2359,6 +1438,36 @@ impl Default for _SYMCRYPT_AES_CMAC_EXPANDED_KEY { pub type SYMCRYPT_AES_CMAC_EXPANDED_KEY = _SYMCRYPT_AES_CMAC_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_XTS_AES_EXPANDED_KEY { + pub key1: SYMCRYPT_AES_EXPANDED_KEY, + pub key2: SYMCRYPT_AES_EXPANDED_KEY, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_XTS_AES_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_XTS_AES_EXPANDED_KEY>() - 992usize]; + ["Alignment of _SYMCRYPT_XTS_AES_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_XTS_AES_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_XTS_AES_EXPANDED_KEY::key1"] + [::std::mem::offset_of!(_SYMCRYPT_XTS_AES_EXPANDED_KEY, key1) - 0usize]; + ["Offset of field: _SYMCRYPT_XTS_AES_EXPANDED_KEY::key2"] + [::std::mem::offset_of!(_SYMCRYPT_XTS_AES_EXPANDED_KEY, key2) - 496usize]; +}; +impl Default for _SYMCRYPT_XTS_AES_EXPANDED_KEY { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type SYMCRYPT_XTS_AES_EXPANDED_KEY = _SYMCRYPT_XTS_AES_EXPANDED_KEY; +pub type PSYMCRYPT_XTS_AES_EXPANDED_KEY = *mut _SYMCRYPT_XTS_AES_EXPANDED_KEY; +pub type PCSYMCRYPT_XTS_AES_EXPANDED_KEY = *const SYMCRYPT_XTS_AES_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] #[derive(Copy, Clone)] pub union _SYMCRYPT_MAC_EXPANDED_KEY { pub md5Key: SYMCRYPT_HMAC_MD5_EXPANDED_KEY, @@ -2377,97 +1486,43 @@ pub union _SYMCRYPT_MAC_EXPANDED_KEY { pub kmac128Key: SYMCRYPT_KMAC128_EXPANDED_KEY, pub kmac256Key: SYMCRYPT_KMAC256_EXPANDED_KEY, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MAC_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MAC_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MAC_EXPANDED_KEY>(), - 544usize, - "Size of _SYMCRYPT_MAC_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MAC_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_MAC_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md5Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::md5Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha1Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha1Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha224Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha224Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha256Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha384Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha384Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_224Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_224Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_256Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_224Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_224Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_256Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_384Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_384Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_512Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_512Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).aescmacKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::aescmacKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).kmac128Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac128Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).kmac256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac256Key" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MAC_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_MAC_EXPANDED_KEY>() - 544usize]; + ["Alignment of _SYMCRYPT_MAC_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_MAC_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::md5Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, md5Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha1Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha1Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha224Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha224Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha256Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha256Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha384Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha384Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha512Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_224Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha512_224Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_256Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha512_256Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_224Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha3_224Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_256Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha3_256Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_384Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha3_384Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_512Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha3_512Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::aescmacKey"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, aescmacKey) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac128Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, kmac128Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac256Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, kmac256Key) - 0usize]; +}; impl Default for _SYMCRYPT_MAC_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2500,66 +1555,29 @@ pub struct _SYMCRYPT_MAC { pub ppHashAlgorithm: *const PCSYMCRYPT_HASH, pub outerChainingStateOffset: UINT32, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MAC() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MAC> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MAC>(), - 72usize, - "Size of _SYMCRYPT_MAC" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MAC>(), - 8usize, - "Alignment of _SYMCRYPT_MAC" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandKeyFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC::expandKeyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).initFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MAC::initFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MAC::appendFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MAC::resultFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandedKeySize) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MAC::expandedKeySize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateSize) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_MAC::stateSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultSize) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_MAC::resultSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ppHashAlgorithm) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_MAC::ppHashAlgorithm" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerChainingStateOffset) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_MAC::outerChainingStateOffset" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MAC"][::std::mem::size_of::<_SYMCRYPT_MAC>() - 72usize]; + ["Alignment of _SYMCRYPT_MAC"][::std::mem::align_of::<_SYMCRYPT_MAC>() - 8usize]; + ["Offset of field: _SYMCRYPT_MAC::expandKeyFunc"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, expandKeyFunc) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC::initFunc"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, initFunc) - 8usize]; + ["Offset of field: _SYMCRYPT_MAC::appendFunc"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, appendFunc) - 16usize]; + ["Offset of field: _SYMCRYPT_MAC::resultFunc"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, resultFunc) - 24usize]; + ["Offset of field: _SYMCRYPT_MAC::expandedKeySize"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, expandedKeySize) - 32usize]; + ["Offset of field: _SYMCRYPT_MAC::stateSize"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, stateSize) - 40usize]; + ["Offset of field: _SYMCRYPT_MAC::resultSize"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, resultSize) - 48usize]; + ["Offset of field: _SYMCRYPT_MAC::ppHashAlgorithm"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, ppHashAlgorithm) - 56usize]; + ["Offset of field: _SYMCRYPT_MAC::outerChainingStateOffset"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, outerChainingStateOffset) - 64usize]; +}; impl Default for _SYMCRYPT_MAC { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2577,27 +1595,15 @@ pub type PCSYMCRYPT_MAC = *const SYMCRYPT_MAC; pub union _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS { pub aes: SYMCRYPT_AES_EXPANDED_KEY, } -#[test] -fn bindgen_test_layout__SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>(), - 496usize, - "Size of _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>(), - 16usize, - "Alignment of _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).aes) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS::aes" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS"] + [::std::mem::size_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>() - 496usize]; + ["Alignment of _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS"] + [::std::mem::align_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>() - 16usize]; + ["Offset of field: _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS::aes"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS, aes) - 0usize]; +}; impl Default for _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2617,37 +1623,18 @@ pub union _SYMCRYPT_GF128_ELEMENT { pub n128: uint8x16_t, pub ul: [UINT32; 4usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_GF128_ELEMENT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GF128_ELEMENT> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GF128_ELEMENT>(), - 16usize, - "Size of _SYMCRYPT_GF128_ELEMENT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GF128_ELEMENT>(), - 16usize, - "Alignment of _SYMCRYPT_GF128_ELEMENT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ull) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GF128_ELEMENT::ull" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).n128) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GF128_ELEMENT::n128" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ul) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GF128_ELEMENT::ul" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_GF128_ELEMENT"][::std::mem::size_of::<_SYMCRYPT_GF128_ELEMENT>() - 16usize]; + ["Alignment of _SYMCRYPT_GF128_ELEMENT"] + [::std::mem::align_of::<_SYMCRYPT_GF128_ELEMENT>() - 16usize]; + ["Offset of field: _SYMCRYPT_GF128_ELEMENT::ull"] + [::std::mem::offset_of!(_SYMCRYPT_GF128_ELEMENT, ull) - 0usize]; + ["Offset of field: _SYMCRYPT_GF128_ELEMENT::n128"] + [::std::mem::offset_of!(_SYMCRYPT_GF128_ELEMENT, n128) - 0usize]; + ["Offset of field: _SYMCRYPT_GF128_ELEMENT::ul"] + [::std::mem::offset_of!(_SYMCRYPT_GF128_ELEMENT, ul) - 0usize]; +}; impl Default for _SYMCRYPT_GF128_ELEMENT { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2664,27 +1651,15 @@ pub type SYMCRYPT_GF128_ELEMENT = _SYMCRYPT_GF128_ELEMENT; pub struct _SYMCRYPT_GHASH_EXPANDED_KEY { pub table: [SYMCRYPT_GF128_ELEMENT; 128usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_GHASH_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GHASH_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>(), - 2048usize, - "Size of _SYMCRYPT_GHASH_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_GHASH_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).table) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GHASH_EXPANDED_KEY::table" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_GHASH_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>() - 2048usize]; + ["Alignment of _SYMCRYPT_GHASH_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_GHASH_EXPANDED_KEY::table"] + [::std::mem::offset_of!(_SYMCRYPT_GHASH_EXPANDED_KEY, table) - 0usize]; +}; impl Default for _SYMCRYPT_GHASH_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2707,52 +1682,25 @@ pub struct _SYMCRYPT_GCM_EXPANDED_KEY { pub abKey: [BYTE; 32usize], pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_GCM_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GCM_EXPANDED_KEY>(), - 2608usize, - "Size of _SYMCRYPT_GCM_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GCM_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_GCM_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ghashKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::ghashKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pBlockCipher) as usize - ptr as usize }, - 2048usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::pBlockCipher" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).blockcipherKey) as usize - ptr as usize }, - 2064usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::blockcipherKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbKey) as usize - ptr as usize }, - 2560usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::cbKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).abKey) as usize - ptr as usize }, - 2568usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::abKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 2600usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_GCM_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_GCM_EXPANDED_KEY>() - 2608usize]; + ["Alignment of _SYMCRYPT_GCM_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_GCM_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::ghashKey"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_EXPANDED_KEY, ghashKey) - 0usize]; + ["Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::pBlockCipher"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_EXPANDED_KEY, pBlockCipher) - 2048usize]; + ["Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::blockcipherKey"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_EXPANDED_KEY, blockcipherKey) - 2064usize]; + ["Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::cbKey"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_EXPANDED_KEY, cbKey) - 2560usize]; + ["Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::abKey"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_EXPANDED_KEY, abKey) - 2568usize]; + ["Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_EXPANDED_KEY, magic) - 2600usize]; +}; impl Default for _SYMCRYPT_GCM_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2779,66 +1727,29 @@ pub struct _SYMCRYPT_GCM_STATE { pub keystreamBlock: [BYTE; 16usize], pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_GCM_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GCM_STATE>(), - 112usize, - "Size of _SYMCRYPT_GCM_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GCM_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_GCM_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GCM_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbData) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_GCM_STATE::cbData" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbAuthData) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_GCM_STATE::cbAuthData" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInMacBlock) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_GCM_STATE::bytesInMacBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ghashState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_GCM_STATE::ghashState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).counterBlock) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_GCM_STATE::counterBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macBlock) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_GCM_STATE::macBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).keystreamBlock) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_GCM_STATE::keystreamBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_GCM_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_GCM_STATE"][::std::mem::size_of::<_SYMCRYPT_GCM_STATE>() - 112usize]; + ["Alignment of _SYMCRYPT_GCM_STATE"][::std::mem::align_of::<_SYMCRYPT_GCM_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::pKey"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, pKey) - 0usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::cbData"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, cbData) - 8usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::cbAuthData"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, cbAuthData) - 16usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::bytesInMacBlock"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, bytesInMacBlock) - 24usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::ghashState"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, ghashState) - 32usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::counterBlock"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, counterBlock) - 48usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::macBlock"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, macBlock) - 64usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::keystreamBlock"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, keystreamBlock) - 80usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, magic) - 96usize]; +}; impl Default for _SYMCRYPT_GCM_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2896,120 +1807,86 @@ pub struct _SYMCRYPT_BLOCKCIPHER { pub blockSize: SIZE_T, pub expandedKeySize: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_BLOCKCIPHER() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_BLOCKCIPHER> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_BLOCKCIPHER>(), - 104usize, - "Size of _SYMCRYPT_BLOCKCIPHER" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_BLOCKCIPHER>(), - 8usize, - "Alignment of _SYMCRYPT_BLOCKCIPHER" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandKeyFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::expandKeyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).encryptFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::encryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).decryptFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::decryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ecbEncryptFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::ecbEncryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ecbDecryptFunc) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::ecbDecryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbcEncryptFunc) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcEncryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbcDecryptFunc) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcDecryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbcMacFunc) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcMacFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ctrMsb64Func) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::ctrMsb64Func" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).gcmEncryptPartFunc) as usize - ptr as usize }, - 72usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::gcmEncryptPartFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).gcmDecryptPartFunc) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::gcmDecryptPartFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).blockSize) as usize - ptr as usize }, - 88usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::blockSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandedKeySize) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::expandedKeySize" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_BLOCKCIPHER"][::std::mem::size_of::<_SYMCRYPT_BLOCKCIPHER>() - 104usize]; + ["Alignment of _SYMCRYPT_BLOCKCIPHER"] + [::std::mem::align_of::<_SYMCRYPT_BLOCKCIPHER>() - 8usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::expandKeyFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, expandKeyFunc) - 0usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::encryptFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, encryptFunc) - 8usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::decryptFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, decryptFunc) - 16usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::ecbEncryptFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, ecbEncryptFunc) - 24usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::ecbDecryptFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, ecbDecryptFunc) - 32usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcEncryptFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, cbcEncryptFunc) - 40usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcDecryptFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, cbcDecryptFunc) - 48usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcMacFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, cbcMacFunc) - 56usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::ctrMsb64Func"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, ctrMsb64Func) - 64usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::gcmEncryptPartFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, gcmEncryptPartFunc) - 72usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::gcmDecryptPartFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, gcmDecryptPartFunc) - 80usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::blockSize"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, blockSize) - 88usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::expandedKeySize"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, expandedKeySize) - 96usize]; +}; #[repr(C)] #[repr(align(16))] #[derive(Copy, Clone)] -pub struct _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY { +pub struct _SYMCRYPT_SP800_108_EXPANDED_KEY { pub macKey: SYMCRYPT_MAC_EXPANDED_KEY, pub macAlg: PCSYMCRYPT_MAC, } -#[test] -fn bindgen_test_layout__SYMCRYPT_TLSPRF1_2_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY>(), - 560usize, - "Size of _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY::macKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macAlg) as usize - ptr as usize }, - 544usize, - "Offset of field: _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY::macAlg" - ); +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SP800_108_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_SP800_108_EXPANDED_KEY>() - 560usize]; + ["Alignment of _SYMCRYPT_SP800_108_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_SP800_108_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_SP800_108_EXPANDED_KEY::macKey"] + [::std::mem::offset_of!(_SYMCRYPT_SP800_108_EXPANDED_KEY, macKey) - 0usize]; + ["Offset of field: _SYMCRYPT_SP800_108_EXPANDED_KEY::macAlg"] + [::std::mem::offset_of!(_SYMCRYPT_SP800_108_EXPANDED_KEY, macAlg) - 544usize]; +}; +impl Default for _SYMCRYPT_SP800_108_EXPANDED_KEY { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type SYMCRYPT_SP800_108_EXPANDED_KEY = _SYMCRYPT_SP800_108_EXPANDED_KEY; +pub type PSYMCRYPT_SP800_108_EXPANDED_KEY = *mut _SYMCRYPT_SP800_108_EXPANDED_KEY; +pub type PCSYMCRYPT_SP800_108_EXPANDED_KEY = *const SYMCRYPT_SP800_108_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Copy, Clone)] +pub struct _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY { + pub macKey: SYMCRYPT_MAC_EXPANDED_KEY, + pub macAlg: PCSYMCRYPT_MAC, } +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY>() - 560usize]; + ["Alignment of _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY::macKey"] + [::std::mem::offset_of!(_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY, macKey) - 0usize]; + ["Offset of field: _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY::macAlg"] + [::std::mem::offset_of!(_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY, macAlg) - 544usize]; +}; impl Default for _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3029,32 +1906,17 @@ pub struct _SYMCRYPT_HKDF_EXPANDED_KEY { pub macKey: SYMCRYPT_MAC_EXPANDED_KEY, pub macAlg: PCSYMCRYPT_MAC, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HKDF_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HKDF_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HKDF_EXPANDED_KEY>(), - 560usize, - "Size of _SYMCRYPT_HKDF_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HKDF_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HKDF_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HKDF_EXPANDED_KEY::macKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macAlg) as usize - ptr as usize }, - 544usize, - "Offset of field: _SYMCRYPT_HKDF_EXPANDED_KEY::macAlg" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HKDF_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HKDF_EXPANDED_KEY>() - 560usize]; + ["Alignment of _SYMCRYPT_HKDF_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HKDF_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HKDF_EXPANDED_KEY::macKey"] + [::std::mem::offset_of!(_SYMCRYPT_HKDF_EXPANDED_KEY, macKey) - 0usize]; + ["Offset of field: _SYMCRYPT_HKDF_EXPANDED_KEY::macAlg"] + [::std::mem::offset_of!(_SYMCRYPT_HKDF_EXPANDED_KEY, macAlg) - 544usize]; +}; impl Default for _SYMCRYPT_HKDF_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3097,48 +1959,24 @@ pub union _SYMCRYPT_INT__bindgen_ty_1 { pub struct _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1 { pub uint32: [UINT32; 1usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>(), - 4usize, - "Size of _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>(), - 4usize, - "Alignment of _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).uint32) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1::uint32" - ); -} -#[test] -fn bindgen_test_layout__SYMCRYPT_INT__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1>(), - 4usize, - "Size of _SYMCRYPT_INT__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1>(), - 4usize, - "Alignment of _SYMCRYPT_INT__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fdef) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_INT__bindgen_ty_1::fdef" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>() - 4usize]; + ["Alignment of _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>() - 4usize]; + ["Offset of field: _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1::uint32"] + [::std::mem::offset_of!(_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1, uint32) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_INT__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1>() - 4usize]; + ["Alignment of _SYMCRYPT_INT__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1>() - 4usize]; + ["Offset of field: _SYMCRYPT_INT__bindgen_ty_1::fdef"] + [::std::mem::offset_of!(_SYMCRYPT_INT__bindgen_ty_1, fdef) - 0usize]; +}; impl Default for _SYMCRYPT_INT__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3148,46 +1986,20 @@ impl Default for _SYMCRYPT_INT__bindgen_ty_1 { } } } -#[test] -fn bindgen_test_layout__SYMCRYPT_INT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_INT>(), - 64usize, - "Size of _SYMCRYPT_INT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_INT>(), - 32usize, - "Alignment of _SYMCRYPT_INT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_INT::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_INT::nDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_INT::cbSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_INT::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ti) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_INT::ti" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_INT"][::std::mem::size_of::<_SYMCRYPT_INT>() - 64usize]; + ["Alignment of _SYMCRYPT_INT"][::std::mem::align_of::<_SYMCRYPT_INT>() - 32usize]; + ["Offset of field: _SYMCRYPT_INT::type_"] + [::std::mem::offset_of!(_SYMCRYPT_INT, type_) - 0usize]; + ["Offset of field: _SYMCRYPT_INT::nDigits"] + [::std::mem::offset_of!(_SYMCRYPT_INT, nDigits) - 4usize]; + ["Offset of field: _SYMCRYPT_INT::cbSize"] + [::std::mem::offset_of!(_SYMCRYPT_INT, cbSize) - 8usize]; + ["Offset of field: _SYMCRYPT_INT::magic"] + [::std::mem::offset_of!(_SYMCRYPT_INT, magic) - 16usize]; + ["Offset of field: _SYMCRYPT_INT::ti"][::std::mem::offset_of!(_SYMCRYPT_INT, ti) - 32usize]; +}; impl Default for _SYMCRYPT_INT { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3219,48 +2031,24 @@ pub union _SYMCRYPT_DIVISOR__bindgen_ty_1 { pub struct _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1 { pub W: UINT64, } -#[test] -fn bindgen_test_layout__SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).W) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1::W" - ); -} -#[test] -fn bindgen_test_layout__SYMCRYPT_DIVISOR__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_DIVISOR__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_DIVISOR__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fdef) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_DIVISOR__bindgen_ty_1::fdef" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>() - 8usize]; + ["Alignment of _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>() - 8usize]; + ["Offset of field: _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1::W"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1, W) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_DIVISOR__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>() - 8usize]; + ["Alignment of _SYMCRYPT_DIVISOR__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>() - 8usize]; + ["Offset of field: _SYMCRYPT_DIVISOR__bindgen_ty_1::fdef"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR__bindgen_ty_1, fdef) - 0usize]; +}; impl Default for _SYMCRYPT_DIVISOR__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3270,56 +2058,25 @@ impl Default for _SYMCRYPT_DIVISOR__bindgen_ty_1 { } } } -#[test] -fn bindgen_test_layout__SYMCRYPT_DIVISOR() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_DIVISOR>(), - 96usize, - "Size of _SYMCRYPT_DIVISOR" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_DIVISOR>(), - 32usize, - "Alignment of _SYMCRYPT_DIVISOR" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_DIVISOR::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_DIVISOR::nDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_DIVISOR::cbSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBits) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_DIVISOR::nBits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_DIVISOR::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).td) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_DIVISOR::td" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).Int) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_DIVISOR::Int" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_DIVISOR"][::std::mem::size_of::<_SYMCRYPT_DIVISOR>() - 96usize]; + ["Alignment of _SYMCRYPT_DIVISOR"][::std::mem::align_of::<_SYMCRYPT_DIVISOR>() - 32usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::type_"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, type_) - 0usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::nDigits"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, nDigits) - 4usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::cbSize"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, cbSize) - 8usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::nBits"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, nBits) - 12usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::magic"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, magic) - 16usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::td"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, td) - 24usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::Int"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, Int) - 32usize]; +}; impl Default for _SYMCRYPT_DIVISOR { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3355,27 +2112,15 @@ pub union _SYMCRYPT_MODULUS__bindgen_ty_1 { pub struct _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1 { pub Rsqr: PCUINT32, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).Rsqr) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1::Rsqr" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>() - 8usize]; + ["Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>() - 8usize]; + ["Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1::Rsqr"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1, Rsqr) - 0usize]; +}; impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3390,53 +2135,26 @@ impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1 { pub struct _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2 { pub k: UINT32, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>(), - 4usize, - "Size of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>(), - 4usize, - "Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).k) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2::k" - ); -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_MODULUS__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).montgomery) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1::montgomery" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pseudoMersenne) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1::pseudoMersenne" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2"] + [::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>() - 4usize]; + ["Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2"] + [::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>() - 4usize]; + ["Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2::k"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2, k) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MODULUS__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>() - 8usize]; + ["Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>() - 8usize]; + ["Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1::montgomery"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS__bindgen_ty_1, montgomery) - 0usize]; + ["Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1::pseudoMersenne"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS__bindgen_ty_1, pseudoMersenne) - 0usize]; +}; impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3446,66 +2164,29 @@ impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1 { } } } -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS>(), - 160usize, - "Size of _SYMCRYPT_MODULUS" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS>(), - 32usize, - "Alignment of _SYMCRYPT_MODULUS" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_MODULUS::nDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MODULUS::cbSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_MODULUS::flags" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbModElement) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MODULUS::cbModElement" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inv64) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MODULUS::inv64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MODULUS::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).tm) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_MODULUS::tm" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).Divisor) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_MODULUS::Divisor" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MODULUS"][::std::mem::size_of::<_SYMCRYPT_MODULUS>() - 160usize]; + ["Alignment of _SYMCRYPT_MODULUS"][::std::mem::align_of::<_SYMCRYPT_MODULUS>() - 32usize]; + ["Offset of field: _SYMCRYPT_MODULUS::type_"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, type_) - 0usize]; + ["Offset of field: _SYMCRYPT_MODULUS::nDigits"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, nDigits) - 4usize]; + ["Offset of field: _SYMCRYPT_MODULUS::cbSize"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, cbSize) - 8usize]; + ["Offset of field: _SYMCRYPT_MODULUS::flags"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, flags) - 12usize]; + ["Offset of field: _SYMCRYPT_MODULUS::cbModElement"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, cbModElement) - 16usize]; + ["Offset of field: _SYMCRYPT_MODULUS::inv64"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, inv64) - 24usize]; + ["Offset of field: _SYMCRYPT_MODULUS::magic"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, magic) - 32usize]; + ["Offset of field: _SYMCRYPT_MODULUS::tm"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, tm) - 40usize]; + ["Offset of field: _SYMCRYPT_MODULUS::Divisor"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, Divisor) - 64usize]; +}; impl Default for _SYMCRYPT_MODULUS { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3526,27 +2207,15 @@ pub struct _SYMCRYPT_MODELEMENT { pub union _SYMCRYPT_MODELEMENT__bindgen_ty_1 { pub uint32: [UINT32; 1usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_MODELEMENT__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODELEMENT__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>(), - 4usize, - "Size of _SYMCRYPT_MODELEMENT__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>(), - 4usize, - "Alignment of _SYMCRYPT_MODELEMENT__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).uint32) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODELEMENT__bindgen_ty_1::uint32" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MODELEMENT__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>() - 4usize]; + ["Alignment of _SYMCRYPT_MODELEMENT__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>() - 4usize]; + ["Offset of field: _SYMCRYPT_MODELEMENT__bindgen_ty_1::uint32"] + [::std::mem::offset_of!(_SYMCRYPT_MODELEMENT__bindgen_ty_1, uint32) - 0usize]; +}; impl Default for _SYMCRYPT_MODELEMENT__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3556,26 +2225,13 @@ impl Default for _SYMCRYPT_MODELEMENT__bindgen_ty_1 { } } } -#[test] -fn bindgen_test_layout__SYMCRYPT_MODELEMENT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODELEMENT> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODELEMENT>(), - 32usize, - "Size of _SYMCRYPT_MODELEMENT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODELEMENT>(), - 32usize, - "Alignment of _SYMCRYPT_MODELEMENT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODELEMENT::d" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MODELEMENT"][::std::mem::size_of::<_SYMCRYPT_MODELEMENT>() - 32usize]; + ["Alignment of _SYMCRYPT_MODELEMENT"][::std::mem::align_of::<_SYMCRYPT_MODELEMENT>() - 32usize]; + ["Offset of field: _SYMCRYPT_MODELEMENT::d"] + [::std::mem::offset_of!(_SYMCRYPT_MODELEMENT, d) - 0usize]; +}; impl Default for _SYMCRYPT_MODELEMENT { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3612,131 +2268,55 @@ pub struct _SYMCRYPT_RSAKEY { pub piCrtPrivExps: [PSYMCRYPT_INT; 2usize], pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_RSAKEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_RSAKEY> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_RSAKEY>(), - 192usize, - "Size of _SYMCRYPT_RSAKEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_RSAKEY>(), - 32usize, - "Alignment of _SYMCRYPT_RSAKEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fAlgorithmInfo) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_RSAKEY::fAlgorithmInfo" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbTotalSize) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_RSAKEY::cbTotalSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hasPrivateKey) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_RSAKEY::hasPrivateKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nSetBitsOfModulus) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_RSAKEY::nSetBitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBitsOfModulus) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_RSAKEY::nBitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigitsOfModulus) as usize - ptr as usize }, - 20usize, - "Offset of field: _SYMCRYPT_RSAKEY::nDigitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPubExp) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_RSAKEY::nPubExp" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPrimes) as usize - ptr as usize }, - 28usize, - "Offset of field: _SYMCRYPT_RSAKEY::nPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBitsOfPrimes) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_RSAKEY::nBitsOfPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigitsOfPrimes) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_RSAKEY::nDigitsOfPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nMaxDigitsOfPrimes) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_RSAKEY::nMaxDigitsOfPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).au64PubExp) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_RSAKEY::au64PubExp" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbPrimes) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbCrtInverses) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbCrtInverses" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbPrivExps) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbCrtPrivExps) as usize - ptr as usize }, - 104usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbCrtPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pmModulus) as usize - ptr as usize }, - 120usize, - "Offset of field: _SYMCRYPT_RSAKEY::pmModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pmPrimes) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_RSAKEY::pmPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).peCrtInverses) as usize - ptr as usize }, - 144usize, - "Offset of field: _SYMCRYPT_RSAKEY::peCrtInverses" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).piPrivExps) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_RSAKEY::piPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).piCrtPrivExps) as usize - ptr as usize }, - 168usize, - "Offset of field: _SYMCRYPT_RSAKEY::piCrtPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 184usize, - "Offset of field: _SYMCRYPT_RSAKEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_RSAKEY"][::std::mem::size_of::<_SYMCRYPT_RSAKEY>() - 192usize]; + ["Alignment of _SYMCRYPT_RSAKEY"][::std::mem::align_of::<_SYMCRYPT_RSAKEY>() - 32usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::fAlgorithmInfo"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, fAlgorithmInfo) - 0usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::cbTotalSize"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, cbTotalSize) - 4usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::hasPrivateKey"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, hasPrivateKey) - 8usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nSetBitsOfModulus"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nSetBitsOfModulus) - 12usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nBitsOfModulus"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nBitsOfModulus) - 16usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nDigitsOfModulus"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nDigitsOfModulus) - 20usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nPubExp"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nPubExp) - 24usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nPrimes) - 28usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nBitsOfPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nBitsOfPrimes) - 32usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nDigitsOfPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nDigitsOfPrimes) - 40usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nMaxDigitsOfPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nMaxDigitsOfPrimes) - 48usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::au64PubExp"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, au64PubExp) - 56usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::pbPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, pbPrimes) - 64usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::pbCrtInverses"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, pbCrtInverses) - 80usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::pbPrivExps"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, pbPrivExps) - 96usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::pbCrtPrivExps"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, pbCrtPrivExps) - 104usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::pmModulus"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, pmModulus) - 120usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::pmPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, pmPrimes) - 128usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::peCrtInverses"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, peCrtInverses) - 144usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::piPrivExps"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, piPrivExps) - 160usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::piCrtPrivExps"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, piCrtPrivExps) - 168usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, magic) - 184usize]; +}; impl Default for _SYMCRYPT_RSAKEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3773,42 +2353,21 @@ pub struct _SYMCRYPT_ECURVE_INFO_PRECOMP { pub nRecodedDigits: UINT32, pub poPrecompPoints: [PSYMCRYPT_ECPOINT; 64usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE_INFO_PRECOMP() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE_INFO_PRECOMP> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(), - 528usize, - "Size of _SYMCRYPT_ECURVE_INFO_PRECOMP" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(), - 8usize, - "Alignment of _SYMCRYPT_ECURVE_INFO_PRECOMP" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::window" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPrecompPoints) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nPrecompPoints" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nRecodedDigits) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nRecodedDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).poPrecompPoints) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::poPrecompPoints" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_ECURVE_INFO_PRECOMP"] + [::std::mem::size_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>() - 528usize]; + ["Alignment of _SYMCRYPT_ECURVE_INFO_PRECOMP"] + [::std::mem::align_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>() - 8usize]; + ["Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::window"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_INFO_PRECOMP, window) - 0usize]; + ["Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nPrecompPoints"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_INFO_PRECOMP, nPrecompPoints) - 4usize]; + ["Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nRecodedDigits"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_INFO_PRECOMP, nRecodedDigits) - 8usize]; + ["Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::poPrecompPoints"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_INFO_PRECOMP, poPrecompPoints) - 16usize]; +}; impl Default for _SYMCRYPT_ECURVE_INFO_PRECOMP { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3868,27 +2427,15 @@ pub struct _SYMCRYPT_ECURVE { pub union _SYMCRYPT_ECURVE__bindgen_ty_1 { pub sw: SYMCRYPT_ECURVE_INFO_PRECOMP, } -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(), - 528usize, - "Size of _SYMCRYPT_ECURVE__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_ECURVE__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sw) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE__bindgen_ty_1::sw" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_ECURVE__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>() - 528usize]; + ["Alignment of _SYMCRYPT_ECURVE__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>() - 8usize]; + ["Offset of field: _SYMCRYPT_ECURVE__bindgen_ty_1::sw"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE__bindgen_ty_1, sw) - 0usize]; +}; impl Default for _SYMCRYPT_ECURVE__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3898,166 +2445,69 @@ impl Default for _SYMCRYPT_ECURVE__bindgen_ty_1 { } } } -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE>(), - 672usize, - "Size of _SYMCRYPT_ECURVE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE>(), - 32usize, - "Alignment of _SYMCRYPT_ECURVE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE::version" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECURVE::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).eCoordinates) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECURVE::eCoordinates" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FModBitsize) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_ECURVE::FModBitsize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FModDigits) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECURVE::FModDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FModBytesize) as usize - ptr as usize }, - 20usize, - "Offset of field: _SYMCRYPT_ECURVE::FModBytesize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrdBitsize) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrdBitsize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrdDigits) as usize - ptr as usize }, - 28usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrdDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrdBytesize) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrdBytesize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbModElement) as usize - ptr as usize }, - 36usize, - "Offset of field: _SYMCRYPT_ECURVE::cbModElement" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbAlloc) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_ECURVE::cbAlloc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchCommon) as usize - ptr as usize }, - 44usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchCommon" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchScalar) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchScalar" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchScalarMulti) as usize - ptr as usize }, - 52usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchScalarMulti" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchGetSetValue) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchGetSetValue" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchEckey) as usize - ptr as usize }, - 60usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchEckey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).coFactorPower) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_ECURVE::coFactorPower" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).PrivateKeyDefaultFormat) as usize - ptr as usize }, - 68usize, - "Offset of field: _SYMCRYPT_ECURVE::PrivateKeyDefaultFormat" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionNumOfBits) as usize - ptr as usize }, - 72usize, - "Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionNumOfBits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionPosition) as usize - ptr as usize }, - 76usize, - "Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionPosition" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionValue) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionValue" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).info) as usize - ptr as usize }, - 88usize, - "Offset of field: _SYMCRYPT_ECURVE::info" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FMod) as usize - ptr as usize }, - 616usize, - "Offset of field: _SYMCRYPT_ECURVE::FMod" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrd) as usize - ptr as usize }, - 624usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrd" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).A) as usize - ptr as usize }, - 632usize, - "Offset of field: _SYMCRYPT_ECURVE::A" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).B) as usize - ptr as usize }, - 640usize, - "Offset of field: _SYMCRYPT_ECURVE::B" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).G) as usize - ptr as usize }, - 648usize, - "Offset of field: _SYMCRYPT_ECURVE::G" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 656usize, - "Offset of field: _SYMCRYPT_ECURVE::H" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 664usize, - "Offset of field: _SYMCRYPT_ECURVE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_ECURVE"][::std::mem::size_of::<_SYMCRYPT_ECURVE>() - 672usize]; + ["Alignment of _SYMCRYPT_ECURVE"][::std::mem::align_of::<_SYMCRYPT_ECURVE>() - 32usize]; + ["Offset of field: _SYMCRYPT_ECURVE::version"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, version) - 0usize]; + ["Offset of field: _SYMCRYPT_ECURVE::type_"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, type_) - 4usize]; + ["Offset of field: _SYMCRYPT_ECURVE::eCoordinates"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, eCoordinates) - 8usize]; + ["Offset of field: _SYMCRYPT_ECURVE::FModBitsize"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, FModBitsize) - 12usize]; + ["Offset of field: _SYMCRYPT_ECURVE::FModDigits"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, FModDigits) - 16usize]; + ["Offset of field: _SYMCRYPT_ECURVE::FModBytesize"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, FModBytesize) - 20usize]; + ["Offset of field: _SYMCRYPT_ECURVE::GOrdBitsize"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, GOrdBitsize) - 24usize]; + ["Offset of field: _SYMCRYPT_ECURVE::GOrdDigits"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, GOrdDigits) - 28usize]; + ["Offset of field: _SYMCRYPT_ECURVE::GOrdBytesize"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, GOrdBytesize) - 32usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbModElement"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbModElement) - 36usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbAlloc"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbAlloc) - 40usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbScratchCommon"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbScratchCommon) - 44usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbScratchScalar"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbScratchScalar) - 48usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbScratchScalarMulti"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbScratchScalarMulti) - 52usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbScratchGetSetValue"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbScratchGetSetValue) - 56usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbScratchEckey"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbScratchEckey) - 60usize]; + ["Offset of field: _SYMCRYPT_ECURVE::coFactorPower"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, coFactorPower) - 64usize]; + ["Offset of field: _SYMCRYPT_ECURVE::PrivateKeyDefaultFormat"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, PrivateKeyDefaultFormat) - 68usize]; + ["Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionNumOfBits"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, HighBitRestrictionNumOfBits) - 72usize]; + ["Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionPosition"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, HighBitRestrictionPosition) - 76usize]; + ["Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionValue"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, HighBitRestrictionValue) - 80usize]; + ["Offset of field: _SYMCRYPT_ECURVE::info"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, info) - 88usize]; + ["Offset of field: _SYMCRYPT_ECURVE::FMod"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, FMod) - 616usize]; + ["Offset of field: _SYMCRYPT_ECURVE::GOrd"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, GOrd) - 624usize]; + ["Offset of field: _SYMCRYPT_ECURVE::A"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, A) - 632usize]; + ["Offset of field: _SYMCRYPT_ECURVE::B"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, B) - 640usize]; + ["Offset of field: _SYMCRYPT_ECURVE::G"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, G) - 648usize]; + ["Offset of field: _SYMCRYPT_ECURVE::H"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, H) - 656usize]; + ["Offset of field: _SYMCRYPT_ECURVE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, magic) - 664usize]; +}; impl Default for _SYMCRYPT_ECURVE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -4078,36 +2528,17 @@ pub struct _SYMCRYPT_ECPOINT { pub pCurve: PCSYMCRYPT_ECURVE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_ECPOINT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECPOINT> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECPOINT>(), - 32usize, - "Size of _SYMCRYPT_ECPOINT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECPOINT>(), - 32usize, - "Alignment of _SYMCRYPT_ECPOINT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).normalized) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECPOINT::normalized" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pCurve) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECPOINT::pCurve" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECPOINT::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_ECPOINT"][::std::mem::size_of::<_SYMCRYPT_ECPOINT>() - 32usize]; + ["Alignment of _SYMCRYPT_ECPOINT"][::std::mem::align_of::<_SYMCRYPT_ECPOINT>() - 32usize]; + ["Offset of field: _SYMCRYPT_ECPOINT::normalized"] + [::std::mem::offset_of!(_SYMCRYPT_ECPOINT, normalized) - 0usize]; + ["Offset of field: _SYMCRYPT_ECPOINT::pCurve"] + [::std::mem::offset_of!(_SYMCRYPT_ECPOINT, pCurve) - 8usize]; + ["Offset of field: _SYMCRYPT_ECPOINT::magic"] + [::std::mem::offset_of!(_SYMCRYPT_ECPOINT, magic) - 16usize]; +}; impl Default for _SYMCRYPT_ECPOINT { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -4128,51 +2559,23 @@ pub struct _SYMCRYPT_ECKEY { pub piPrivateKey: PSYMCRYPT_INT, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_ECKEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECKEY> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECKEY>(), - 64usize, - "Size of _SYMCRYPT_ECKEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECKEY>(), - 32usize, - "Alignment of _SYMCRYPT_ECKEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fAlgorithmInfo) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECKEY::fAlgorithmInfo" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hasPrivateKey) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECKEY::hasPrivateKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pCurve) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECKEY::pCurve" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).poPublicKey) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECKEY::poPublicKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).piPrivateKey) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_ECKEY::piPrivateKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_ECKEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_ECKEY"][::std::mem::size_of::<_SYMCRYPT_ECKEY>() - 64usize]; + ["Alignment of _SYMCRYPT_ECKEY"][::std::mem::align_of::<_SYMCRYPT_ECKEY>() - 32usize]; + ["Offset of field: _SYMCRYPT_ECKEY::fAlgorithmInfo"] + [::std::mem::offset_of!(_SYMCRYPT_ECKEY, fAlgorithmInfo) - 0usize]; + ["Offset of field: _SYMCRYPT_ECKEY::hasPrivateKey"] + [::std::mem::offset_of!(_SYMCRYPT_ECKEY, hasPrivateKey) - 4usize]; + ["Offset of field: _SYMCRYPT_ECKEY::pCurve"] + [::std::mem::offset_of!(_SYMCRYPT_ECKEY, pCurve) - 8usize]; + ["Offset of field: _SYMCRYPT_ECKEY::poPublicKey"] + [::std::mem::offset_of!(_SYMCRYPT_ECKEY, poPublicKey) - 16usize]; + ["Offset of field: _SYMCRYPT_ECKEY::piPrivateKey"] + [::std::mem::offset_of!(_SYMCRYPT_ECKEY, piPrivateKey) - 24usize]; + ["Offset of field: _SYMCRYPT_ECKEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_ECKEY, magic) - 32usize]; +}; impl Default for _SYMCRYPT_ECKEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -4185,188 +2588,183 @@ impl Default for _SYMCRYPT_ECKEY { pub type SYMCRYPT_ECKEY = _SYMCRYPT_ECKEY; pub type PSYMCRYPT_ECKEY = *mut SYMCRYPT_ECKEY; pub type PCSYMCRYPT_ECKEY = *const SYMCRYPT_ECKEY; -extern "C" { +unsafe extern "C" { pub fn SymCryptWipe(pbData: PVOID, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptLoadMsbFirstUint64( pbSrc: PCBYTE, cbSrc: SIZE_T, pDst: PUINT64, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptStoreMsbFirstUint64(src: UINT64, pbDst: PBYTE, cbDst: SIZE_T) -> SYMCRYPT_ERROR; } -#[cfg(not(feature = "dynamic"))] -extern "C" { - pub fn SymCryptInit(); -} -#[cfg(feature = "dynamic")] -extern "C" { +unsafe extern "C" { pub fn SymCryptModuleInit(api: UINT32, minor: UINT32); } -extern "C" { +unsafe extern "C" { pub fn SymCryptMd5(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptMd5Init(pState: PSYMCRYPT_MD5_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptMd5Append(pState: PSYMCRYPT_MD5_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptMd5Result(pState: PSYMCRYPT_MD5_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptMd5StateCopy(pSrc: PCSYMCRYPT_MD5_STATE, pDst: PSYMCRYPT_MD5_STATE); } -extern "C" { +unsafe extern "C" { pub static SymCryptMd5Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha1(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha1Init(pState: PSYMCRYPT_SHA1_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha1Append(pState: PSYMCRYPT_SHA1_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha1Result(pState: PSYMCRYPT_SHA1_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha1StateCopy(pSrc: PCSYMCRYPT_SHA1_STATE, pDst: PSYMCRYPT_SHA1_STATE); } -extern "C" { +unsafe extern "C" { pub static SymCryptSha1Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha256(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha256Init(pState: PSYMCRYPT_SHA256_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha256Append(pState: PSYMCRYPT_SHA256_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha256Result(pState: PSYMCRYPT_SHA256_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha256StateCopy(pSrc: PCSYMCRYPT_SHA256_STATE, pDst: PSYMCRYPT_SHA256_STATE); } -extern "C" { +unsafe extern "C" { pub static SymCryptSha256Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha384(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha384Init(pState: PSYMCRYPT_SHA384_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha384Append(pState: PSYMCRYPT_SHA384_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha384Result(pState: PSYMCRYPT_SHA384_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha384StateCopy(pSrc: PCSYMCRYPT_SHA384_STATE, pDst: PSYMCRYPT_SHA384_STATE); } -extern "C" { +unsafe extern "C" { pub static SymCryptSha384Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha512(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha512Init(pState: PSYMCRYPT_SHA512_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha512Append(pState: PSYMCRYPT_SHA512_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha512Result(pState: PSYMCRYPT_SHA512_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha512StateCopy(pSrc: PCSYMCRYPT_SHA512_STATE, pDst: PSYMCRYPT_SHA512_STATE); } -extern "C" { +unsafe extern "C" { pub static SymCryptSha512Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_256(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_256Init(pState: PSYMCRYPT_SHA3_256_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_256Append(pState: PSYMCRYPT_SHA3_256_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_256Result(pState: PSYMCRYPT_SHA3_256_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_256StateCopy( pSrc: PCSYMCRYPT_SHA3_256_STATE, pDst: PSYMCRYPT_SHA3_256_STATE, ); } -extern "C" { +unsafe extern "C" { pub static SymCryptSha3_256Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_384(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_384Init(pState: PSYMCRYPT_SHA3_384_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_384Append(pState: PSYMCRYPT_SHA3_384_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_384Result(pState: PSYMCRYPT_SHA3_384_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_384StateCopy( pSrc: PCSYMCRYPT_SHA3_384_STATE, pDst: PSYMCRYPT_SHA3_384_STATE, ); } -extern "C" { +unsafe extern "C" { pub static SymCryptSha3_384Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_512(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_512Init(pState: PSYMCRYPT_SHA3_512_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_512Append(pState: PSYMCRYPT_SHA3_512_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_512Result(pState: PSYMCRYPT_SHA3_512_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_512StateCopy( pSrc: PCSYMCRYPT_SHA3_512_STATE, pDst: PSYMCRYPT_SHA3_512_STATE, ); } -extern "C" { +unsafe extern "C" { pub static SymCryptSha3_512Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacMd5ExpandKey( pExpandedKey: PSYMCRYPT_HMAC_MD5_EXPANDED_KEY, pbKey: PCBYTE, cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacMd5( pExpandedKey: PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY, pbData: PCBYTE, @@ -4374,36 +2772,36 @@ extern "C" { pbResult: PBYTE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacMd5StateCopy( pSrc: PCSYMCRYPT_HMAC_MD5_STATE, pExpandedKey: PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY, pDst: PSYMCRYPT_HMAC_MD5_STATE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacMd5Init( pState: PSYMCRYPT_HMAC_MD5_STATE, pExpandedKey: PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacMd5Append(pState: PSYMCRYPT_HMAC_MD5_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacMd5Result(pState: PSYMCRYPT_HMAC_MD5_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub static SymCryptHmacMd5Algorithm: PCSYMCRYPT_MAC; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha1ExpandKey( pExpandedKey: PSYMCRYPT_HMAC_SHA1_EXPANDED_KEY, pbKey: PCBYTE, cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha1( pExpandedKey: PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY, pbData: PCBYTE, @@ -4411,40 +2809,40 @@ extern "C" { pbResult: PBYTE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha1StateCopy( pSrc: PCSYMCRYPT_HMAC_SHA1_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY, pDst: PSYMCRYPT_HMAC_SHA1_STATE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha1Init( pState: PSYMCRYPT_HMAC_SHA1_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha1Append( pState: PSYMCRYPT_HMAC_SHA1_STATE, pbData: PCBYTE, cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha1Result(pState: PSYMCRYPT_HMAC_SHA1_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub static SymCryptHmacSha1Algorithm: PCSYMCRYPT_MAC; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha256ExpandKey( pExpandedKey: PSYMCRYPT_HMAC_SHA256_EXPANDED_KEY, pbKey: PCBYTE, cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha256( pExpandedKey: PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY, pbData: PCBYTE, @@ -4452,40 +2850,40 @@ extern "C" { pbResult: PBYTE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha256StateCopy( pSrc: PCSYMCRYPT_HMAC_SHA256_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY, pDst: PSYMCRYPT_HMAC_SHA256_STATE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha256Init( pState: PSYMCRYPT_HMAC_SHA256_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha256Append( pState: PSYMCRYPT_HMAC_SHA256_STATE, pbData: PCBYTE, cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha256Result(pState: PSYMCRYPT_HMAC_SHA256_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub static SymCryptHmacSha256Algorithm: PCSYMCRYPT_MAC; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha384ExpandKey( pExpandedKey: PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, pbKey: PCBYTE, cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha384( pExpandedKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, pbData: PCBYTE, @@ -4493,40 +2891,40 @@ extern "C" { pbResult: PBYTE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha384StateCopy( pSrc: PCSYMCRYPT_HMAC_SHA384_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, pDst: PSYMCRYPT_HMAC_SHA384_STATE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha384Init( pState: PSYMCRYPT_HMAC_SHA384_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha384Append( pState: PSYMCRYPT_HMAC_SHA384_STATE, pbData: PCBYTE, cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha384Result(pState: PSYMCRYPT_HMAC_SHA384_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub static SymCryptHmacSha384Algorithm: PCSYMCRYPT_MAC; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha512ExpandKey( pExpandedKey: PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, pbKey: PCBYTE, cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha512( pExpandedKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, pbData: PCBYTE, @@ -4534,33 +2932,33 @@ extern "C" { pbResult: PBYTE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha512StateCopy( pSrc: PCSYMCRYPT_HMAC_SHA512_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, pDst: PSYMCRYPT_HMAC_SHA512_STATE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha512Init( pState: PSYMCRYPT_HMAC_SHA512_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha512Append( pState: PSYMCRYPT_HMAC_SHA512_STATE, pbData: PCBYTE, cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha512Result(pState: PSYMCRYPT_HMAC_SHA512_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub static SymCryptHmacSha512Algorithm: PCSYMCRYPT_MAC; } -extern "C" { +unsafe extern "C" { pub fn SymCryptChaCha20Poly1305Encrypt( pbKey: PCBYTE, cbKey: SIZE_T, @@ -4575,7 +2973,7 @@ extern "C" { cbTag: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptChaCha20Poly1305Decrypt( pbKey: PCBYTE, cbKey: SIZE_T, @@ -4590,14 +2988,14 @@ extern "C" { cbTag: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptAesExpandKey( pExpandedKey: PSYMCRYPT_AES_EXPANDED_KEY, pbKey: PCBYTE, cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptAesCbcEncrypt( pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY, pbChainingValue: PBYTE, @@ -4606,7 +3004,7 @@ extern "C" { cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptAesCbcDecrypt( pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY, pbChainingValue: PBYTE, @@ -4615,10 +3013,10 @@ extern "C" { cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub static SymCryptAesBlockCipher: PCSYMCRYPT_BLOCKCIPHER; } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmValidateParameters( pBlockCipher: PCSYMCRYPT_BLOCKCIPHER, cbNonce: SIZE_T, @@ -4627,7 +3025,7 @@ extern "C" { cbTag: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmExpandKey( pExpandedKey: PSYMCRYPT_GCM_EXPANDED_KEY, pBlockCipher: PCSYMCRYPT_BLOCKCIPHER, @@ -4635,7 +3033,7 @@ extern "C" { cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmEncrypt( pExpandedKey: PCSYMCRYPT_GCM_EXPANDED_KEY, pbNonce: PCBYTE, @@ -4649,7 +3047,7 @@ extern "C" { cbTag: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmDecrypt( pExpandedKey: PCSYMCRYPT_GCM_EXPANDED_KEY, pbNonce: PCBYTE, @@ -4663,7 +3061,7 @@ extern "C" { cbTag: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmInit( pState: PSYMCRYPT_GCM_STATE, pExpandedKey: PCSYMCRYPT_GCM_EXPANDED_KEY, @@ -4671,17 +3069,17 @@ extern "C" { cbNonce: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmStateCopy( pSrc: PCSYMCRYPT_GCM_STATE, pExpandedKeyCopy: PCSYMCRYPT_GCM_EXPANDED_KEY, pDst: PSYMCRYPT_GCM_STATE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmAuthPart(pState: PSYMCRYPT_GCM_STATE, pbAuthData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmEncryptPart( pState: PSYMCRYPT_GCM_STATE, pbSrc: PCBYTE, @@ -4689,10 +3087,10 @@ extern "C" { cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmEncryptFinal(pState: PSYMCRYPT_GCM_STATE, pbTag: PBYTE, cbTag: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmDecryptPart( pState: PSYMCRYPT_GCM_STATE, pbSrc: PCBYTE, @@ -4700,14 +3098,58 @@ extern "C" { cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmDecryptFinal( pState: PSYMCRYPT_GCM_STATE, pbTag: PCBYTE, cbTag: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { + pub fn SymCryptSp800_108ExpandKey( + pExpandedKey: PSYMCRYPT_SP800_108_EXPANDED_KEY, + macAlgorithm: PCSYMCRYPT_MAC, + pbKey: PCBYTE, + cbKey: SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptSp800_108Derive( + pExpandedKey: PCSYMCRYPT_SP800_108_EXPANDED_KEY, + pbLabel: PCBYTE, + cbLabel: SIZE_T, + pbContext: PCBYTE, + cbContext: SIZE_T, + pbResult: PBYTE, + cbResult: SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptSp800_108( + macAlgorithm: PCSYMCRYPT_MAC, + pbKey: PCBYTE, + cbKey: SIZE_T, + pbLabel: PCBYTE, + cbLabel: SIZE_T, + pbContext: PCBYTE, + cbContext: SIZE_T, + pbResult: PBYTE, + cbResult: SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptSp800_108_HmacSha1SelfTest(); +} +unsafe extern "C" { + pub fn SymCryptSp800_108_HmacSha256SelfTest(); +} +unsafe extern "C" { + pub fn SymCryptSp800_108_HmacSha384SelfTest(); +} +unsafe extern "C" { + pub fn SymCryptSp800_108_HmacSha512SelfTest(); +} +unsafe extern "C" { pub fn SymCryptTlsPrf1_2ExpandKey( pExpandedKey: PSYMCRYPT_TLSPRF1_2_EXPANDED_KEY, macAlgorithm: PCSYMCRYPT_MAC, @@ -4715,7 +3157,7 @@ extern "C" { cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptTlsPrf1_2Derive( pExpandedKey: PCSYMCRYPT_TLSPRF1_2_EXPANDED_KEY, pbLabel: PCBYTE, @@ -4726,7 +3168,7 @@ extern "C" { cbResult: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptTlsPrf1_2( macAlgorithm: PCSYMCRYPT_MAC, pbKey: PCBYTE, @@ -4739,7 +3181,7 @@ extern "C" { cbResult: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHkdfExpandKey( pExpandedKey: PSYMCRYPT_HKDF_EXPANDED_KEY, macAlgorithm: PCSYMCRYPT_MAC, @@ -4749,7 +3191,7 @@ extern "C" { cbSalt: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHkdfExtractPrk( macAlgorithm: PCSYMCRYPT_MAC, pbIkm: PCBYTE, @@ -4760,7 +3202,7 @@ extern "C" { cbPrk: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHkdfPrkExpandKey( pExpandedKey: PSYMCRYPT_HKDF_EXPANDED_KEY, macAlgorithm: PCSYMCRYPT_MAC, @@ -4768,7 +3210,7 @@ extern "C" { cbPrk: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHkdfDerive( pExpandedKey: PCSYMCRYPT_HKDF_EXPANDED_KEY, pbInfo: PCBYTE, @@ -4777,7 +3219,7 @@ extern "C" { cbResult: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHkdf( macAlgorithm: PCSYMCRYPT_MAC, pbIkm: PCBYTE, @@ -4790,16 +3232,112 @@ extern "C" { cbResult: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHkdfSelfTest(); } -#[cfg(feature = "dynamic")] -extern "C" { +unsafe extern "C" { pub fn SymCryptRandom(pbRandom: PBYTE, cbRandom: SIZE_T); } -#[cfg(not(feature = "dynamic"))] -extern "C" { - pub fn SymCryptCallbackRandom(pbBuffer: PBYTE, cbBuffer: SIZE_T) -> SYMCRYPT_ERROR; +unsafe extern "C" { + pub fn SymCryptXtsAesExpandKey( + pExpandedKey: PSYMCRYPT_XTS_AES_EXPANDED_KEY, + pbKey: PCBYTE, + cbKey: SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptXtsAesExpandKeyEx( + pExpandedKey: PSYMCRYPT_XTS_AES_EXPANDED_KEY, + pbKey: PCBYTE, + cbKey: SIZE_T, + flags: UINT32, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptXtsAesKeyCopy( + pSrc: PCSYMCRYPT_XTS_AES_EXPANDED_KEY, + pDst: PSYMCRYPT_XTS_AES_EXPANDED_KEY, + ); +} +unsafe extern "C" { + pub fn SymCryptXtsAesEncrypt( + pExpandedKey: PCSYMCRYPT_XTS_AES_EXPANDED_KEY, + cbDataUnit: SIZE_T, + tweak: UINT64, + pbSrc: PCBYTE, + pbDst: PBYTE, + cbData: SIZE_T, + ); +} +unsafe extern "C" { + pub fn SymCryptXtsAesDecrypt( + pExpandedKey: PCSYMCRYPT_XTS_AES_EXPANDED_KEY, + cbDataUnit: SIZE_T, + tweak: UINT64, + pbSrc: PCBYTE, + pbDst: PBYTE, + cbData: SIZE_T, + ); +} +unsafe extern "C" { + pub fn SymCryptXtsAesEncryptWith128bTweak( + pExpandedKey: PCSYMCRYPT_XTS_AES_EXPANDED_KEY, + cbDataUnit: SIZE_T, + pbTweak: PCBYTE, + pbSrc: PCBYTE, + pbDst: PBYTE, + cbData: SIZE_T, + ); +} +unsafe extern "C" { + pub fn SymCryptXtsAesDecryptWith128bTweak( + pExpandedKey: PCSYMCRYPT_XTS_AES_EXPANDED_KEY, + cbDataUnit: SIZE_T, + pbTweak: PCBYTE, + pbSrc: PCBYTE, + pbDst: PBYTE, + cbData: SIZE_T, + ); +} +unsafe extern "C" { + pub fn SymCryptAesKwEncrypt( + pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY, + pbSrc: PCBYTE, + cbSrc: SIZE_T, + pbDst: PBYTE, + cbDst: SIZE_T, + pcbResult: *mut SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptAesKwDecrypt( + pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY, + pbSrc: PCBYTE, + cbSrc: SIZE_T, + pbDst: PBYTE, + cbDst: SIZE_T, + pcbResult: *mut SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptAesKwpEncrypt( + pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY, + pbSrc: PCBYTE, + cbSrc: SIZE_T, + pbDst: PBYTE, + cbDst: SIZE_T, + pcbResult: *mut SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptAesKwpDecrypt( + pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY, + pbSrc: PCBYTE, + cbSrc: SIZE_T, + pbDst: PBYTE, + cbDst: SIZE_T, + pcbResult: *mut SIZE_T, + ) -> SYMCRYPT_ERROR; } pub const _SYMCRYPT_NUMBER_FORMAT_SYMCRYPT_NUMBER_FORMAT_LSB_FIRST: _SYMCRYPT_NUMBER_FORMAT = 1; pub const _SYMCRYPT_NUMBER_FORMAT_SYMCRYPT_NUMBER_FORMAT_MSB_FIRST: _SYMCRYPT_NUMBER_FORMAT = 2; @@ -4813,41 +3351,19 @@ pub struct _SYMCRYPT_RSA_PARAMS { pub nPrimes: UINT32, pub nPubExp: UINT32, } -#[test] -fn bindgen_test_layout__SYMCRYPT_RSA_PARAMS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_RSA_PARAMS> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_RSA_PARAMS>(), - 16usize, - "Size of _SYMCRYPT_RSA_PARAMS" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_RSA_PARAMS>(), - 4usize, - "Alignment of _SYMCRYPT_RSA_PARAMS" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_RSA_PARAMS::version" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBitsOfModulus) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_RSA_PARAMS::nBitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPrimes) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_RSA_PARAMS::nPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPubExp) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_RSA_PARAMS::nPubExp" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_RSA_PARAMS"][::std::mem::size_of::<_SYMCRYPT_RSA_PARAMS>() - 16usize]; + ["Alignment of _SYMCRYPT_RSA_PARAMS"][::std::mem::align_of::<_SYMCRYPT_RSA_PARAMS>() - 4usize]; + ["Offset of field: _SYMCRYPT_RSA_PARAMS::version"] + [::std::mem::offset_of!(_SYMCRYPT_RSA_PARAMS, version) - 0usize]; + ["Offset of field: _SYMCRYPT_RSA_PARAMS::nBitsOfModulus"] + [::std::mem::offset_of!(_SYMCRYPT_RSA_PARAMS, nBitsOfModulus) - 4usize]; + ["Offset of field: _SYMCRYPT_RSA_PARAMS::nPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSA_PARAMS, nPrimes) - 8usize]; + ["Offset of field: _SYMCRYPT_RSA_PARAMS::nPubExp"] + [::std::mem::offset_of!(_SYMCRYPT_RSA_PARAMS, nPubExp) - 12usize]; +}; pub type SYMCRYPT_RSA_PARAMS = _SYMCRYPT_RSA_PARAMS; pub type PCSYMCRYPT_RSA_PARAMS = *const SYMCRYPT_RSA_PARAMS; pub const _SYMCRYPT_ECURVE_GEN_ALG_ID_SYMCRYPT_ECURVE_GEN_ALG_ID_NULL: _SYMCRYPT_ECURVE_GEN_ALG_ID = @@ -4865,57 +3381,26 @@ pub struct _SYMCRYPT_ECURVE_PARAMS { pub cbCofactor: UINT32, pub cbSeed: UINT32, } -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE_PARAMS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE_PARAMS> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE_PARAMS>(), - 28usize, - "Size of _SYMCRYPT_ECURVE_PARAMS" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE_PARAMS>(), - 4usize, - "Alignment of _SYMCRYPT_ECURVE_PARAMS" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::version" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).algId) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::algId" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbFieldLength) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbFieldLength" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSubgroupOrder) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbSubgroupOrder" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbCofactor) as usize - ptr as usize }, - 20usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbCofactor" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSeed) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbSeed" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_ECURVE_PARAMS"][::std::mem::size_of::<_SYMCRYPT_ECURVE_PARAMS>() - 28usize]; + ["Alignment of _SYMCRYPT_ECURVE_PARAMS"] + [::std::mem::align_of::<_SYMCRYPT_ECURVE_PARAMS>() - 4usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::version"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, version) - 0usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::type_"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, type_) - 4usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::algId"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, algId) - 8usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbFieldLength"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, cbFieldLength) - 12usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbSubgroupOrder"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, cbSubgroupOrder) - 16usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbCofactor"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, cbCofactor) - 20usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbSeed"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, cbSeed) - 24usize]; +}; impl Default for _SYMCRYPT_ECURVE_PARAMS { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -4931,52 +3416,52 @@ pub const _SYMCRYPT_ECPOINT_FORMAT_SYMCRYPT_ECPOINT_FORMAT_X: _SYMCRYPT_ECPOINT_ pub const _SYMCRYPT_ECPOINT_FORMAT_SYMCRYPT_ECPOINT_FORMAT_XY: _SYMCRYPT_ECPOINT_FORMAT = 2; pub type _SYMCRYPT_ECPOINT_FORMAT = ::std::os::raw::c_uint; pub use self::_SYMCRYPT_ECPOINT_FORMAT as SYMCRYPT_ECPOINT_FORMAT; -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyAllocate( pParams: PCSYMCRYPT_RSA_PARAMS, flags: UINT32, ) -> PSYMCRYPT_RSAKEY; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyFree(pkObj: PSYMCRYPT_RSAKEY); } -extern "C" { +unsafe extern "C" { pub fn SymCryptEcurveAllocate( pParams: PCSYMCRYPT_ECURVE_PARAMS, flags: UINT32, ) -> PSYMCRYPT_ECURVE; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEcurveFree(pCurve: PSYMCRYPT_ECURVE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeyAllocate(pCurve: PCSYMCRYPT_ECURVE) -> PSYMCRYPT_ECKEY; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeyFree(pkObj: PSYMCRYPT_ECKEY); } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyHasPrivateKey(pkRsakey: PCSYMCRYPT_RSAKEY) -> BOOLEAN; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeySizeofModulus(pkRsakey: PCSYMCRYPT_RSAKEY) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyModulusBits(pkRsakey: PCSYMCRYPT_RSAKEY) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeySizeofPublicExponent(pRsakey: PCSYMCRYPT_RSAKEY, index: UINT32) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeySizeofPrime(pkRsakey: PCSYMCRYPT_RSAKEY, index: UINT32) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyGetNumberOfPublicExponents(pkRsakey: PCSYMCRYPT_RSAKEY) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyGetNumberOfPrimes(pkRsakey: PCSYMCRYPT_RSAKEY) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyGenerate( pkRsakey: PSYMCRYPT_RSAKEY, pu64PubExp: PCUINT64, @@ -4984,7 +3469,7 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeySetValue( pbModulus: PCBYTE, cbModulus: SIZE_T, @@ -4998,7 +3483,7 @@ extern "C" { pkRsakey: PSYMCRYPT_RSAKEY, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeySetValueFromPrivateExponent( pbModulus: PCBYTE, cbModulus: SIZE_T, @@ -5010,7 +3495,7 @@ extern "C" { pkRsakey: PSYMCRYPT_RSAKEY, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyGetValue( pkRsakey: PCSYMCRYPT_RSAKEY, pbModulus: PBYTE, @@ -5024,7 +3509,7 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyGetCrtValue( pkRsakey: PCSYMCRYPT_RSAKEY, ppCrtExponents: *mut PBYTE, @@ -5038,37 +3523,37 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyExtendKeyUsage( pkRsakey: PSYMCRYPT_RSAKEY, flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEcurveSizeofFieldElement(pCurve: PCSYMCRYPT_ECURVE) -> UINT32; } -extern "C" { +unsafe extern "C" { pub static SymCryptEcurveParamsNistP256: PCSYMCRYPT_ECURVE_PARAMS; } -extern "C" { +unsafe extern "C" { pub static SymCryptEcurveParamsNistP384: PCSYMCRYPT_ECURVE_PARAMS; } -extern "C" { +unsafe extern "C" { pub static SymCryptEcurveParamsNistP521: PCSYMCRYPT_ECURVE_PARAMS; } -extern "C" { +unsafe extern "C" { pub static SymCryptEcurveParamsCurve25519: PCSYMCRYPT_ECURVE_PARAMS; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeySizeofPublicKey( pkEckey: PCSYMCRYPT_ECKEY, ecPointFormat: SYMCRYPT_ECPOINT_FORMAT, ) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeySizeofPrivateKey(pkEckey: PCSYMCRYPT_ECKEY) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeySetValue( pbPrivateKey: PCBYTE, cbPrivateKey: SIZE_T, @@ -5080,10 +3565,10 @@ extern "C" { pEckey: PSYMCRYPT_ECKEY, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeySetRandom(flags: UINT32, pEckey: PSYMCRYPT_ECKEY) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeyGetValue( pEckey: PCSYMCRYPT_ECKEY, pbPrivateKey: PBYTE, @@ -5095,7 +3580,7 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaPkcs1Encrypt( pkRsakey: PCSYMCRYPT_RSAKEY, pbSrc: PCBYTE, @@ -5107,7 +3592,7 @@ extern "C" { pcbDst: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaPkcs1Decrypt( pkRsakey: PCSYMCRYPT_RSAKEY, pbSrc: PCBYTE, @@ -5119,7 +3604,7 @@ extern "C" { pcbDst: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaOaepEncrypt( pkRsakey: PCSYMCRYPT_RSAKEY, pbSrc: PCBYTE, @@ -5134,7 +3619,7 @@ extern "C" { pcbDst: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaOaepDecrypt( pkRsakey: PCSYMCRYPT_RSAKEY, pbSrc: PCBYTE, @@ -5149,7 +3634,7 @@ extern "C" { pcbDst: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaPkcs1Sign( pkRsakey: PCSYMCRYPT_RSAKEY, pbHashValue: PCBYTE, @@ -5163,7 +3648,7 @@ extern "C" { pcbSignature: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaPkcs1Verify( pkRsakey: PCSYMCRYPT_RSAKEY, pbHashValue: PCBYTE, @@ -5176,7 +3661,7 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaPssSign( pkRsakey: PCSYMCRYPT_RSAKEY, pbHashValue: PCBYTE, @@ -5190,7 +3675,7 @@ extern "C" { pcbSignature: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaPssVerify( pkRsakey: PCSYMCRYPT_RSAKEY, pbHashValue: PCBYTE, @@ -5203,7 +3688,7 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEcDsaSign( pKey: PCSYMCRYPT_ECKEY, pbHashValue: PCBYTE, @@ -5214,7 +3699,7 @@ extern "C" { cbSignature: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEcDsaVerify( pKey: PCSYMCRYPT_ECKEY, pbHashValue: PCBYTE, @@ -5225,7 +3710,7 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEcDhSecretAgreement( pkPrivate: PCSYMCRYPT_ECKEY, pkPublic: PCSYMCRYPT_ECKEY, diff --git a/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs b/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs index bbbedfb9..ff2e446c 100644 --- a/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs +++ b/symcrypt-sys/src/bindings/x86_64_pc_windows_msvc.rs @@ -72,32 +72,17 @@ pub struct _SYMCRYPT_MD2_CHAINING_STATE { pub C: [BYTE; 16usize], pub X: [BYTE; 48usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_MD2_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD2_CHAINING_STATE>(), - 64usize, - "Size of _SYMCRYPT_MD2_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD2_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD2_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).C) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::C" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::X" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MD2_CHAINING_STATE"] + [::std::mem::size_of::<_SYMCRYPT_MD2_CHAINING_STATE>() - 64usize]; + ["Alignment of _SYMCRYPT_MD2_CHAINING_STATE"] + [::std::mem::align_of::<_SYMCRYPT_MD2_CHAINING_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::C"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_CHAINING_STATE, C) - 0usize]; + ["Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::X"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_CHAINING_STATE, X) - 16usize]; +}; impl Default for _SYMCRYPT_MD2_CHAINING_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -119,51 +104,23 @@ pub struct _SYMCRYPT_MD2_STATE { pub buffer: [BYTE; 16usize], pub chain: SYMCRYPT_MD2_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MD2_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD2_STATE>(), - 112usize, - "Size of _SYMCRYPT_MD2_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD2_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD2_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD2_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MD2_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MD2_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MD2_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MD2_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_MD2_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MD2_STATE"][::std::mem::size_of::<_SYMCRYPT_MD2_STATE>() - 112usize]; + ["Alignment of _SYMCRYPT_MD2_STATE"][::std::mem::align_of::<_SYMCRYPT_MD2_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_MD2_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_MD2_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_MD2_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_MD2_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_MD2_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_MD2_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_STATE, chain) - 48usize]; +}; impl Default for _SYMCRYPT_MD2_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -180,27 +137,15 @@ pub type SYMCRYPT_MD2_STATE = _SYMCRYPT_MD2_STATE; pub struct _SYMCRYPT_MD4_CHAINING_STATE { pub H: [UINT32; 4usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_MD4_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD4_CHAINING_STATE>(), - 16usize, - "Size of _SYMCRYPT_MD4_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD4_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD4_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD4_CHAINING_STATE::H" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MD4_CHAINING_STATE"] + [::std::mem::size_of::<_SYMCRYPT_MD4_CHAINING_STATE>() - 16usize]; + ["Alignment of _SYMCRYPT_MD4_CHAINING_STATE"] + [::std::mem::align_of::<_SYMCRYPT_MD4_CHAINING_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_MD4_CHAINING_STATE::H"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_CHAINING_STATE, H) - 0usize]; +}; pub type SYMCRYPT_MD4_CHAINING_STATE = _SYMCRYPT_MD4_CHAINING_STATE; #[repr(C)] #[repr(align(16))] @@ -213,51 +158,23 @@ pub struct _SYMCRYPT_MD4_STATE { pub buffer: [BYTE; 64usize], pub chain: SYMCRYPT_MD4_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MD4_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD4_STATE>(), - 112usize, - "Size of _SYMCRYPT_MD4_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD4_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD4_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD4_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MD4_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MD4_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MD4_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MD4_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_MD4_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MD4_STATE"][::std::mem::size_of::<_SYMCRYPT_MD4_STATE>() - 112usize]; + ["Alignment of _SYMCRYPT_MD4_STATE"][::std::mem::align_of::<_SYMCRYPT_MD4_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_MD4_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_MD4_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_MD4_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_MD4_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_MD4_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_MD4_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_STATE, chain) - 96usize]; +}; impl Default for _SYMCRYPT_MD4_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -274,27 +191,15 @@ pub type SYMCRYPT_MD4_STATE = _SYMCRYPT_MD4_STATE; pub struct _SYMCRYPT_MD5_CHAINING_STATE { pub H: [UINT32; 4usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_MD5_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD5_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD5_CHAINING_STATE>(), - 16usize, - "Size of _SYMCRYPT_MD5_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD5_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD5_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD5_CHAINING_STATE::H" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MD5_CHAINING_STATE"] + [::std::mem::size_of::<_SYMCRYPT_MD5_CHAINING_STATE>() - 16usize]; + ["Alignment of _SYMCRYPT_MD5_CHAINING_STATE"] + [::std::mem::align_of::<_SYMCRYPT_MD5_CHAINING_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_MD5_CHAINING_STATE::H"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_CHAINING_STATE, H) - 0usize]; +}; pub type SYMCRYPT_MD5_CHAINING_STATE = _SYMCRYPT_MD5_CHAINING_STATE; #[repr(C)] #[repr(align(16))] @@ -307,51 +212,23 @@ pub struct _SYMCRYPT_MD5_STATE { pub buffer: [BYTE; 64usize], pub chain: SYMCRYPT_MD5_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MD5_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD5_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD5_STATE>(), - 112usize, - "Size of _SYMCRYPT_MD5_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD5_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD5_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD5_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MD5_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MD5_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MD5_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MD5_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_MD5_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MD5_STATE"][::std::mem::size_of::<_SYMCRYPT_MD5_STATE>() - 112usize]; + ["Alignment of _SYMCRYPT_MD5_STATE"][::std::mem::align_of::<_SYMCRYPT_MD5_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_MD5_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_MD5_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_MD5_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_MD5_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_MD5_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_MD5_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_STATE, chain) - 96usize]; +}; impl Default for _SYMCRYPT_MD5_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -370,27 +247,15 @@ pub type PCSYMCRYPT_MD5_STATE = *const SYMCRYPT_MD5_STATE; pub struct _SYMCRYPT_SHA1_CHAINING_STATE { pub H: [UINT32; 5usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA1_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA1_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA1_CHAINING_STATE>(), - 32usize, - "Size of _SYMCRYPT_SHA1_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA1_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA1_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA1_CHAINING_STATE::H" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA1_CHAINING_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA1_CHAINING_STATE>() - 32usize]; + ["Alignment of _SYMCRYPT_SHA1_CHAINING_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA1_CHAINING_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA1_CHAINING_STATE::H"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_CHAINING_STATE, H) - 0usize]; +}; pub type SYMCRYPT_SHA1_CHAINING_STATE = _SYMCRYPT_SHA1_CHAINING_STATE; #[repr(C)] #[repr(align(16))] @@ -403,51 +268,23 @@ pub struct _SYMCRYPT_SHA1_STATE { pub buffer: [BYTE; 64usize], pub chain: SYMCRYPT_SHA1_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA1_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA1_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA1_STATE>(), - 128usize, - "Size of _SYMCRYPT_SHA1_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA1_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA1_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA1_STATE"][::std::mem::size_of::<_SYMCRYPT_SHA1_STATE>() - 128usize]; + ["Alignment of _SYMCRYPT_SHA1_STATE"][::std::mem::align_of::<_SYMCRYPT_SHA1_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA1_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA1_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA1_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA1_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA1_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA1_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_STATE, chain) - 96usize]; +}; impl Default for _SYMCRYPT_SHA1_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -466,27 +303,15 @@ pub type PCSYMCRYPT_SHA1_STATE = *const SYMCRYPT_SHA1_STATE; pub struct _SYMCRYPT_SHA256_CHAINING_STATE { pub H: [UINT32; 8usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA256_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA256_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA256_CHAINING_STATE>(), - 32usize, - "Size of _SYMCRYPT_SHA256_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA256_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA256_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA256_CHAINING_STATE::H" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA256_CHAINING_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA256_CHAINING_STATE>() - 32usize]; + ["Alignment of _SYMCRYPT_SHA256_CHAINING_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA256_CHAINING_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA256_CHAINING_STATE::H"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_CHAINING_STATE, H) - 0usize]; +}; pub type SYMCRYPT_SHA256_CHAINING_STATE = _SYMCRYPT_SHA256_CHAINING_STATE; #[repr(C)] #[repr(align(16))] @@ -499,52 +324,24 @@ pub struct _SYMCRYPT_SHA256_STATE { pub buffer: [BYTE; 64usize], pub chain: SYMCRYPT_SHA256_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA256_STATE>(), - 128usize, - "Size of _SYMCRYPT_SHA256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA256_STATE"][::std::mem::size_of::<_SYMCRYPT_SHA256_STATE>() - 128usize]; + ["Alignment of _SYMCRYPT_SHA256_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA256_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA256_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA256_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA256_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA256_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA256_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA256_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_STATE, chain) - 96usize]; +}; impl Default for _SYMCRYPT_SHA256_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -568,52 +365,24 @@ pub struct _SYMCRYPT_SHA224_STATE { pub buffer: [BYTE; 64usize], pub chain: SYMCRYPT_SHA256_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA224_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA224_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA224_STATE>(), - 128usize, - "Size of _SYMCRYPT_SHA224_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA224_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA224_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA224_STATE"][::std::mem::size_of::<_SYMCRYPT_SHA224_STATE>() - 128usize]; + ["Alignment of _SYMCRYPT_SHA224_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA224_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA224_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA224_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA224_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA224_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA224_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA224_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA224_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA224_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA224_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA224_STATE, chain) - 96usize]; +}; impl Default for _SYMCRYPT_SHA224_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -630,27 +399,15 @@ pub type SYMCRYPT_SHA224_STATE = _SYMCRYPT_SHA224_STATE; pub struct _SYMCRYPT_SHA512_CHAINING_STATE { pub H: [UINT64; 8usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_CHAINING_STATE>(), - 64usize, - "Size of _SYMCRYPT_SHA512_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_CHAINING_STATE::H" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA512_CHAINING_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA512_CHAINING_STATE>() - 64usize]; + ["Alignment of _SYMCRYPT_SHA512_CHAINING_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA512_CHAINING_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_CHAINING_STATE::H"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_CHAINING_STATE, H) - 0usize]; +}; pub type SYMCRYPT_SHA512_CHAINING_STATE = _SYMCRYPT_SHA512_CHAINING_STATE; #[repr(C)] #[repr(align(16))] @@ -663,52 +420,24 @@ pub struct _SYMCRYPT_SHA512_STATE { pub buffer: [BYTE; 128usize], pub chain: SYMCRYPT_SHA512_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA512_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA512_STATE"][::std::mem::size_of::<_SYMCRYPT_SHA512_STATE>() - 224usize]; + ["Alignment of _SYMCRYPT_SHA512_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA512_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA512_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA512_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA512_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA512_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_STATE, chain) - 160usize]; +}; impl Default for _SYMCRYPT_SHA512_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -732,52 +461,24 @@ pub struct _SYMCRYPT_SHA384_STATE { pub buffer: [BYTE; 128usize], pub chain: SYMCRYPT_SHA512_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA384_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA384_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA384_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA384_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA384_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA384_STATE"][::std::mem::size_of::<_SYMCRYPT_SHA384_STATE>() - 224usize]; + ["Alignment of _SYMCRYPT_SHA384_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA384_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA384_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA384_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA384_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA384_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA384_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA384_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA384_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA384_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA384_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA384_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA384_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA384_STATE, chain) - 160usize]; +}; impl Default for _SYMCRYPT_SHA384_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -801,52 +502,25 @@ pub struct _SYMCRYPT_SHA512_224_STATE { pub buffer: [BYTE; 128usize], pub chain: SYMCRYPT_SHA512_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_224_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_224_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_224_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA512_224_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_224_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_224_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA512_224_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA512_224_STATE>() - 224usize]; + ["Alignment of _SYMCRYPT_SHA512_224_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA512_224_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_224_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_224_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA512_224_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_224_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_224_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_224_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA512_224_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_224_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA512_224_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_224_STATE, chain) - 160usize]; +}; impl Default for _SYMCRYPT_SHA512_224_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -868,52 +542,25 @@ pub struct _SYMCRYPT_SHA512_256_STATE { pub buffer: [BYTE; 128usize], pub chain: SYMCRYPT_SHA512_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_256_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA512_256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA512_256_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA512_256_STATE>() - 224usize]; + ["Alignment of _SYMCRYPT_SHA512_256_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA512_256_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_256_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_256_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA512_256_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_256_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_256_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_256_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA512_256_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_256_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA512_256_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_256_STATE, chain) - 160usize]; +}; impl Default for _SYMCRYPT_SHA512_256_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -934,47 +581,22 @@ pub struct _SYMCRYPT_KECCAK_STATE { pub paddingValue: UINT8, pub squeezeMode: BOOLEAN, } -#[test] -fn bindgen_test_layout__SYMCRYPT_KECCAK_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KECCAK_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KECCAK_STATE>(), - 224usize, - "Size of _SYMCRYPT_KECCAK_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KECCAK_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_KECCAK_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::state" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, - 200usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::inputBlockSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateIndex) as usize - ptr as usize }, - 204usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::stateIndex" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).paddingValue) as usize - ptr as usize }, - 208usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::paddingValue" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).squeezeMode) as usize - ptr as usize }, - 209usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::squeezeMode" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_KECCAK_STATE"][::std::mem::size_of::<_SYMCRYPT_KECCAK_STATE>() - 224usize]; + ["Alignment of _SYMCRYPT_KECCAK_STATE"] + [::std::mem::align_of::<_SYMCRYPT_KECCAK_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_KECCAK_STATE::state"] + [::std::mem::offset_of!(_SYMCRYPT_KECCAK_STATE, state) - 0usize]; + ["Offset of field: _SYMCRYPT_KECCAK_STATE::inputBlockSize"] + [::std::mem::offset_of!(_SYMCRYPT_KECCAK_STATE, inputBlockSize) - 200usize]; + ["Offset of field: _SYMCRYPT_KECCAK_STATE::stateIndex"] + [::std::mem::offset_of!(_SYMCRYPT_KECCAK_STATE, stateIndex) - 204usize]; + ["Offset of field: _SYMCRYPT_KECCAK_STATE::paddingValue"] + [::std::mem::offset_of!(_SYMCRYPT_KECCAK_STATE, paddingValue) - 208usize]; + ["Offset of field: _SYMCRYPT_KECCAK_STATE::squeezeMode"] + [::std::mem::offset_of!(_SYMCRYPT_KECCAK_STATE, squeezeMode) - 209usize]; +}; pub type SYMCRYPT_KECCAK_STATE = _SYMCRYPT_KECCAK_STATE; #[repr(C)] #[repr(align(16))] @@ -983,32 +605,17 @@ pub struct _SYMCRYPT_SHA3_224_STATE { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_224_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_224_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_224_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_224_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_224_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_224_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_224_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_224_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA3_224_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA3_224_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_SHA3_224_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA3_224_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA3_224_STATE::ks"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_224_STATE, ks) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA3_224_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_224_STATE, magic) - 224usize]; +}; pub type SYMCRYPT_SHA3_224_STATE = _SYMCRYPT_SHA3_224_STATE; #[repr(C)] #[repr(align(16))] @@ -1017,32 +624,17 @@ pub struct _SYMCRYPT_SHA3_256_STATE { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_256_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_256_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_256_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA3_256_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA3_256_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_SHA3_256_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA3_256_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA3_256_STATE::ks"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_256_STATE, ks) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA3_256_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_256_STATE, magic) - 224usize]; +}; pub type SYMCRYPT_SHA3_256_STATE = _SYMCRYPT_SHA3_256_STATE; pub type PSYMCRYPT_SHA3_256_STATE = *mut _SYMCRYPT_SHA3_256_STATE; pub type PCSYMCRYPT_SHA3_256_STATE = *const SYMCRYPT_SHA3_256_STATE; @@ -1053,32 +645,17 @@ pub struct _SYMCRYPT_SHA3_384_STATE { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_384_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_384_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_384_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_384_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_384_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_384_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_384_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA3_384_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA3_384_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_SHA3_384_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA3_384_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA3_384_STATE::ks"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_384_STATE, ks) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA3_384_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_384_STATE, magic) - 224usize]; +}; pub type SYMCRYPT_SHA3_384_STATE = _SYMCRYPT_SHA3_384_STATE; pub type PSYMCRYPT_SHA3_384_STATE = *mut _SYMCRYPT_SHA3_384_STATE; pub type PCSYMCRYPT_SHA3_384_STATE = *const SYMCRYPT_SHA3_384_STATE; @@ -1089,32 +666,17 @@ pub struct _SYMCRYPT_SHA3_512_STATE { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_512_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_512_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_512_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_512_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_512_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_512_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_512_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA3_512_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA3_512_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_SHA3_512_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA3_512_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA3_512_STATE::ks"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_512_STATE, ks) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA3_512_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_512_STATE, magic) - 224usize]; +}; pub type SYMCRYPT_SHA3_512_STATE = _SYMCRYPT_SHA3_512_STATE; pub type PSYMCRYPT_SHA3_512_STATE = *mut _SYMCRYPT_SHA3_512_STATE; pub type PCSYMCRYPT_SHA3_512_STATE = *const SYMCRYPT_SHA3_512_STATE; @@ -1125,32 +687,17 @@ pub struct _SYMCRYPT_KMAC128_EXPANDED_KEY { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_KMAC128_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC128_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(), - 240usize, - "Size of _SYMCRYPT_KMAC128_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_KMAC128_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_KMAC128_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>() - 240usize]; + ["Alignment of _SYMCRYPT_KMAC128_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::ks"] + [::std::mem::offset_of!(_SYMCRYPT_KMAC128_EXPANDED_KEY, ks) - 0usize]; + ["Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_KMAC128_EXPANDED_KEY, magic) - 224usize]; +}; pub type SYMCRYPT_KMAC128_EXPANDED_KEY = _SYMCRYPT_KMAC128_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] @@ -1159,32 +706,17 @@ pub struct _SYMCRYPT_KMAC256_EXPANDED_KEY { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_KMAC256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(), - 240usize, - "Size of _SYMCRYPT_KMAC256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_KMAC256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_KMAC256_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>() - 240usize]; + ["Alignment of _SYMCRYPT_KMAC256_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::ks"] + [::std::mem::offset_of!(_SYMCRYPT_KMAC256_EXPANDED_KEY, ks) - 0usize]; + ["Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_KMAC256_EXPANDED_KEY, magic) - 224usize]; +}; pub type SYMCRYPT_KMAC256_EXPANDED_KEY = _SYMCRYPT_KMAC256_EXPANDED_KEY; #[repr(C)] #[derive(Debug, Copy, Clone)] @@ -1192,31 +724,15 @@ pub struct _SYMCRYPT_OID { pub cbOID: UINT32, pub pbOID: PCBYTE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_OID() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_OID> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_OID>(), - 16usize, - "Size of _SYMCRYPT_OID" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_OID>(), - 8usize, - "Alignment of _SYMCRYPT_OID" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbOID) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_OID::cbOID" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbOID) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_OID::pbOID" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_OID"][::std::mem::size_of::<_SYMCRYPT_OID>() - 16usize]; + ["Alignment of _SYMCRYPT_OID"][::std::mem::align_of::<_SYMCRYPT_OID>() - 8usize]; + ["Offset of field: _SYMCRYPT_OID::cbOID"] + [::std::mem::offset_of!(_SYMCRYPT_OID, cbOID) - 0usize]; + ["Offset of field: _SYMCRYPT_OID::pbOID"] + [::std::mem::offset_of!(_SYMCRYPT_OID, pbOID) - 8usize]; +}; impl Default for _SYMCRYPT_OID { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1228,36 +744,36 @@ impl Default for _SYMCRYPT_OID { } pub type SYMCRYPT_OID = _SYMCRYPT_OID; pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID; -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize]; } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize]; } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize]; } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize]; } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize]; } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize]; } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize]; } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize]; } #[repr(C)] @@ -1279,91 +795,39 @@ pub union _SYMCRYPT_HASH_STATE { pub sha3_384State: SYMCRYPT_SHA3_384_STATE, pub sha3_512State: SYMCRYPT_SHA3_512_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HASH_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HASH_STATE>(), - 240usize, - "Size of _SYMCRYPT_HASH_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HASH_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HASH_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md2State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::md2State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md4State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::md4State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md5State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::md5State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha1State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha1State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha224State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha224State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha256State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha256State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha384State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha384State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha512State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_224State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha512_224State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_256State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha512_256State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_224State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_224State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_256State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_256State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_384State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_384State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_512State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_512State" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HASH_STATE"][::std::mem::size_of::<_SYMCRYPT_HASH_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_HASH_STATE"][::std::mem::align_of::<_SYMCRYPT_HASH_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::md2State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, md2State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::md4State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, md4State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::md5State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, md5State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha1State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha1State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha224State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha224State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha256State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha256State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha384State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha384State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha512State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha512State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha512_224State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha512_224State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha512_256State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha512_256State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha3_224State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha3_224State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha3_256State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha3_256State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha3_384State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha3_384State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha3_512State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha3_512State) - 0usize]; +}; impl Default for _SYMCRYPT_HASH_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1401,71 +865,31 @@ pub struct _SYMCRYPT_HASH { pub chainOffset: UINT32, pub chainSize: UINT32, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HASH() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HASH>(), - 64usize, - "Size of _SYMCRYPT_HASH" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HASH>(), - 16usize, - "Alignment of _SYMCRYPT_HASH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).initFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH::initFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_HASH::appendFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_HASH::resultFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendBlockFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_HASH::appendBlockFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateCopyFunc) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HASH::stateCopyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateSize) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_HASH::stateSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultSize) as usize - ptr as usize }, - 44usize, - "Offset of field: _SYMCRYPT_HASH::resultSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_HASH::inputBlockSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chainOffset) as usize - ptr as usize }, - 52usize, - "Offset of field: _SYMCRYPT_HASH::chainOffset" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chainSize) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_HASH::chainSize" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HASH"][::std::mem::size_of::<_SYMCRYPT_HASH>() - 64usize]; + ["Alignment of _SYMCRYPT_HASH"][::std::mem::align_of::<_SYMCRYPT_HASH>() - 16usize]; + ["Offset of field: _SYMCRYPT_HASH::initFunc"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, initFunc) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH::appendFunc"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, appendFunc) - 8usize]; + ["Offset of field: _SYMCRYPT_HASH::resultFunc"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, resultFunc) - 16usize]; + ["Offset of field: _SYMCRYPT_HASH::appendBlockFunc"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, appendBlockFunc) - 24usize]; + ["Offset of field: _SYMCRYPT_HASH::stateCopyFunc"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, stateCopyFunc) - 32usize]; + ["Offset of field: _SYMCRYPT_HASH::stateSize"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, stateSize) - 40usize]; + ["Offset of field: _SYMCRYPT_HASH::resultSize"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, resultSize) - 44usize]; + ["Offset of field: _SYMCRYPT_HASH::inputBlockSize"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, inputBlockSize) - 48usize]; + ["Offset of field: _SYMCRYPT_HASH::chainOffset"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, chainOffset) - 52usize]; + ["Offset of field: _SYMCRYPT_HASH::chainSize"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, chainSize) - 56usize]; +}; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] @@ -1474,37 +898,19 @@ pub struct _SYMCRYPT_HMAC_MD5_EXPANDED_KEY { pub outerState: SYMCRYPT_MD5_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), - 48usize, - "Size of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>() - 48usize]; + ["Alignment of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_MD5_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_MD5_EXPANDED_KEY, outerState) - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_MD5_EXPANDED_KEY, magic) - 32usize]; +}; pub type SYMCRYPT_HMAC_MD5_EXPANDED_KEY = _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; pub type PSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; pub type PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *const SYMCRYPT_HMAC_MD5_EXPANDED_KEY; @@ -1516,37 +922,19 @@ pub struct _SYMCRYPT_HMAC_MD5_STATE { pub pKey: PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_MD5_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_STATE>(), - 128usize, - "Size of _SYMCRYPT_HMAC_MD5_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_MD5_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 112usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 120usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_MD5_STATE"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_STATE>() - 128usize]; + ["Alignment of _SYMCRYPT_HMAC_MD5_STATE"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_MD5_STATE::hash"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_MD5_STATE, hash) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_MD5_STATE::pKey"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_MD5_STATE, pKey) - 112usize]; + ["Offset of field: _SYMCRYPT_HMAC_MD5_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_MD5_STATE, magic) - 120usize]; +}; impl Default for _SYMCRYPT_HMAC_MD5_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1567,37 +955,19 @@ pub struct _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA1_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(), - 80usize, - "Size of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>() - 80usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY, outerState) - 32usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY, magic) - 64usize]; +}; pub type SYMCRYPT_HMAC_SHA1_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; pub type PSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; pub type PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; @@ -1609,37 +979,19 @@ pub struct _SYMCRYPT_HMAC_SHA1_STATE { pub pKey: PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA1_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_STATE>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA1_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA1_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 136usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA1_STATE"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_STATE>() - 144usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA1_STATE"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::hash"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA1_STATE, hash) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::pKey"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA1_STATE, pKey) - 128usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA1_STATE, magic) - 136usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA1_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1660,37 +1012,19 @@ pub struct _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA256_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA224_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>(), - 80usize, - "Size of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>() - 80usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY, outerState) - 32usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY, magic) - 64usize]; +}; pub type SYMCRYPT_HMAC_SHA224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] @@ -1700,37 +1034,19 @@ pub struct _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA256_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(), - 80usize, - "Size of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>() - 80usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY, outerState) - 32usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY, magic) - 64usize]; +}; pub type SYMCRYPT_HMAC_SHA256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; pub type PSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; pub type PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; @@ -1742,37 +1058,19 @@ pub struct _SYMCRYPT_HMAC_SHA256_STATE { pub pKey: PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_STATE>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 136usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA256_STATE"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_STATE>() - 144usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA256_STATE"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::hash"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA256_STATE, hash) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::pKey"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA256_STATE, pKey) - 128usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA256_STATE, magic) - 136usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA256_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1793,37 +1091,19 @@ pub struct _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>() - 144usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY, outerState) - 64usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY, magic) - 128usize]; +}; pub type SYMCRYPT_HMAC_SHA384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; pub type PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; pub type PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; @@ -1835,37 +1115,19 @@ pub struct _SYMCRYPT_HMAC_SHA384_STATE { pub pKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), - 240usize, - "Size of _SYMCRYPT_HMAC_SHA384_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA384_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 232usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA384_STATE"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA384_STATE"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::hash"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA384_STATE, hash) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::pKey"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA384_STATE, pKey) - 224usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA384_STATE, magic) - 232usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA384_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1886,37 +1148,19 @@ pub struct _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>() - 144usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY, outerState) - 64usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY, magic) - 128usize]; +}; pub type SYMCRYPT_HMAC_SHA512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; pub type PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; pub type PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; @@ -1928,37 +1172,19 @@ pub struct _SYMCRYPT_HMAC_SHA512_STATE { pub pKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), - 240usize, - "Size of _SYMCRYPT_HMAC_SHA512_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 232usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA512_STATE"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA512_STATE"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::hash"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_STATE, hash) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::pKey"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_STATE, pKey) - 224usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_STATE, magic) - 232usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA512_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1979,37 +1205,19 @@ pub struct _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>() - 144usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY, outerState) - 64usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY, magic) - 128usize]; +}; pub type SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] @@ -2019,37 +1227,19 @@ pub struct _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>() - 144usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY, outerState) - 64usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY, magic) - 128usize]; +}; pub type SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] @@ -2061,42 +1251,21 @@ pub struct _SYMCRYPT_HMAC_EXPANDED_KEY { pub outerState: SYMCRYPT_HASH_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pHash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::pHash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 256usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 496usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>() - 512usize]; + ["Alignment of _SYMCRYPT_HMAC_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::pHash"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_EXPANDED_KEY, pHash) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_EXPANDED_KEY, innerState) - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_EXPANDED_KEY, outerState) - 256usize]; + ["Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_EXPANDED_KEY, magic) - 496usize]; +}; impl Default for _SYMCRYPT_HMAC_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2113,27 +1282,15 @@ pub type SYMCRYPT_HMAC_EXPANDED_KEY = _SYMCRYPT_HMAC_EXPANDED_KEY; pub struct _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY { pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY::generic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>() - 512usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY::generic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY, generic) - 0usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2150,27 +1307,15 @@ pub type SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_224_EXPANDED_ pub struct _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY { pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY::generic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>() - 512usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY::generic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY, generic) - 0usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2187,27 +1332,15 @@ pub type SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_256_EXPANDED_ pub struct _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY { pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY::generic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>() - 512usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY::generic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY, generic) - 0usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2224,27 +1357,15 @@ pub type SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_384_EXPANDED_ pub struct _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY { pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY::generic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>() - 512usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY::generic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY, generic) - 0usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2264,42 +1385,21 @@ pub struct _SYMCRYPT_AES_EXPANDED_KEY { pub lastDecRoundKey: *mut [[BYTE; 4usize]; 4usize], pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_AES_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_AES_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_AES_EXPANDED_KEY>(), - 496usize, - "Size of _SYMCRYPT_AES_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_AES_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_AES_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).RoundKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::RoundKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).lastEncRoundKey) as usize - ptr as usize }, - 464usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::lastEncRoundKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).lastDecRoundKey) as usize - ptr as usize }, - 472usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::lastDecRoundKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 480usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_AES_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_AES_EXPANDED_KEY>() - 496usize]; + ["Alignment of _SYMCRYPT_AES_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_AES_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::RoundKey"] + [::std::mem::offset_of!(_SYMCRYPT_AES_EXPANDED_KEY, RoundKey) - 0usize]; + ["Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::lastEncRoundKey"] + [::std::mem::offset_of!(_SYMCRYPT_AES_EXPANDED_KEY, lastEncRoundKey) - 464usize]; + ["Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::lastDecRoundKey"] + [::std::mem::offset_of!(_SYMCRYPT_AES_EXPANDED_KEY, lastDecRoundKey) - 472usize]; + ["Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_AES_EXPANDED_KEY, magic) - 480usize]; +}; impl Default for _SYMCRYPT_AES_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2321,42 +1421,21 @@ pub struct _SYMCRYPT_AES_CMAC_EXPANDED_KEY { pub K2: [BYTE; 16usize], pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_AES_CMAC_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_AES_CMAC_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>(), - 544usize, - "Size of _SYMCRYPT_AES_CMAC_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_AES_CMAC_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).aesKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::aesKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).K1) as usize - ptr as usize }, - 496usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::K1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).K2) as usize - ptr as usize }, - 512usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::K2" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 528usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_AES_CMAC_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>() - 544usize]; + ["Alignment of _SYMCRYPT_AES_CMAC_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::aesKey"] + [::std::mem::offset_of!(_SYMCRYPT_AES_CMAC_EXPANDED_KEY, aesKey) - 0usize]; + ["Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::K1"] + [::std::mem::offset_of!(_SYMCRYPT_AES_CMAC_EXPANDED_KEY, K1) - 496usize]; + ["Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::K2"] + [::std::mem::offset_of!(_SYMCRYPT_AES_CMAC_EXPANDED_KEY, K2) - 512usize]; + ["Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_AES_CMAC_EXPANDED_KEY, magic) - 528usize]; +}; impl Default for _SYMCRYPT_AES_CMAC_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2369,6 +1448,36 @@ impl Default for _SYMCRYPT_AES_CMAC_EXPANDED_KEY { pub type SYMCRYPT_AES_CMAC_EXPANDED_KEY = _SYMCRYPT_AES_CMAC_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_XTS_AES_EXPANDED_KEY { + pub key1: SYMCRYPT_AES_EXPANDED_KEY, + pub key2: SYMCRYPT_AES_EXPANDED_KEY, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_XTS_AES_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_XTS_AES_EXPANDED_KEY>() - 992usize]; + ["Alignment of _SYMCRYPT_XTS_AES_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_XTS_AES_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_XTS_AES_EXPANDED_KEY::key1"] + [::std::mem::offset_of!(_SYMCRYPT_XTS_AES_EXPANDED_KEY, key1) - 0usize]; + ["Offset of field: _SYMCRYPT_XTS_AES_EXPANDED_KEY::key2"] + [::std::mem::offset_of!(_SYMCRYPT_XTS_AES_EXPANDED_KEY, key2) - 496usize]; +}; +impl Default for _SYMCRYPT_XTS_AES_EXPANDED_KEY { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type SYMCRYPT_XTS_AES_EXPANDED_KEY = _SYMCRYPT_XTS_AES_EXPANDED_KEY; +pub type PSYMCRYPT_XTS_AES_EXPANDED_KEY = *mut _SYMCRYPT_XTS_AES_EXPANDED_KEY; +pub type PCSYMCRYPT_XTS_AES_EXPANDED_KEY = *const SYMCRYPT_XTS_AES_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] #[derive(Copy, Clone)] pub union _SYMCRYPT_MAC_EXPANDED_KEY { pub md5Key: SYMCRYPT_HMAC_MD5_EXPANDED_KEY, @@ -2387,97 +1496,43 @@ pub union _SYMCRYPT_MAC_EXPANDED_KEY { pub kmac128Key: SYMCRYPT_KMAC128_EXPANDED_KEY, pub kmac256Key: SYMCRYPT_KMAC256_EXPANDED_KEY, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MAC_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MAC_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MAC_EXPANDED_KEY>(), - 544usize, - "Size of _SYMCRYPT_MAC_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MAC_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_MAC_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md5Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::md5Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha1Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha1Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha224Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha224Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha256Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha384Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha384Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_224Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_224Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_256Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_224Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_224Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_256Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_384Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_384Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_512Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_512Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).aescmacKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::aescmacKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).kmac128Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac128Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).kmac256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac256Key" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MAC_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_MAC_EXPANDED_KEY>() - 544usize]; + ["Alignment of _SYMCRYPT_MAC_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_MAC_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::md5Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, md5Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha1Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha1Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha224Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha224Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha256Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha256Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha384Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha384Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha512Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_224Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha512_224Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_256Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha512_256Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_224Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha3_224Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_256Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha3_256Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_384Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha3_384Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_512Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha3_512Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::aescmacKey"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, aescmacKey) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac128Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, kmac128Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac256Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, kmac256Key) - 0usize]; +}; impl Default for _SYMCRYPT_MAC_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2510,66 +1565,29 @@ pub struct _SYMCRYPT_MAC { pub ppHashAlgorithm: *const PCSYMCRYPT_HASH, pub outerChainingStateOffset: UINT32, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MAC() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MAC> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MAC>(), - 72usize, - "Size of _SYMCRYPT_MAC" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MAC>(), - 8usize, - "Alignment of _SYMCRYPT_MAC" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandKeyFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC::expandKeyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).initFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MAC::initFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MAC::appendFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MAC::resultFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandedKeySize) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MAC::expandedKeySize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateSize) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_MAC::stateSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultSize) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_MAC::resultSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ppHashAlgorithm) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_MAC::ppHashAlgorithm" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerChainingStateOffset) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_MAC::outerChainingStateOffset" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MAC"][::std::mem::size_of::<_SYMCRYPT_MAC>() - 72usize]; + ["Alignment of _SYMCRYPT_MAC"][::std::mem::align_of::<_SYMCRYPT_MAC>() - 8usize]; + ["Offset of field: _SYMCRYPT_MAC::expandKeyFunc"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, expandKeyFunc) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC::initFunc"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, initFunc) - 8usize]; + ["Offset of field: _SYMCRYPT_MAC::appendFunc"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, appendFunc) - 16usize]; + ["Offset of field: _SYMCRYPT_MAC::resultFunc"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, resultFunc) - 24usize]; + ["Offset of field: _SYMCRYPT_MAC::expandedKeySize"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, expandedKeySize) - 32usize]; + ["Offset of field: _SYMCRYPT_MAC::stateSize"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, stateSize) - 40usize]; + ["Offset of field: _SYMCRYPT_MAC::resultSize"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, resultSize) - 48usize]; + ["Offset of field: _SYMCRYPT_MAC::ppHashAlgorithm"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, ppHashAlgorithm) - 56usize]; + ["Offset of field: _SYMCRYPT_MAC::outerChainingStateOffset"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, outerChainingStateOffset) - 64usize]; +}; impl Default for _SYMCRYPT_MAC { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2587,27 +1605,15 @@ pub type PCSYMCRYPT_MAC = *const SYMCRYPT_MAC; pub union _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS { pub aes: SYMCRYPT_AES_EXPANDED_KEY, } -#[test] -fn bindgen_test_layout__SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>(), - 496usize, - "Size of _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>(), - 16usize, - "Alignment of _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).aes) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS::aes" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS"] + [::std::mem::size_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>() - 496usize]; + ["Alignment of _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS"] + [::std::mem::align_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>() - 16usize]; + ["Offset of field: _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS::aes"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS, aes) - 0usize]; +}; impl Default for _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2626,37 +1632,18 @@ pub union _SYMCRYPT_GF128_ELEMENT { pub m128i: __m128i, pub ul: [UINT32; 4usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_GF128_ELEMENT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GF128_ELEMENT> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GF128_ELEMENT>(), - 16usize, - "Size of _SYMCRYPT_GF128_ELEMENT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GF128_ELEMENT>(), - 16usize, - "Alignment of _SYMCRYPT_GF128_ELEMENT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ull) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GF128_ELEMENT::ull" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).m128i) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GF128_ELEMENT::m128i" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ul) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GF128_ELEMENT::ul" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_GF128_ELEMENT"][::std::mem::size_of::<_SYMCRYPT_GF128_ELEMENT>() - 16usize]; + ["Alignment of _SYMCRYPT_GF128_ELEMENT"] + [::std::mem::align_of::<_SYMCRYPT_GF128_ELEMENT>() - 16usize]; + ["Offset of field: _SYMCRYPT_GF128_ELEMENT::ull"] + [::std::mem::offset_of!(_SYMCRYPT_GF128_ELEMENT, ull) - 0usize]; + ["Offset of field: _SYMCRYPT_GF128_ELEMENT::m128i"] + [::std::mem::offset_of!(_SYMCRYPT_GF128_ELEMENT, m128i) - 0usize]; + ["Offset of field: _SYMCRYPT_GF128_ELEMENT::ul"] + [::std::mem::offset_of!(_SYMCRYPT_GF128_ELEMENT, ul) - 0usize]; +}; impl Default for _SYMCRYPT_GF128_ELEMENT { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2673,27 +1660,15 @@ pub type SYMCRYPT_GF128_ELEMENT = _SYMCRYPT_GF128_ELEMENT; pub struct _SYMCRYPT_GHASH_EXPANDED_KEY { pub table: [SYMCRYPT_GF128_ELEMENT; 128usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_GHASH_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GHASH_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>(), - 2048usize, - "Size of _SYMCRYPT_GHASH_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_GHASH_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).table) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GHASH_EXPANDED_KEY::table" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_GHASH_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>() - 2048usize]; + ["Alignment of _SYMCRYPT_GHASH_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_GHASH_EXPANDED_KEY::table"] + [::std::mem::offset_of!(_SYMCRYPT_GHASH_EXPANDED_KEY, table) - 0usize]; +}; impl Default for _SYMCRYPT_GHASH_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2716,52 +1691,25 @@ pub struct _SYMCRYPT_GCM_EXPANDED_KEY { pub abKey: [BYTE; 32usize], pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_GCM_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GCM_EXPANDED_KEY>(), - 2608usize, - "Size of _SYMCRYPT_GCM_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GCM_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_GCM_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ghashKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::ghashKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pBlockCipher) as usize - ptr as usize }, - 2048usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::pBlockCipher" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).blockcipherKey) as usize - ptr as usize }, - 2064usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::blockcipherKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbKey) as usize - ptr as usize }, - 2560usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::cbKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).abKey) as usize - ptr as usize }, - 2568usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::abKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 2600usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_GCM_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_GCM_EXPANDED_KEY>() - 2608usize]; + ["Alignment of _SYMCRYPT_GCM_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_GCM_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::ghashKey"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_EXPANDED_KEY, ghashKey) - 0usize]; + ["Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::pBlockCipher"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_EXPANDED_KEY, pBlockCipher) - 2048usize]; + ["Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::blockcipherKey"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_EXPANDED_KEY, blockcipherKey) - 2064usize]; + ["Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::cbKey"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_EXPANDED_KEY, cbKey) - 2560usize]; + ["Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::abKey"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_EXPANDED_KEY, abKey) - 2568usize]; + ["Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_EXPANDED_KEY, magic) - 2600usize]; +}; impl Default for _SYMCRYPT_GCM_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2788,66 +1736,29 @@ pub struct _SYMCRYPT_GCM_STATE { pub keystreamBlock: [BYTE; 16usize], pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_GCM_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GCM_STATE>(), - 112usize, - "Size of _SYMCRYPT_GCM_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GCM_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_GCM_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GCM_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbData) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_GCM_STATE::cbData" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbAuthData) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_GCM_STATE::cbAuthData" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInMacBlock) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_GCM_STATE::bytesInMacBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ghashState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_GCM_STATE::ghashState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).counterBlock) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_GCM_STATE::counterBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macBlock) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_GCM_STATE::macBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).keystreamBlock) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_GCM_STATE::keystreamBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_GCM_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_GCM_STATE"][::std::mem::size_of::<_SYMCRYPT_GCM_STATE>() - 112usize]; + ["Alignment of _SYMCRYPT_GCM_STATE"][::std::mem::align_of::<_SYMCRYPT_GCM_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::pKey"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, pKey) - 0usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::cbData"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, cbData) - 8usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::cbAuthData"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, cbAuthData) - 16usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::bytesInMacBlock"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, bytesInMacBlock) - 24usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::ghashState"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, ghashState) - 32usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::counterBlock"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, counterBlock) - 48usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::macBlock"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, macBlock) - 64usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::keystreamBlock"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, keystreamBlock) - 80usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, magic) - 96usize]; +}; impl Default for _SYMCRYPT_GCM_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2905,120 +1816,86 @@ pub struct _SYMCRYPT_BLOCKCIPHER { pub blockSize: SIZE_T, pub expandedKeySize: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_BLOCKCIPHER() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_BLOCKCIPHER> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_BLOCKCIPHER>(), - 104usize, - "Size of _SYMCRYPT_BLOCKCIPHER" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_BLOCKCIPHER>(), - 8usize, - "Alignment of _SYMCRYPT_BLOCKCIPHER" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandKeyFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::expandKeyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).encryptFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::encryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).decryptFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::decryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ecbEncryptFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::ecbEncryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ecbDecryptFunc) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::ecbDecryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbcEncryptFunc) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcEncryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbcDecryptFunc) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcDecryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbcMacFunc) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcMacFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ctrMsb64Func) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::ctrMsb64Func" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).gcmEncryptPartFunc) as usize - ptr as usize }, - 72usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::gcmEncryptPartFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).gcmDecryptPartFunc) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::gcmDecryptPartFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).blockSize) as usize - ptr as usize }, - 88usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::blockSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandedKeySize) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::expandedKeySize" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_BLOCKCIPHER"][::std::mem::size_of::<_SYMCRYPT_BLOCKCIPHER>() - 104usize]; + ["Alignment of _SYMCRYPT_BLOCKCIPHER"] + [::std::mem::align_of::<_SYMCRYPT_BLOCKCIPHER>() - 8usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::expandKeyFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, expandKeyFunc) - 0usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::encryptFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, encryptFunc) - 8usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::decryptFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, decryptFunc) - 16usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::ecbEncryptFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, ecbEncryptFunc) - 24usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::ecbDecryptFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, ecbDecryptFunc) - 32usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcEncryptFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, cbcEncryptFunc) - 40usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcDecryptFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, cbcDecryptFunc) - 48usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcMacFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, cbcMacFunc) - 56usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::ctrMsb64Func"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, ctrMsb64Func) - 64usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::gcmEncryptPartFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, gcmEncryptPartFunc) - 72usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::gcmDecryptPartFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, gcmDecryptPartFunc) - 80usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::blockSize"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, blockSize) - 88usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::expandedKeySize"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, expandedKeySize) - 96usize]; +}; #[repr(C)] #[repr(align(16))] #[derive(Copy, Clone)] -pub struct _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY { +pub struct _SYMCRYPT_SP800_108_EXPANDED_KEY { pub macKey: SYMCRYPT_MAC_EXPANDED_KEY, pub macAlg: PCSYMCRYPT_MAC, } -#[test] -fn bindgen_test_layout__SYMCRYPT_TLSPRF1_2_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY>(), - 560usize, - "Size of _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY::macKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macAlg) as usize - ptr as usize }, - 544usize, - "Offset of field: _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY::macAlg" - ); +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SP800_108_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_SP800_108_EXPANDED_KEY>() - 560usize]; + ["Alignment of _SYMCRYPT_SP800_108_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_SP800_108_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_SP800_108_EXPANDED_KEY::macKey"] + [::std::mem::offset_of!(_SYMCRYPT_SP800_108_EXPANDED_KEY, macKey) - 0usize]; + ["Offset of field: _SYMCRYPT_SP800_108_EXPANDED_KEY::macAlg"] + [::std::mem::offset_of!(_SYMCRYPT_SP800_108_EXPANDED_KEY, macAlg) - 544usize]; +}; +impl Default for _SYMCRYPT_SP800_108_EXPANDED_KEY { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type SYMCRYPT_SP800_108_EXPANDED_KEY = _SYMCRYPT_SP800_108_EXPANDED_KEY; +pub type PSYMCRYPT_SP800_108_EXPANDED_KEY = *mut _SYMCRYPT_SP800_108_EXPANDED_KEY; +pub type PCSYMCRYPT_SP800_108_EXPANDED_KEY = *const SYMCRYPT_SP800_108_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Copy, Clone)] +pub struct _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY { + pub macKey: SYMCRYPT_MAC_EXPANDED_KEY, + pub macAlg: PCSYMCRYPT_MAC, } +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY>() - 560usize]; + ["Alignment of _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY::macKey"] + [::std::mem::offset_of!(_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY, macKey) - 0usize]; + ["Offset of field: _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY::macAlg"] + [::std::mem::offset_of!(_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY, macAlg) - 544usize]; +}; impl Default for _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3038,32 +1915,17 @@ pub struct _SYMCRYPT_HKDF_EXPANDED_KEY { pub macKey: SYMCRYPT_MAC_EXPANDED_KEY, pub macAlg: PCSYMCRYPT_MAC, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HKDF_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HKDF_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HKDF_EXPANDED_KEY>(), - 560usize, - "Size of _SYMCRYPT_HKDF_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HKDF_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HKDF_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HKDF_EXPANDED_KEY::macKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macAlg) as usize - ptr as usize }, - 544usize, - "Offset of field: _SYMCRYPT_HKDF_EXPANDED_KEY::macAlg" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HKDF_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HKDF_EXPANDED_KEY>() - 560usize]; + ["Alignment of _SYMCRYPT_HKDF_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HKDF_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HKDF_EXPANDED_KEY::macKey"] + [::std::mem::offset_of!(_SYMCRYPT_HKDF_EXPANDED_KEY, macKey) - 0usize]; + ["Offset of field: _SYMCRYPT_HKDF_EXPANDED_KEY::macAlg"] + [::std::mem::offset_of!(_SYMCRYPT_HKDF_EXPANDED_KEY, macAlg) - 544usize]; +}; impl Default for _SYMCRYPT_HKDF_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3107,48 +1969,24 @@ pub union _SYMCRYPT_INT__bindgen_ty_1 { pub struct _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1 { pub uint32: [UINT32; 1usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>(), - 4usize, - "Size of _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>(), - 4usize, - "Alignment of _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).uint32) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1::uint32" - ); -} -#[test] -fn bindgen_test_layout__SYMCRYPT_INT__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1>(), - 32usize, - "Size of _SYMCRYPT_INT__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1>(), - 32usize, - "Alignment of _SYMCRYPT_INT__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fdef) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_INT__bindgen_ty_1::fdef" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>() - 4usize]; + ["Alignment of _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>() - 4usize]; + ["Offset of field: _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1::uint32"] + [::std::mem::offset_of!(_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1, uint32) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_INT__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1>() - 32usize]; + ["Alignment of _SYMCRYPT_INT__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1>() - 32usize]; + ["Offset of field: _SYMCRYPT_INT__bindgen_ty_1::fdef"] + [::std::mem::offset_of!(_SYMCRYPT_INT__bindgen_ty_1, fdef) - 0usize]; +}; impl Default for _SYMCRYPT_INT__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3158,46 +1996,20 @@ impl Default for _SYMCRYPT_INT__bindgen_ty_1 { } } } -#[test] -fn bindgen_test_layout__SYMCRYPT_INT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_INT>(), - 64usize, - "Size of _SYMCRYPT_INT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_INT>(), - 32usize, - "Alignment of _SYMCRYPT_INT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_INT::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_INT::nDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_INT::cbSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_INT::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ti) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_INT::ti" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_INT"][::std::mem::size_of::<_SYMCRYPT_INT>() - 64usize]; + ["Alignment of _SYMCRYPT_INT"][::std::mem::align_of::<_SYMCRYPT_INT>() - 32usize]; + ["Offset of field: _SYMCRYPT_INT::type_"] + [::std::mem::offset_of!(_SYMCRYPT_INT, type_) - 0usize]; + ["Offset of field: _SYMCRYPT_INT::nDigits"] + [::std::mem::offset_of!(_SYMCRYPT_INT, nDigits) - 4usize]; + ["Offset of field: _SYMCRYPT_INT::cbSize"] + [::std::mem::offset_of!(_SYMCRYPT_INT, cbSize) - 8usize]; + ["Offset of field: _SYMCRYPT_INT::magic"] + [::std::mem::offset_of!(_SYMCRYPT_INT, magic) - 16usize]; + ["Offset of field: _SYMCRYPT_INT::ti"][::std::mem::offset_of!(_SYMCRYPT_INT, ti) - 32usize]; +}; impl Default for _SYMCRYPT_INT { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3229,48 +2041,24 @@ pub union _SYMCRYPT_DIVISOR__bindgen_ty_1 { pub struct _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1 { pub W: UINT64, } -#[test] -fn bindgen_test_layout__SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).W) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1::W" - ); -} -#[test] -fn bindgen_test_layout__SYMCRYPT_DIVISOR__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_DIVISOR__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_DIVISOR__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fdef) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_DIVISOR__bindgen_ty_1::fdef" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>() - 8usize]; + ["Alignment of _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>() - 8usize]; + ["Offset of field: _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1::W"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1, W) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_DIVISOR__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>() - 8usize]; + ["Alignment of _SYMCRYPT_DIVISOR__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>() - 8usize]; + ["Offset of field: _SYMCRYPT_DIVISOR__bindgen_ty_1::fdef"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR__bindgen_ty_1, fdef) - 0usize]; +}; impl Default for _SYMCRYPT_DIVISOR__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3280,56 +2068,25 @@ impl Default for _SYMCRYPT_DIVISOR__bindgen_ty_1 { } } } -#[test] -fn bindgen_test_layout__SYMCRYPT_DIVISOR() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_DIVISOR>(), - 96usize, - "Size of _SYMCRYPT_DIVISOR" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_DIVISOR>(), - 32usize, - "Alignment of _SYMCRYPT_DIVISOR" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_DIVISOR::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_DIVISOR::nDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_DIVISOR::cbSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBits) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_DIVISOR::nBits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_DIVISOR::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).td) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_DIVISOR::td" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).Int) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_DIVISOR::Int" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_DIVISOR"][::std::mem::size_of::<_SYMCRYPT_DIVISOR>() - 96usize]; + ["Alignment of _SYMCRYPT_DIVISOR"][::std::mem::align_of::<_SYMCRYPT_DIVISOR>() - 32usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::type_"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, type_) - 0usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::nDigits"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, nDigits) - 4usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::cbSize"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, cbSize) - 8usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::nBits"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, nBits) - 12usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::magic"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, magic) - 16usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::td"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, td) - 24usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::Int"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, Int) - 32usize]; +}; impl Default for _SYMCRYPT_DIVISOR { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3365,27 +2122,15 @@ pub union _SYMCRYPT_MODULUS__bindgen_ty_1 { pub struct _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1 { pub Rsqr: PCUINT32, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).Rsqr) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1::Rsqr" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>() - 8usize]; + ["Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>() - 8usize]; + ["Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1::Rsqr"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1, Rsqr) - 0usize]; +}; impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3400,53 +2145,26 @@ impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1 { pub struct _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2 { pub k: UINT32, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>(), - 4usize, - "Size of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>(), - 4usize, - "Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).k) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2::k" - ); -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_MODULUS__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).montgomery) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1::montgomery" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pseudoMersenne) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1::pseudoMersenne" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2"] + [::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>() - 4usize]; + ["Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2"] + [::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>() - 4usize]; + ["Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2::k"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2, k) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MODULUS__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>() - 8usize]; + ["Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>() - 8usize]; + ["Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1::montgomery"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS__bindgen_ty_1, montgomery) - 0usize]; + ["Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1::pseudoMersenne"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS__bindgen_ty_1, pseudoMersenne) - 0usize]; +}; impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3456,66 +2174,29 @@ impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1 { } } } -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS>(), - 160usize, - "Size of _SYMCRYPT_MODULUS" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS>(), - 32usize, - "Alignment of _SYMCRYPT_MODULUS" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_MODULUS::nDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MODULUS::cbSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_MODULUS::flags" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbModElement) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MODULUS::cbModElement" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inv64) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MODULUS::inv64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MODULUS::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).tm) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_MODULUS::tm" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).Divisor) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_MODULUS::Divisor" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MODULUS"][::std::mem::size_of::<_SYMCRYPT_MODULUS>() - 160usize]; + ["Alignment of _SYMCRYPT_MODULUS"][::std::mem::align_of::<_SYMCRYPT_MODULUS>() - 32usize]; + ["Offset of field: _SYMCRYPT_MODULUS::type_"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, type_) - 0usize]; + ["Offset of field: _SYMCRYPT_MODULUS::nDigits"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, nDigits) - 4usize]; + ["Offset of field: _SYMCRYPT_MODULUS::cbSize"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, cbSize) - 8usize]; + ["Offset of field: _SYMCRYPT_MODULUS::flags"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, flags) - 12usize]; + ["Offset of field: _SYMCRYPT_MODULUS::cbModElement"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, cbModElement) - 16usize]; + ["Offset of field: _SYMCRYPT_MODULUS::inv64"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, inv64) - 24usize]; + ["Offset of field: _SYMCRYPT_MODULUS::magic"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, magic) - 32usize]; + ["Offset of field: _SYMCRYPT_MODULUS::tm"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, tm) - 40usize]; + ["Offset of field: _SYMCRYPT_MODULUS::Divisor"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, Divisor) - 64usize]; +}; impl Default for _SYMCRYPT_MODULUS { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3536,27 +2217,15 @@ pub struct _SYMCRYPT_MODELEMENT { pub union _SYMCRYPT_MODELEMENT__bindgen_ty_1 { pub uint32: [UINT32; 1usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_MODELEMENT__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODELEMENT__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>(), - 4usize, - "Size of _SYMCRYPT_MODELEMENT__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>(), - 4usize, - "Alignment of _SYMCRYPT_MODELEMENT__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).uint32) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODELEMENT__bindgen_ty_1::uint32" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MODELEMENT__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>() - 4usize]; + ["Alignment of _SYMCRYPT_MODELEMENT__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>() - 4usize]; + ["Offset of field: _SYMCRYPT_MODELEMENT__bindgen_ty_1::uint32"] + [::std::mem::offset_of!(_SYMCRYPT_MODELEMENT__bindgen_ty_1, uint32) - 0usize]; +}; impl Default for _SYMCRYPT_MODELEMENT__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3566,26 +2235,13 @@ impl Default for _SYMCRYPT_MODELEMENT__bindgen_ty_1 { } } } -#[test] -fn bindgen_test_layout__SYMCRYPT_MODELEMENT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODELEMENT> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODELEMENT>(), - 32usize, - "Size of _SYMCRYPT_MODELEMENT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODELEMENT>(), - 32usize, - "Alignment of _SYMCRYPT_MODELEMENT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODELEMENT::d" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MODELEMENT"][::std::mem::size_of::<_SYMCRYPT_MODELEMENT>() - 32usize]; + ["Alignment of _SYMCRYPT_MODELEMENT"][::std::mem::align_of::<_SYMCRYPT_MODELEMENT>() - 32usize]; + ["Offset of field: _SYMCRYPT_MODELEMENT::d"] + [::std::mem::offset_of!(_SYMCRYPT_MODELEMENT, d) - 0usize]; +}; impl Default for _SYMCRYPT_MODELEMENT { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3622,131 +2278,55 @@ pub struct _SYMCRYPT_RSAKEY { pub piCrtPrivExps: [PSYMCRYPT_INT; 2usize], pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_RSAKEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_RSAKEY> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_RSAKEY>(), - 192usize, - "Size of _SYMCRYPT_RSAKEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_RSAKEY>(), - 32usize, - "Alignment of _SYMCRYPT_RSAKEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fAlgorithmInfo) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_RSAKEY::fAlgorithmInfo" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbTotalSize) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_RSAKEY::cbTotalSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hasPrivateKey) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_RSAKEY::hasPrivateKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nSetBitsOfModulus) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_RSAKEY::nSetBitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBitsOfModulus) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_RSAKEY::nBitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigitsOfModulus) as usize - ptr as usize }, - 20usize, - "Offset of field: _SYMCRYPT_RSAKEY::nDigitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPubExp) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_RSAKEY::nPubExp" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPrimes) as usize - ptr as usize }, - 28usize, - "Offset of field: _SYMCRYPT_RSAKEY::nPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBitsOfPrimes) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_RSAKEY::nBitsOfPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigitsOfPrimes) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_RSAKEY::nDigitsOfPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nMaxDigitsOfPrimes) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_RSAKEY::nMaxDigitsOfPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).au64PubExp) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_RSAKEY::au64PubExp" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbPrimes) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbCrtInverses) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbCrtInverses" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbPrivExps) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbCrtPrivExps) as usize - ptr as usize }, - 104usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbCrtPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pmModulus) as usize - ptr as usize }, - 120usize, - "Offset of field: _SYMCRYPT_RSAKEY::pmModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pmPrimes) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_RSAKEY::pmPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).peCrtInverses) as usize - ptr as usize }, - 144usize, - "Offset of field: _SYMCRYPT_RSAKEY::peCrtInverses" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).piPrivExps) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_RSAKEY::piPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).piCrtPrivExps) as usize - ptr as usize }, - 168usize, - "Offset of field: _SYMCRYPT_RSAKEY::piCrtPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 184usize, - "Offset of field: _SYMCRYPT_RSAKEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_RSAKEY"][::std::mem::size_of::<_SYMCRYPT_RSAKEY>() - 192usize]; + ["Alignment of _SYMCRYPT_RSAKEY"][::std::mem::align_of::<_SYMCRYPT_RSAKEY>() - 32usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::fAlgorithmInfo"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, fAlgorithmInfo) - 0usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::cbTotalSize"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, cbTotalSize) - 4usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::hasPrivateKey"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, hasPrivateKey) - 8usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nSetBitsOfModulus"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nSetBitsOfModulus) - 12usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nBitsOfModulus"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nBitsOfModulus) - 16usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nDigitsOfModulus"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nDigitsOfModulus) - 20usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nPubExp"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nPubExp) - 24usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nPrimes) - 28usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nBitsOfPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nBitsOfPrimes) - 32usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nDigitsOfPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nDigitsOfPrimes) - 40usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nMaxDigitsOfPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nMaxDigitsOfPrimes) - 48usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::au64PubExp"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, au64PubExp) - 56usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::pbPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, pbPrimes) - 64usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::pbCrtInverses"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, pbCrtInverses) - 80usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::pbPrivExps"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, pbPrivExps) - 96usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::pbCrtPrivExps"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, pbCrtPrivExps) - 104usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::pmModulus"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, pmModulus) - 120usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::pmPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, pmPrimes) - 128usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::peCrtInverses"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, peCrtInverses) - 144usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::piPrivExps"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, piPrivExps) - 160usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::piCrtPrivExps"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, piCrtPrivExps) - 168usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, magic) - 184usize]; +}; impl Default for _SYMCRYPT_RSAKEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3783,42 +2363,21 @@ pub struct _SYMCRYPT_ECURVE_INFO_PRECOMP { pub nRecodedDigits: UINT32, pub poPrecompPoints: [PSYMCRYPT_ECPOINT; 64usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE_INFO_PRECOMP() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE_INFO_PRECOMP> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(), - 528usize, - "Size of _SYMCRYPT_ECURVE_INFO_PRECOMP" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(), - 8usize, - "Alignment of _SYMCRYPT_ECURVE_INFO_PRECOMP" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::window" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPrecompPoints) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nPrecompPoints" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nRecodedDigits) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nRecodedDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).poPrecompPoints) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::poPrecompPoints" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_ECURVE_INFO_PRECOMP"] + [::std::mem::size_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>() - 528usize]; + ["Alignment of _SYMCRYPT_ECURVE_INFO_PRECOMP"] + [::std::mem::align_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>() - 8usize]; + ["Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::window"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_INFO_PRECOMP, window) - 0usize]; + ["Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nPrecompPoints"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_INFO_PRECOMP, nPrecompPoints) - 4usize]; + ["Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nRecodedDigits"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_INFO_PRECOMP, nRecodedDigits) - 8usize]; + ["Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::poPrecompPoints"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_INFO_PRECOMP, poPrecompPoints) - 16usize]; +}; impl Default for _SYMCRYPT_ECURVE_INFO_PRECOMP { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3878,27 +2437,15 @@ pub struct _SYMCRYPT_ECURVE { pub union _SYMCRYPT_ECURVE__bindgen_ty_1 { pub sw: SYMCRYPT_ECURVE_INFO_PRECOMP, } -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(), - 528usize, - "Size of _SYMCRYPT_ECURVE__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_ECURVE__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sw) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE__bindgen_ty_1::sw" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_ECURVE__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>() - 528usize]; + ["Alignment of _SYMCRYPT_ECURVE__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>() - 8usize]; + ["Offset of field: _SYMCRYPT_ECURVE__bindgen_ty_1::sw"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE__bindgen_ty_1, sw) - 0usize]; +}; impl Default for _SYMCRYPT_ECURVE__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3908,166 +2455,69 @@ impl Default for _SYMCRYPT_ECURVE__bindgen_ty_1 { } } } -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE>(), - 672usize, - "Size of _SYMCRYPT_ECURVE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE>(), - 32usize, - "Alignment of _SYMCRYPT_ECURVE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE::version" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECURVE::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).eCoordinates) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECURVE::eCoordinates" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FModBitsize) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_ECURVE::FModBitsize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FModDigits) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECURVE::FModDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FModBytesize) as usize - ptr as usize }, - 20usize, - "Offset of field: _SYMCRYPT_ECURVE::FModBytesize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrdBitsize) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrdBitsize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrdDigits) as usize - ptr as usize }, - 28usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrdDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrdBytesize) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrdBytesize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbModElement) as usize - ptr as usize }, - 36usize, - "Offset of field: _SYMCRYPT_ECURVE::cbModElement" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbAlloc) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_ECURVE::cbAlloc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchCommon) as usize - ptr as usize }, - 44usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchCommon" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchScalar) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchScalar" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchScalarMulti) as usize - ptr as usize }, - 52usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchScalarMulti" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchGetSetValue) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchGetSetValue" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchEckey) as usize - ptr as usize }, - 60usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchEckey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).coFactorPower) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_ECURVE::coFactorPower" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).PrivateKeyDefaultFormat) as usize - ptr as usize }, - 68usize, - "Offset of field: _SYMCRYPT_ECURVE::PrivateKeyDefaultFormat" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionNumOfBits) as usize - ptr as usize }, - 72usize, - "Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionNumOfBits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionPosition) as usize - ptr as usize }, - 76usize, - "Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionPosition" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionValue) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionValue" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).info) as usize - ptr as usize }, - 88usize, - "Offset of field: _SYMCRYPT_ECURVE::info" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FMod) as usize - ptr as usize }, - 616usize, - "Offset of field: _SYMCRYPT_ECURVE::FMod" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrd) as usize - ptr as usize }, - 624usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrd" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).A) as usize - ptr as usize }, - 632usize, - "Offset of field: _SYMCRYPT_ECURVE::A" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).B) as usize - ptr as usize }, - 640usize, - "Offset of field: _SYMCRYPT_ECURVE::B" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).G) as usize - ptr as usize }, - 648usize, - "Offset of field: _SYMCRYPT_ECURVE::G" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 656usize, - "Offset of field: _SYMCRYPT_ECURVE::H" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 664usize, - "Offset of field: _SYMCRYPT_ECURVE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_ECURVE"][::std::mem::size_of::<_SYMCRYPT_ECURVE>() - 672usize]; + ["Alignment of _SYMCRYPT_ECURVE"][::std::mem::align_of::<_SYMCRYPT_ECURVE>() - 32usize]; + ["Offset of field: _SYMCRYPT_ECURVE::version"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, version) - 0usize]; + ["Offset of field: _SYMCRYPT_ECURVE::type_"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, type_) - 4usize]; + ["Offset of field: _SYMCRYPT_ECURVE::eCoordinates"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, eCoordinates) - 8usize]; + ["Offset of field: _SYMCRYPT_ECURVE::FModBitsize"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, FModBitsize) - 12usize]; + ["Offset of field: _SYMCRYPT_ECURVE::FModDigits"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, FModDigits) - 16usize]; + ["Offset of field: _SYMCRYPT_ECURVE::FModBytesize"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, FModBytesize) - 20usize]; + ["Offset of field: _SYMCRYPT_ECURVE::GOrdBitsize"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, GOrdBitsize) - 24usize]; + ["Offset of field: _SYMCRYPT_ECURVE::GOrdDigits"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, GOrdDigits) - 28usize]; + ["Offset of field: _SYMCRYPT_ECURVE::GOrdBytesize"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, GOrdBytesize) - 32usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbModElement"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbModElement) - 36usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbAlloc"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbAlloc) - 40usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbScratchCommon"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbScratchCommon) - 44usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbScratchScalar"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbScratchScalar) - 48usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbScratchScalarMulti"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbScratchScalarMulti) - 52usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbScratchGetSetValue"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbScratchGetSetValue) - 56usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbScratchEckey"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbScratchEckey) - 60usize]; + ["Offset of field: _SYMCRYPT_ECURVE::coFactorPower"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, coFactorPower) - 64usize]; + ["Offset of field: _SYMCRYPT_ECURVE::PrivateKeyDefaultFormat"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, PrivateKeyDefaultFormat) - 68usize]; + ["Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionNumOfBits"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, HighBitRestrictionNumOfBits) - 72usize]; + ["Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionPosition"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, HighBitRestrictionPosition) - 76usize]; + ["Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionValue"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, HighBitRestrictionValue) - 80usize]; + ["Offset of field: _SYMCRYPT_ECURVE::info"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, info) - 88usize]; + ["Offset of field: _SYMCRYPT_ECURVE::FMod"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, FMod) - 616usize]; + ["Offset of field: _SYMCRYPT_ECURVE::GOrd"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, GOrd) - 624usize]; + ["Offset of field: _SYMCRYPT_ECURVE::A"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, A) - 632usize]; + ["Offset of field: _SYMCRYPT_ECURVE::B"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, B) - 640usize]; + ["Offset of field: _SYMCRYPT_ECURVE::G"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, G) - 648usize]; + ["Offset of field: _SYMCRYPT_ECURVE::H"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, H) - 656usize]; + ["Offset of field: _SYMCRYPT_ECURVE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, magic) - 664usize]; +}; impl Default for _SYMCRYPT_ECURVE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -4088,36 +2538,17 @@ pub struct _SYMCRYPT_ECPOINT { pub pCurve: PCSYMCRYPT_ECURVE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_ECPOINT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECPOINT> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECPOINT>(), - 32usize, - "Size of _SYMCRYPT_ECPOINT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECPOINT>(), - 32usize, - "Alignment of _SYMCRYPT_ECPOINT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).normalized) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECPOINT::normalized" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pCurve) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECPOINT::pCurve" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECPOINT::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_ECPOINT"][::std::mem::size_of::<_SYMCRYPT_ECPOINT>() - 32usize]; + ["Alignment of _SYMCRYPT_ECPOINT"][::std::mem::align_of::<_SYMCRYPT_ECPOINT>() - 32usize]; + ["Offset of field: _SYMCRYPT_ECPOINT::normalized"] + [::std::mem::offset_of!(_SYMCRYPT_ECPOINT, normalized) - 0usize]; + ["Offset of field: _SYMCRYPT_ECPOINT::pCurve"] + [::std::mem::offset_of!(_SYMCRYPT_ECPOINT, pCurve) - 8usize]; + ["Offset of field: _SYMCRYPT_ECPOINT::magic"] + [::std::mem::offset_of!(_SYMCRYPT_ECPOINT, magic) - 16usize]; +}; impl Default for _SYMCRYPT_ECPOINT { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -4138,51 +2569,23 @@ pub struct _SYMCRYPT_ECKEY { pub piPrivateKey: PSYMCRYPT_INT, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_ECKEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECKEY> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECKEY>(), - 64usize, - "Size of _SYMCRYPT_ECKEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECKEY>(), - 32usize, - "Alignment of _SYMCRYPT_ECKEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fAlgorithmInfo) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECKEY::fAlgorithmInfo" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hasPrivateKey) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECKEY::hasPrivateKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pCurve) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECKEY::pCurve" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).poPublicKey) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECKEY::poPublicKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).piPrivateKey) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_ECKEY::piPrivateKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_ECKEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_ECKEY"][::std::mem::size_of::<_SYMCRYPT_ECKEY>() - 64usize]; + ["Alignment of _SYMCRYPT_ECKEY"][::std::mem::align_of::<_SYMCRYPT_ECKEY>() - 32usize]; + ["Offset of field: _SYMCRYPT_ECKEY::fAlgorithmInfo"] + [::std::mem::offset_of!(_SYMCRYPT_ECKEY, fAlgorithmInfo) - 0usize]; + ["Offset of field: _SYMCRYPT_ECKEY::hasPrivateKey"] + [::std::mem::offset_of!(_SYMCRYPT_ECKEY, hasPrivateKey) - 4usize]; + ["Offset of field: _SYMCRYPT_ECKEY::pCurve"] + [::std::mem::offset_of!(_SYMCRYPT_ECKEY, pCurve) - 8usize]; + ["Offset of field: _SYMCRYPT_ECKEY::poPublicKey"] + [::std::mem::offset_of!(_SYMCRYPT_ECKEY, poPublicKey) - 16usize]; + ["Offset of field: _SYMCRYPT_ECKEY::piPrivateKey"] + [::std::mem::offset_of!(_SYMCRYPT_ECKEY, piPrivateKey) - 24usize]; + ["Offset of field: _SYMCRYPT_ECKEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_ECKEY, magic) - 32usize]; +}; impl Default for _SYMCRYPT_ECKEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -4195,196 +2598,191 @@ impl Default for _SYMCRYPT_ECKEY { pub type SYMCRYPT_ECKEY = _SYMCRYPT_ECKEY; pub type PSYMCRYPT_ECKEY = *mut SYMCRYPT_ECKEY; pub type PCSYMCRYPT_ECKEY = *const SYMCRYPT_ECKEY; -extern "C" { +unsafe extern "C" { pub fn SymCryptWipe(pbData: PVOID, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptLoadMsbFirstUint64( pbSrc: PCBYTE, cbSrc: SIZE_T, pDst: PUINT64, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptStoreMsbFirstUint64(src: UINT64, pbDst: PBYTE, cbDst: SIZE_T) -> SYMCRYPT_ERROR; } -#[cfg(not(feature = "dynamic"))] -extern "C" { - pub fn SymCryptInit(); -} -#[cfg(feature = "dynamic")] -extern "C" { +unsafe extern "C" { pub fn SymCryptModuleInit(api: UINT32, minor: UINT32); } -extern "C" { +unsafe extern "C" { pub fn SymCryptMd5(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptMd5Init(pState: PSYMCRYPT_MD5_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptMd5Append(pState: PSYMCRYPT_MD5_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptMd5Result(pState: PSYMCRYPT_MD5_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptMd5StateCopy(pSrc: PCSYMCRYPT_MD5_STATE, pDst: PSYMCRYPT_MD5_STATE); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptMd5Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha1(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha1Init(pState: PSYMCRYPT_SHA1_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha1Append(pState: PSYMCRYPT_SHA1_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha1Result(pState: PSYMCRYPT_SHA1_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha1StateCopy(pSrc: PCSYMCRYPT_SHA1_STATE, pDst: PSYMCRYPT_SHA1_STATE); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha1Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha256(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha256Init(pState: PSYMCRYPT_SHA256_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha256Append(pState: PSYMCRYPT_SHA256_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha256Result(pState: PSYMCRYPT_SHA256_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha256StateCopy(pSrc: PCSYMCRYPT_SHA256_STATE, pDst: PSYMCRYPT_SHA256_STATE); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha256Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha384(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha384Init(pState: PSYMCRYPT_SHA384_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha384Append(pState: PSYMCRYPT_SHA384_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha384Result(pState: PSYMCRYPT_SHA384_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha384StateCopy(pSrc: PCSYMCRYPT_SHA384_STATE, pDst: PSYMCRYPT_SHA384_STATE); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha384Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha512(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha512Init(pState: PSYMCRYPT_SHA512_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha512Append(pState: PSYMCRYPT_SHA512_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha512Result(pState: PSYMCRYPT_SHA512_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha512StateCopy(pSrc: PCSYMCRYPT_SHA512_STATE, pDst: PSYMCRYPT_SHA512_STATE); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha512Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_256(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_256Init(pState: PSYMCRYPT_SHA3_256_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_256Append(pState: PSYMCRYPT_SHA3_256_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_256Result(pState: PSYMCRYPT_SHA3_256_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_256StateCopy( pSrc: PCSYMCRYPT_SHA3_256_STATE, pDst: PSYMCRYPT_SHA3_256_STATE, ); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha3_256Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_384(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_384Init(pState: PSYMCRYPT_SHA3_384_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_384Append(pState: PSYMCRYPT_SHA3_384_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_384Result(pState: PSYMCRYPT_SHA3_384_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_384StateCopy( pSrc: PCSYMCRYPT_SHA3_384_STATE, pDst: PSYMCRYPT_SHA3_384_STATE, ); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha3_384Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_512(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_512Init(pState: PSYMCRYPT_SHA3_512_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_512Append(pState: PSYMCRYPT_SHA3_512_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_512Result(pState: PSYMCRYPT_SHA3_512_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_512StateCopy( pSrc: PCSYMCRYPT_SHA3_512_STATE, pDst: PSYMCRYPT_SHA3_512_STATE, ); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptSha3_512Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacMd5ExpandKey( pExpandedKey: PSYMCRYPT_HMAC_MD5_EXPANDED_KEY, pbKey: PCBYTE, cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacMd5( pExpandedKey: PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY, pbData: PCBYTE, @@ -4392,37 +2790,37 @@ extern "C" { pbResult: PBYTE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacMd5StateCopy( pSrc: PCSYMCRYPT_HMAC_MD5_STATE, pExpandedKey: PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY, pDst: PSYMCRYPT_HMAC_MD5_STATE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacMd5Init( pState: PSYMCRYPT_HMAC_MD5_STATE, pExpandedKey: PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacMd5Append(pState: PSYMCRYPT_HMAC_MD5_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacMd5Result(pState: PSYMCRYPT_HMAC_MD5_STATE, pbResult: PBYTE); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptHmacMd5Algorithm: PCSYMCRYPT_MAC; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha1ExpandKey( pExpandedKey: PSYMCRYPT_HMAC_SHA1_EXPANDED_KEY, pbKey: PCBYTE, cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha1( pExpandedKey: PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY, pbData: PCBYTE, @@ -4430,41 +2828,41 @@ extern "C" { pbResult: PBYTE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha1StateCopy( pSrc: PCSYMCRYPT_HMAC_SHA1_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY, pDst: PSYMCRYPT_HMAC_SHA1_STATE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha1Init( pState: PSYMCRYPT_HMAC_SHA1_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha1Append( pState: PSYMCRYPT_HMAC_SHA1_STATE, pbData: PCBYTE, cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha1Result(pState: PSYMCRYPT_HMAC_SHA1_STATE, pbResult: PBYTE); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptHmacSha1Algorithm: PCSYMCRYPT_MAC; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha256ExpandKey( pExpandedKey: PSYMCRYPT_HMAC_SHA256_EXPANDED_KEY, pbKey: PCBYTE, cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha256( pExpandedKey: PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY, pbData: PCBYTE, @@ -4472,41 +2870,41 @@ extern "C" { pbResult: PBYTE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha256StateCopy( pSrc: PCSYMCRYPT_HMAC_SHA256_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY, pDst: PSYMCRYPT_HMAC_SHA256_STATE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha256Init( pState: PSYMCRYPT_HMAC_SHA256_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha256Append( pState: PSYMCRYPT_HMAC_SHA256_STATE, pbData: PCBYTE, cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha256Result(pState: PSYMCRYPT_HMAC_SHA256_STATE, pbResult: PBYTE); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptHmacSha256Algorithm: PCSYMCRYPT_MAC; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha384ExpandKey( pExpandedKey: PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, pbKey: PCBYTE, cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha384( pExpandedKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, pbData: PCBYTE, @@ -4514,41 +2912,41 @@ extern "C" { pbResult: PBYTE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha384StateCopy( pSrc: PCSYMCRYPT_HMAC_SHA384_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, pDst: PSYMCRYPT_HMAC_SHA384_STATE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha384Init( pState: PSYMCRYPT_HMAC_SHA384_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha384Append( pState: PSYMCRYPT_HMAC_SHA384_STATE, pbData: PCBYTE, cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha384Result(pState: PSYMCRYPT_HMAC_SHA384_STATE, pbResult: PBYTE); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptHmacSha384Algorithm: PCSYMCRYPT_MAC; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha512ExpandKey( pExpandedKey: PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, pbKey: PCBYTE, cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha512( pExpandedKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, pbData: PCBYTE, @@ -4556,34 +2954,34 @@ extern "C" { pbResult: PBYTE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha512StateCopy( pSrc: PCSYMCRYPT_HMAC_SHA512_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, pDst: PSYMCRYPT_HMAC_SHA512_STATE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha512Init( pState: PSYMCRYPT_HMAC_SHA512_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha512Append( pState: PSYMCRYPT_HMAC_SHA512_STATE, pbData: PCBYTE, cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha512Result(pState: PSYMCRYPT_HMAC_SHA512_STATE, pbResult: PBYTE); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptHmacSha512Algorithm: PCSYMCRYPT_MAC; } -extern "C" { +unsafe extern "C" { pub fn SymCryptChaCha20Poly1305Encrypt( pbKey: PCBYTE, cbKey: SIZE_T, @@ -4598,7 +2996,7 @@ extern "C" { cbTag: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptChaCha20Poly1305Decrypt( pbKey: PCBYTE, cbKey: SIZE_T, @@ -4613,14 +3011,14 @@ extern "C" { cbTag: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptAesExpandKey( pExpandedKey: PSYMCRYPT_AES_EXPANDED_KEY, pbKey: PCBYTE, cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptAesCbcEncrypt( pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY, pbChainingValue: PBYTE, @@ -4629,7 +3027,7 @@ extern "C" { cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptAesCbcDecrypt( pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY, pbChainingValue: PBYTE, @@ -4638,11 +3036,11 @@ extern "C" { cbData: SIZE_T, ); } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptAesBlockCipher: PCSYMCRYPT_BLOCKCIPHER; } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmValidateParameters( pBlockCipher: PCSYMCRYPT_BLOCKCIPHER, cbNonce: SIZE_T, @@ -4651,7 +3049,7 @@ extern "C" { cbTag: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmExpandKey( pExpandedKey: PSYMCRYPT_GCM_EXPANDED_KEY, pBlockCipher: PCSYMCRYPT_BLOCKCIPHER, @@ -4659,7 +3057,7 @@ extern "C" { cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmEncrypt( pExpandedKey: PCSYMCRYPT_GCM_EXPANDED_KEY, pbNonce: PCBYTE, @@ -4673,7 +3071,7 @@ extern "C" { cbTag: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmDecrypt( pExpandedKey: PCSYMCRYPT_GCM_EXPANDED_KEY, pbNonce: PCBYTE, @@ -4687,7 +3085,7 @@ extern "C" { cbTag: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmInit( pState: PSYMCRYPT_GCM_STATE, pExpandedKey: PCSYMCRYPT_GCM_EXPANDED_KEY, @@ -4695,17 +3093,17 @@ extern "C" { cbNonce: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmStateCopy( pSrc: PCSYMCRYPT_GCM_STATE, pExpandedKeyCopy: PCSYMCRYPT_GCM_EXPANDED_KEY, pDst: PSYMCRYPT_GCM_STATE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmAuthPart(pState: PSYMCRYPT_GCM_STATE, pbAuthData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmEncryptPart( pState: PSYMCRYPT_GCM_STATE, pbSrc: PCBYTE, @@ -4713,10 +3111,10 @@ extern "C" { cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmEncryptFinal(pState: PSYMCRYPT_GCM_STATE, pbTag: PBYTE, cbTag: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmDecryptPart( pState: PSYMCRYPT_GCM_STATE, pbSrc: PCBYTE, @@ -4724,14 +3122,58 @@ extern "C" { cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmDecryptFinal( pState: PSYMCRYPT_GCM_STATE, pbTag: PCBYTE, cbTag: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { + pub fn SymCryptSp800_108ExpandKey( + pExpandedKey: PSYMCRYPT_SP800_108_EXPANDED_KEY, + macAlgorithm: PCSYMCRYPT_MAC, + pbKey: PCBYTE, + cbKey: SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptSp800_108Derive( + pExpandedKey: PCSYMCRYPT_SP800_108_EXPANDED_KEY, + pbLabel: PCBYTE, + cbLabel: SIZE_T, + pbContext: PCBYTE, + cbContext: SIZE_T, + pbResult: PBYTE, + cbResult: SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptSp800_108( + macAlgorithm: PCSYMCRYPT_MAC, + pbKey: PCBYTE, + cbKey: SIZE_T, + pbLabel: PCBYTE, + cbLabel: SIZE_T, + pbContext: PCBYTE, + cbContext: SIZE_T, + pbResult: PBYTE, + cbResult: SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptSp800_108_HmacSha1SelfTest(); +} +unsafe extern "C" { + pub fn SymCryptSp800_108_HmacSha256SelfTest(); +} +unsafe extern "C" { + pub fn SymCryptSp800_108_HmacSha384SelfTest(); +} +unsafe extern "C" { + pub fn SymCryptSp800_108_HmacSha512SelfTest(); +} +unsafe extern "C" { pub fn SymCryptTlsPrf1_2ExpandKey( pExpandedKey: PSYMCRYPT_TLSPRF1_2_EXPANDED_KEY, macAlgorithm: PCSYMCRYPT_MAC, @@ -4739,7 +3181,7 @@ extern "C" { cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptTlsPrf1_2Derive( pExpandedKey: PCSYMCRYPT_TLSPRF1_2_EXPANDED_KEY, pbLabel: PCBYTE, @@ -4750,7 +3192,7 @@ extern "C" { cbResult: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptTlsPrf1_2( macAlgorithm: PCSYMCRYPT_MAC, pbKey: PCBYTE, @@ -4763,7 +3205,7 @@ extern "C" { cbResult: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHkdfExpandKey( pExpandedKey: PSYMCRYPT_HKDF_EXPANDED_KEY, macAlgorithm: PCSYMCRYPT_MAC, @@ -4773,7 +3215,7 @@ extern "C" { cbSalt: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHkdfExtractPrk( macAlgorithm: PCSYMCRYPT_MAC, pbIkm: PCBYTE, @@ -4784,7 +3226,7 @@ extern "C" { cbPrk: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHkdfPrkExpandKey( pExpandedKey: PSYMCRYPT_HKDF_EXPANDED_KEY, macAlgorithm: PCSYMCRYPT_MAC, @@ -4792,7 +3234,7 @@ extern "C" { cbPrk: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHkdfDerive( pExpandedKey: PCSYMCRYPT_HKDF_EXPANDED_KEY, pbInfo: PCBYTE, @@ -4801,7 +3243,7 @@ extern "C" { cbResult: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHkdf( macAlgorithm: PCSYMCRYPT_MAC, pbIkm: PCBYTE, @@ -4814,16 +3256,112 @@ extern "C" { cbResult: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHkdfSelfTest(); } -#[cfg(feature = "dynamic")] -extern "C" { +unsafe extern "C" { pub fn SymCryptRandom(pbRandom: PBYTE, cbRandom: SIZE_T); } -#[cfg(not(feature = "dynamic"))] -extern "C" { - pub fn SymCryptCallbackRandom(pbBuffer: PBYTE, cbBuffer: SIZE_T) -> SYMCRYPT_ERROR; +unsafe extern "C" { + pub fn SymCryptXtsAesExpandKey( + pExpandedKey: PSYMCRYPT_XTS_AES_EXPANDED_KEY, + pbKey: PCBYTE, + cbKey: SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptXtsAesExpandKeyEx( + pExpandedKey: PSYMCRYPT_XTS_AES_EXPANDED_KEY, + pbKey: PCBYTE, + cbKey: SIZE_T, + flags: UINT32, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptXtsAesKeyCopy( + pSrc: PCSYMCRYPT_XTS_AES_EXPANDED_KEY, + pDst: PSYMCRYPT_XTS_AES_EXPANDED_KEY, + ); +} +unsafe extern "C" { + pub fn SymCryptXtsAesEncrypt( + pExpandedKey: PCSYMCRYPT_XTS_AES_EXPANDED_KEY, + cbDataUnit: SIZE_T, + tweak: UINT64, + pbSrc: PCBYTE, + pbDst: PBYTE, + cbData: SIZE_T, + ); +} +unsafe extern "C" { + pub fn SymCryptXtsAesDecrypt( + pExpandedKey: PCSYMCRYPT_XTS_AES_EXPANDED_KEY, + cbDataUnit: SIZE_T, + tweak: UINT64, + pbSrc: PCBYTE, + pbDst: PBYTE, + cbData: SIZE_T, + ); +} +unsafe extern "C" { + pub fn SymCryptXtsAesEncryptWith128bTweak( + pExpandedKey: PCSYMCRYPT_XTS_AES_EXPANDED_KEY, + cbDataUnit: SIZE_T, + pbTweak: PCBYTE, + pbSrc: PCBYTE, + pbDst: PBYTE, + cbData: SIZE_T, + ); +} +unsafe extern "C" { + pub fn SymCryptXtsAesDecryptWith128bTweak( + pExpandedKey: PCSYMCRYPT_XTS_AES_EXPANDED_KEY, + cbDataUnit: SIZE_T, + pbTweak: PCBYTE, + pbSrc: PCBYTE, + pbDst: PBYTE, + cbData: SIZE_T, + ); +} +unsafe extern "C" { + pub fn SymCryptAesKwEncrypt( + pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY, + pbSrc: PCBYTE, + cbSrc: SIZE_T, + pbDst: PBYTE, + cbDst: SIZE_T, + pcbResult: *mut SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptAesKwDecrypt( + pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY, + pbSrc: PCBYTE, + cbSrc: SIZE_T, + pbDst: PBYTE, + cbDst: SIZE_T, + pcbResult: *mut SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptAesKwpEncrypt( + pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY, + pbSrc: PCBYTE, + cbSrc: SIZE_T, + pbDst: PBYTE, + cbDst: SIZE_T, + pcbResult: *mut SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptAesKwpDecrypt( + pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY, + pbSrc: PCBYTE, + cbSrc: SIZE_T, + pbDst: PBYTE, + cbDst: SIZE_T, + pcbResult: *mut SIZE_T, + ) -> SYMCRYPT_ERROR; } pub const _SYMCRYPT_NUMBER_FORMAT_SYMCRYPT_NUMBER_FORMAT_LSB_FIRST: _SYMCRYPT_NUMBER_FORMAT = 1; pub const _SYMCRYPT_NUMBER_FORMAT_SYMCRYPT_NUMBER_FORMAT_MSB_FIRST: _SYMCRYPT_NUMBER_FORMAT = 2; @@ -4837,41 +3375,19 @@ pub struct _SYMCRYPT_RSA_PARAMS { pub nPrimes: UINT32, pub nPubExp: UINT32, } -#[test] -fn bindgen_test_layout__SYMCRYPT_RSA_PARAMS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_RSA_PARAMS> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_RSA_PARAMS>(), - 16usize, - "Size of _SYMCRYPT_RSA_PARAMS" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_RSA_PARAMS>(), - 4usize, - "Alignment of _SYMCRYPT_RSA_PARAMS" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_RSA_PARAMS::version" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBitsOfModulus) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_RSA_PARAMS::nBitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPrimes) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_RSA_PARAMS::nPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPubExp) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_RSA_PARAMS::nPubExp" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_RSA_PARAMS"][::std::mem::size_of::<_SYMCRYPT_RSA_PARAMS>() - 16usize]; + ["Alignment of _SYMCRYPT_RSA_PARAMS"][::std::mem::align_of::<_SYMCRYPT_RSA_PARAMS>() - 4usize]; + ["Offset of field: _SYMCRYPT_RSA_PARAMS::version"] + [::std::mem::offset_of!(_SYMCRYPT_RSA_PARAMS, version) - 0usize]; + ["Offset of field: _SYMCRYPT_RSA_PARAMS::nBitsOfModulus"] + [::std::mem::offset_of!(_SYMCRYPT_RSA_PARAMS, nBitsOfModulus) - 4usize]; + ["Offset of field: _SYMCRYPT_RSA_PARAMS::nPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSA_PARAMS, nPrimes) - 8usize]; + ["Offset of field: _SYMCRYPT_RSA_PARAMS::nPubExp"] + [::std::mem::offset_of!(_SYMCRYPT_RSA_PARAMS, nPubExp) - 12usize]; +}; pub type SYMCRYPT_RSA_PARAMS = _SYMCRYPT_RSA_PARAMS; pub type PCSYMCRYPT_RSA_PARAMS = *const SYMCRYPT_RSA_PARAMS; pub const _SYMCRYPT_ECURVE_GEN_ALG_ID_SYMCRYPT_ECURVE_GEN_ALG_ID_NULL: _SYMCRYPT_ECURVE_GEN_ALG_ID = @@ -4889,57 +3405,26 @@ pub struct _SYMCRYPT_ECURVE_PARAMS { pub cbCofactor: UINT32, pub cbSeed: UINT32, } -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE_PARAMS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE_PARAMS> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE_PARAMS>(), - 28usize, - "Size of _SYMCRYPT_ECURVE_PARAMS" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE_PARAMS>(), - 4usize, - "Alignment of _SYMCRYPT_ECURVE_PARAMS" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::version" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).algId) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::algId" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbFieldLength) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbFieldLength" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSubgroupOrder) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbSubgroupOrder" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbCofactor) as usize - ptr as usize }, - 20usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbCofactor" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSeed) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbSeed" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_ECURVE_PARAMS"][::std::mem::size_of::<_SYMCRYPT_ECURVE_PARAMS>() - 28usize]; + ["Alignment of _SYMCRYPT_ECURVE_PARAMS"] + [::std::mem::align_of::<_SYMCRYPT_ECURVE_PARAMS>() - 4usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::version"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, version) - 0usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::type_"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, type_) - 4usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::algId"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, algId) - 8usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbFieldLength"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, cbFieldLength) - 12usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbSubgroupOrder"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, cbSubgroupOrder) - 16usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbCofactor"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, cbCofactor) - 20usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbSeed"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, cbSeed) - 24usize]; +}; impl Default for _SYMCRYPT_ECURVE_PARAMS { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -4955,52 +3440,52 @@ pub const _SYMCRYPT_ECPOINT_FORMAT_SYMCRYPT_ECPOINT_FORMAT_X: _SYMCRYPT_ECPOINT_ pub const _SYMCRYPT_ECPOINT_FORMAT_SYMCRYPT_ECPOINT_FORMAT_XY: _SYMCRYPT_ECPOINT_FORMAT = 2; pub type _SYMCRYPT_ECPOINT_FORMAT = ::std::os::raw::c_int; pub use self::_SYMCRYPT_ECPOINT_FORMAT as SYMCRYPT_ECPOINT_FORMAT; -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyAllocate( pParams: PCSYMCRYPT_RSA_PARAMS, flags: UINT32, ) -> PSYMCRYPT_RSAKEY; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyFree(pkObj: PSYMCRYPT_RSAKEY); } -extern "C" { +unsafe extern "C" { pub fn SymCryptEcurveAllocate( pParams: PCSYMCRYPT_ECURVE_PARAMS, flags: UINT32, ) -> PSYMCRYPT_ECURVE; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEcurveFree(pCurve: PSYMCRYPT_ECURVE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeyAllocate(pCurve: PCSYMCRYPT_ECURVE) -> PSYMCRYPT_ECKEY; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeyFree(pkObj: PSYMCRYPT_ECKEY); } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyHasPrivateKey(pkRsakey: PCSYMCRYPT_RSAKEY) -> BOOLEAN; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeySizeofModulus(pkRsakey: PCSYMCRYPT_RSAKEY) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyModulusBits(pkRsakey: PCSYMCRYPT_RSAKEY) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeySizeofPublicExponent(pRsakey: PCSYMCRYPT_RSAKEY, index: UINT32) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeySizeofPrime(pkRsakey: PCSYMCRYPT_RSAKEY, index: UINT32) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyGetNumberOfPublicExponents(pkRsakey: PCSYMCRYPT_RSAKEY) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyGetNumberOfPrimes(pkRsakey: PCSYMCRYPT_RSAKEY) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyGenerate( pkRsakey: PSYMCRYPT_RSAKEY, pu64PubExp: PCUINT64, @@ -5008,7 +3493,7 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeySetValue( pbModulus: PCBYTE, cbModulus: SIZE_T, @@ -5022,7 +3507,7 @@ extern "C" { pkRsakey: PSYMCRYPT_RSAKEY, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeySetValueFromPrivateExponent( pbModulus: PCBYTE, cbModulus: SIZE_T, @@ -5034,7 +3519,7 @@ extern "C" { pkRsakey: PSYMCRYPT_RSAKEY, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyGetValue( pkRsakey: PCSYMCRYPT_RSAKEY, pbModulus: PBYTE, @@ -5048,7 +3533,7 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyGetCrtValue( pkRsakey: PCSYMCRYPT_RSAKEY, ppCrtExponents: *mut PBYTE, @@ -5062,41 +3547,41 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyExtendKeyUsage( pkRsakey: PSYMCRYPT_RSAKEY, flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEcurveSizeofFieldElement(pCurve: PCSYMCRYPT_ECURVE) -> UINT32; } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptEcurveParamsNistP256: PCSYMCRYPT_ECURVE_PARAMS; } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptEcurveParamsNistP384: PCSYMCRYPT_ECURVE_PARAMS; } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptEcurveParamsNistP521: PCSYMCRYPT_ECURVE_PARAMS; } -#[cfg_attr(feature = "dynamic", link(name = "symcrypt", kind = "dylib"))] -extern "C" { +#[link(name = "symcrypt", kind = "dylib")] +unsafe extern "C" { pub static SymCryptEcurveParamsCurve25519: PCSYMCRYPT_ECURVE_PARAMS; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeySizeofPublicKey( pkEckey: PCSYMCRYPT_ECKEY, ecPointFormat: SYMCRYPT_ECPOINT_FORMAT, ) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeySizeofPrivateKey(pkEckey: PCSYMCRYPT_ECKEY) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeySetValue( pbPrivateKey: PCBYTE, cbPrivateKey: SIZE_T, @@ -5108,10 +3593,10 @@ extern "C" { pEckey: PSYMCRYPT_ECKEY, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeySetRandom(flags: UINT32, pEckey: PSYMCRYPT_ECKEY) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeyGetValue( pEckey: PCSYMCRYPT_ECKEY, pbPrivateKey: PBYTE, @@ -5123,7 +3608,7 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaPkcs1Encrypt( pkRsakey: PCSYMCRYPT_RSAKEY, pbSrc: PCBYTE, @@ -5135,7 +3620,7 @@ extern "C" { pcbDst: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaPkcs1Decrypt( pkRsakey: PCSYMCRYPT_RSAKEY, pbSrc: PCBYTE, @@ -5147,7 +3632,7 @@ extern "C" { pcbDst: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaOaepEncrypt( pkRsakey: PCSYMCRYPT_RSAKEY, pbSrc: PCBYTE, @@ -5162,7 +3647,7 @@ extern "C" { pcbDst: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaOaepDecrypt( pkRsakey: PCSYMCRYPT_RSAKEY, pbSrc: PCBYTE, @@ -5177,7 +3662,7 @@ extern "C" { pcbDst: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaPkcs1Sign( pkRsakey: PCSYMCRYPT_RSAKEY, pbHashValue: PCBYTE, @@ -5191,7 +3676,7 @@ extern "C" { pcbSignature: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaPkcs1Verify( pkRsakey: PCSYMCRYPT_RSAKEY, pbHashValue: PCBYTE, @@ -5204,7 +3689,7 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaPssSign( pkRsakey: PCSYMCRYPT_RSAKEY, pbHashValue: PCBYTE, @@ -5218,7 +3703,7 @@ extern "C" { pcbSignature: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaPssVerify( pkRsakey: PCSYMCRYPT_RSAKEY, pbHashValue: PCBYTE, @@ -5231,7 +3716,7 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEcDsaSign( pKey: PCSYMCRYPT_ECKEY, pbHashValue: PCBYTE, @@ -5242,7 +3727,7 @@ extern "C" { cbSignature: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEcDsaVerify( pKey: PCSYMCRYPT_ECKEY, pbHashValue: PCBYTE, @@ -5253,7 +3738,7 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEcDhSecretAgreement( pkPrivate: PCSYMCRYPT_ECKEY, pkPublic: PCSYMCRYPT_ECKEY, diff --git a/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs b/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs index cb35fa3c..13e65aa9 100644 --- a/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs +++ b/symcrypt-sys/src/bindings/x86_64_unknown_linux_gnu.rs @@ -71,32 +71,17 @@ pub struct _SYMCRYPT_MD2_CHAINING_STATE { pub C: [BYTE; 16usize], pub X: [BYTE; 48usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_MD2_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD2_CHAINING_STATE>(), - 64usize, - "Size of _SYMCRYPT_MD2_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD2_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD2_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).C) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::C" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).X) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::X" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MD2_CHAINING_STATE"] + [::std::mem::size_of::<_SYMCRYPT_MD2_CHAINING_STATE>() - 64usize]; + ["Alignment of _SYMCRYPT_MD2_CHAINING_STATE"] + [::std::mem::align_of::<_SYMCRYPT_MD2_CHAINING_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::C"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_CHAINING_STATE, C) - 0usize]; + ["Offset of field: _SYMCRYPT_MD2_CHAINING_STATE::X"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_CHAINING_STATE, X) - 16usize]; +}; impl Default for _SYMCRYPT_MD2_CHAINING_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -118,51 +103,23 @@ pub struct _SYMCRYPT_MD2_STATE { pub buffer: [BYTE; 16usize], pub chain: SYMCRYPT_MD2_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MD2_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD2_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD2_STATE>(), - 112usize, - "Size of _SYMCRYPT_MD2_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD2_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD2_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD2_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MD2_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MD2_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MD2_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MD2_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_MD2_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MD2_STATE"][::std::mem::size_of::<_SYMCRYPT_MD2_STATE>() - 112usize]; + ["Alignment of _SYMCRYPT_MD2_STATE"][::std::mem::align_of::<_SYMCRYPT_MD2_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_MD2_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_MD2_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_MD2_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_MD2_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_MD2_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_MD2_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_MD2_STATE, chain) - 48usize]; +}; impl Default for _SYMCRYPT_MD2_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -179,27 +136,15 @@ pub type SYMCRYPT_MD2_STATE = _SYMCRYPT_MD2_STATE; pub struct _SYMCRYPT_MD4_CHAINING_STATE { pub H: [UINT32; 4usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_MD4_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD4_CHAINING_STATE>(), - 16usize, - "Size of _SYMCRYPT_MD4_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD4_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD4_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD4_CHAINING_STATE::H" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MD4_CHAINING_STATE"] + [::std::mem::size_of::<_SYMCRYPT_MD4_CHAINING_STATE>() - 16usize]; + ["Alignment of _SYMCRYPT_MD4_CHAINING_STATE"] + [::std::mem::align_of::<_SYMCRYPT_MD4_CHAINING_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_MD4_CHAINING_STATE::H"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_CHAINING_STATE, H) - 0usize]; +}; pub type SYMCRYPT_MD4_CHAINING_STATE = _SYMCRYPT_MD4_CHAINING_STATE; #[repr(C)] #[repr(align(16))] @@ -212,51 +157,23 @@ pub struct _SYMCRYPT_MD4_STATE { pub buffer: [BYTE; 64usize], pub chain: SYMCRYPT_MD4_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MD4_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD4_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD4_STATE>(), - 112usize, - "Size of _SYMCRYPT_MD4_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD4_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD4_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD4_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MD4_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MD4_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MD4_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MD4_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_MD4_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MD4_STATE"][::std::mem::size_of::<_SYMCRYPT_MD4_STATE>() - 112usize]; + ["Alignment of _SYMCRYPT_MD4_STATE"][::std::mem::align_of::<_SYMCRYPT_MD4_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_MD4_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_MD4_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_MD4_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_MD4_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_MD4_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_MD4_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_MD4_STATE, chain) - 96usize]; +}; impl Default for _SYMCRYPT_MD4_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -273,27 +190,15 @@ pub type SYMCRYPT_MD4_STATE = _SYMCRYPT_MD4_STATE; pub struct _SYMCRYPT_MD5_CHAINING_STATE { pub H: [UINT32; 4usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_MD5_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD5_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD5_CHAINING_STATE>(), - 16usize, - "Size of _SYMCRYPT_MD5_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD5_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD5_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD5_CHAINING_STATE::H" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MD5_CHAINING_STATE"] + [::std::mem::size_of::<_SYMCRYPT_MD5_CHAINING_STATE>() - 16usize]; + ["Alignment of _SYMCRYPT_MD5_CHAINING_STATE"] + [::std::mem::align_of::<_SYMCRYPT_MD5_CHAINING_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_MD5_CHAINING_STATE::H"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_CHAINING_STATE, H) - 0usize]; +}; pub type SYMCRYPT_MD5_CHAINING_STATE = _SYMCRYPT_MD5_CHAINING_STATE; #[repr(C)] #[repr(align(16))] @@ -306,51 +211,23 @@ pub struct _SYMCRYPT_MD5_STATE { pub buffer: [BYTE; 64usize], pub chain: SYMCRYPT_MD5_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MD5_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MD5_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MD5_STATE>(), - 112usize, - "Size of _SYMCRYPT_MD5_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MD5_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_MD5_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MD5_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MD5_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MD5_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MD5_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MD5_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_MD5_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MD5_STATE"][::std::mem::size_of::<_SYMCRYPT_MD5_STATE>() - 112usize]; + ["Alignment of _SYMCRYPT_MD5_STATE"][::std::mem::align_of::<_SYMCRYPT_MD5_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_MD5_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_MD5_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_MD5_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_MD5_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_MD5_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_MD5_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_MD5_STATE, chain) - 96usize]; +}; impl Default for _SYMCRYPT_MD5_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -369,27 +246,15 @@ pub type PCSYMCRYPT_MD5_STATE = *const SYMCRYPT_MD5_STATE; pub struct _SYMCRYPT_SHA1_CHAINING_STATE { pub H: [UINT32; 5usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA1_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA1_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA1_CHAINING_STATE>(), - 32usize, - "Size of _SYMCRYPT_SHA1_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA1_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA1_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA1_CHAINING_STATE::H" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA1_CHAINING_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA1_CHAINING_STATE>() - 32usize]; + ["Alignment of _SYMCRYPT_SHA1_CHAINING_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA1_CHAINING_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA1_CHAINING_STATE::H"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_CHAINING_STATE, H) - 0usize]; +}; pub type SYMCRYPT_SHA1_CHAINING_STATE = _SYMCRYPT_SHA1_CHAINING_STATE; #[repr(C)] #[repr(align(16))] @@ -402,51 +267,23 @@ pub struct _SYMCRYPT_SHA1_STATE { pub buffer: [BYTE; 64usize], pub chain: SYMCRYPT_SHA1_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA1_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA1_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA1_STATE>(), - 128usize, - "Size of _SYMCRYPT_SHA1_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA1_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA1_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_SHA1_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA1_STATE"][::std::mem::size_of::<_SYMCRYPT_SHA1_STATE>() - 128usize]; + ["Alignment of _SYMCRYPT_SHA1_STATE"][::std::mem::align_of::<_SYMCRYPT_SHA1_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA1_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA1_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA1_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA1_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA1_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA1_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA1_STATE, chain) - 96usize]; +}; impl Default for _SYMCRYPT_SHA1_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -465,27 +302,15 @@ pub type PCSYMCRYPT_SHA1_STATE = *const SYMCRYPT_SHA1_STATE; pub struct _SYMCRYPT_SHA256_CHAINING_STATE { pub H: [UINT32; 8usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA256_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA256_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA256_CHAINING_STATE>(), - 32usize, - "Size of _SYMCRYPT_SHA256_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA256_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA256_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA256_CHAINING_STATE::H" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA256_CHAINING_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA256_CHAINING_STATE>() - 32usize]; + ["Alignment of _SYMCRYPT_SHA256_CHAINING_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA256_CHAINING_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA256_CHAINING_STATE::H"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_CHAINING_STATE, H) - 0usize]; +}; pub type SYMCRYPT_SHA256_CHAINING_STATE = _SYMCRYPT_SHA256_CHAINING_STATE; #[repr(C)] #[repr(align(16))] @@ -498,52 +323,24 @@ pub struct _SYMCRYPT_SHA256_STATE { pub buffer: [BYTE; 64usize], pub chain: SYMCRYPT_SHA256_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA256_STATE>(), - 128usize, - "Size of _SYMCRYPT_SHA256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_SHA256_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA256_STATE"][::std::mem::size_of::<_SYMCRYPT_SHA256_STATE>() - 128usize]; + ["Alignment of _SYMCRYPT_SHA256_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA256_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA256_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA256_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA256_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA256_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA256_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA256_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA256_STATE, chain) - 96usize]; +}; impl Default for _SYMCRYPT_SHA256_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -567,52 +364,24 @@ pub struct _SYMCRYPT_SHA224_STATE { pub buffer: [BYTE; 64usize], pub chain: SYMCRYPT_SHA256_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA224_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA224_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA224_STATE>(), - 128usize, - "Size of _SYMCRYPT_SHA224_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA224_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA224_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_SHA224_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA224_STATE"][::std::mem::size_of::<_SYMCRYPT_SHA224_STATE>() - 128usize]; + ["Alignment of _SYMCRYPT_SHA224_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA224_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA224_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA224_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA224_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA224_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA224_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA224_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA224_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA224_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA224_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA224_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA224_STATE, chain) - 96usize]; +}; impl Default for _SYMCRYPT_SHA224_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -629,27 +398,15 @@ pub type SYMCRYPT_SHA224_STATE = _SYMCRYPT_SHA224_STATE; pub struct _SYMCRYPT_SHA512_CHAINING_STATE { pub H: [UINT64; 8usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_CHAINING_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_CHAINING_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_CHAINING_STATE>(), - 64usize, - "Size of _SYMCRYPT_SHA512_CHAINING_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_CHAINING_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_CHAINING_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_CHAINING_STATE::H" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA512_CHAINING_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA512_CHAINING_STATE>() - 64usize]; + ["Alignment of _SYMCRYPT_SHA512_CHAINING_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA512_CHAINING_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_CHAINING_STATE::H"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_CHAINING_STATE, H) - 0usize]; +}; pub type SYMCRYPT_SHA512_CHAINING_STATE = _SYMCRYPT_SHA512_CHAINING_STATE; #[repr(C)] #[repr(align(16))] @@ -662,52 +419,24 @@ pub struct _SYMCRYPT_SHA512_STATE { pub buffer: [BYTE; 128usize], pub chain: SYMCRYPT_SHA512_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA512_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA512_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA512_STATE"][::std::mem::size_of::<_SYMCRYPT_SHA512_STATE>() - 224usize]; + ["Alignment of _SYMCRYPT_SHA512_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA512_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA512_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA512_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA512_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA512_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_STATE, chain) - 160usize]; +}; impl Default for _SYMCRYPT_SHA512_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -731,52 +460,24 @@ pub struct _SYMCRYPT_SHA384_STATE { pub buffer: [BYTE; 128usize], pub chain: SYMCRYPT_SHA512_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA384_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA384_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA384_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA384_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA384_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA384_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA384_STATE"][::std::mem::size_of::<_SYMCRYPT_SHA384_STATE>() - 224usize]; + ["Alignment of _SYMCRYPT_SHA384_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA384_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA384_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA384_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA384_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA384_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA384_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA384_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA384_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA384_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA384_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA384_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA384_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA384_STATE, chain) - 160usize]; +}; impl Default for _SYMCRYPT_SHA384_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -800,52 +501,25 @@ pub struct _SYMCRYPT_SHA512_224_STATE { pub buffer: [BYTE; 128usize], pub chain: SYMCRYPT_SHA512_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_224_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_224_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_224_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA512_224_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_224_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_224_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA512_224_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA512_224_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA512_224_STATE>() - 224usize]; + ["Alignment of _SYMCRYPT_SHA512_224_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA512_224_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_224_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_224_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA512_224_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_224_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_224_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_224_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_224_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA512_224_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_224_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA512_224_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_224_STATE, chain) - 160usize]; +}; impl Default for _SYMCRYPT_SHA512_224_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -867,52 +541,25 @@ pub struct _SYMCRYPT_SHA512_256_STATE { pub buffer: [BYTE; 128usize], pub chain: SYMCRYPT_SHA512_CHAINING_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA512_256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA512_256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA512_256_STATE>(), - 224usize, - "Size of _SYMCRYPT_SHA512_256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA512_256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA512_256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInBuffer) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::bytesInBuffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthL) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthL" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).dataLengthH) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).buffer) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::buffer" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chain) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_SHA512_256_STATE::chain" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA512_256_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA512_256_STATE>() - 224usize]; + ["Alignment of _SYMCRYPT_SHA512_256_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA512_256_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_256_STATE::bytesInBuffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_256_STATE, bytesInBuffer) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA512_256_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_256_STATE, magic) - 8usize]; + ["Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthL"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_256_STATE, dataLengthL) - 16usize]; + ["Offset of field: _SYMCRYPT_SHA512_256_STATE::dataLengthH"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_256_STATE, dataLengthH) - 24usize]; + ["Offset of field: _SYMCRYPT_SHA512_256_STATE::buffer"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_256_STATE, buffer) - 32usize]; + ["Offset of field: _SYMCRYPT_SHA512_256_STATE::chain"] + [::std::mem::offset_of!(_SYMCRYPT_SHA512_256_STATE, chain) - 160usize]; +}; impl Default for _SYMCRYPT_SHA512_256_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -933,47 +580,22 @@ pub struct _SYMCRYPT_KECCAK_STATE { pub paddingValue: UINT8, pub squeezeMode: BOOLEAN, } -#[test] -fn bindgen_test_layout__SYMCRYPT_KECCAK_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KECCAK_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KECCAK_STATE>(), - 224usize, - "Size of _SYMCRYPT_KECCAK_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KECCAK_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_KECCAK_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).state) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::state" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, - 200usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::inputBlockSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateIndex) as usize - ptr as usize }, - 204usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::stateIndex" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).paddingValue) as usize - ptr as usize }, - 208usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::paddingValue" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).squeezeMode) as usize - ptr as usize }, - 209usize, - "Offset of field: _SYMCRYPT_KECCAK_STATE::squeezeMode" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_KECCAK_STATE"][::std::mem::size_of::<_SYMCRYPT_KECCAK_STATE>() - 224usize]; + ["Alignment of _SYMCRYPT_KECCAK_STATE"] + [::std::mem::align_of::<_SYMCRYPT_KECCAK_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_KECCAK_STATE::state"] + [::std::mem::offset_of!(_SYMCRYPT_KECCAK_STATE, state) - 0usize]; + ["Offset of field: _SYMCRYPT_KECCAK_STATE::inputBlockSize"] + [::std::mem::offset_of!(_SYMCRYPT_KECCAK_STATE, inputBlockSize) - 200usize]; + ["Offset of field: _SYMCRYPT_KECCAK_STATE::stateIndex"] + [::std::mem::offset_of!(_SYMCRYPT_KECCAK_STATE, stateIndex) - 204usize]; + ["Offset of field: _SYMCRYPT_KECCAK_STATE::paddingValue"] + [::std::mem::offset_of!(_SYMCRYPT_KECCAK_STATE, paddingValue) - 208usize]; + ["Offset of field: _SYMCRYPT_KECCAK_STATE::squeezeMode"] + [::std::mem::offset_of!(_SYMCRYPT_KECCAK_STATE, squeezeMode) - 209usize]; +}; pub type SYMCRYPT_KECCAK_STATE = _SYMCRYPT_KECCAK_STATE; #[repr(C)] #[repr(align(16))] @@ -982,32 +604,17 @@ pub struct _SYMCRYPT_SHA3_224_STATE { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_224_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_224_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_224_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_224_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_224_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_224_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_224_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_224_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA3_224_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA3_224_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_SHA3_224_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA3_224_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA3_224_STATE::ks"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_224_STATE, ks) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA3_224_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_224_STATE, magic) - 224usize]; +}; pub type SYMCRYPT_SHA3_224_STATE = _SYMCRYPT_SHA3_224_STATE; #[repr(C)] #[repr(align(16))] @@ -1016,32 +623,17 @@ pub struct _SYMCRYPT_SHA3_256_STATE { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_256_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_256_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_256_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA3_256_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA3_256_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_SHA3_256_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA3_256_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA3_256_STATE::ks"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_256_STATE, ks) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA3_256_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_256_STATE, magic) - 224usize]; +}; pub type SYMCRYPT_SHA3_256_STATE = _SYMCRYPT_SHA3_256_STATE; pub type PSYMCRYPT_SHA3_256_STATE = *mut _SYMCRYPT_SHA3_256_STATE; pub type PCSYMCRYPT_SHA3_256_STATE = *const SYMCRYPT_SHA3_256_STATE; @@ -1052,32 +644,17 @@ pub struct _SYMCRYPT_SHA3_384_STATE { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_384_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_384_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_384_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_384_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_384_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_384_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_384_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA3_384_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA3_384_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_SHA3_384_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA3_384_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA3_384_STATE::ks"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_384_STATE, ks) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA3_384_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_384_STATE, magic) - 224usize]; +}; pub type SYMCRYPT_SHA3_384_STATE = _SYMCRYPT_SHA3_384_STATE; pub type PSYMCRYPT_SHA3_384_STATE = *mut _SYMCRYPT_SHA3_384_STATE; pub type PCSYMCRYPT_SHA3_384_STATE = *const SYMCRYPT_SHA3_384_STATE; @@ -1088,32 +665,17 @@ pub struct _SYMCRYPT_SHA3_512_STATE { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_SHA3_512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_SHA3_512_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_SHA3_512_STATE>(), - 240usize, - "Size of _SYMCRYPT_SHA3_512_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_SHA3_512_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_SHA3_512_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_SHA3_512_STATE::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_SHA3_512_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SHA3_512_STATE"] + [::std::mem::size_of::<_SYMCRYPT_SHA3_512_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_SHA3_512_STATE"] + [::std::mem::align_of::<_SYMCRYPT_SHA3_512_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_SHA3_512_STATE::ks"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_512_STATE, ks) - 0usize]; + ["Offset of field: _SYMCRYPT_SHA3_512_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_SHA3_512_STATE, magic) - 224usize]; +}; pub type SYMCRYPT_SHA3_512_STATE = _SYMCRYPT_SHA3_512_STATE; pub type PSYMCRYPT_SHA3_512_STATE = *mut _SYMCRYPT_SHA3_512_STATE; pub type PCSYMCRYPT_SHA3_512_STATE = *const SYMCRYPT_SHA3_512_STATE; @@ -1124,32 +686,17 @@ pub struct _SYMCRYPT_KMAC128_EXPANDED_KEY { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_KMAC128_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC128_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(), - 240usize, - "Size of _SYMCRYPT_KMAC128_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_KMAC128_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_KMAC128_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>() - 240usize]; + ["Alignment of _SYMCRYPT_KMAC128_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_KMAC128_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::ks"] + [::std::mem::offset_of!(_SYMCRYPT_KMAC128_EXPANDED_KEY, ks) - 0usize]; + ["Offset of field: _SYMCRYPT_KMAC128_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_KMAC128_EXPANDED_KEY, magic) - 224usize]; +}; pub type SYMCRYPT_KMAC128_EXPANDED_KEY = _SYMCRYPT_KMAC128_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] @@ -1158,32 +705,17 @@ pub struct _SYMCRYPT_KMAC256_EXPANDED_KEY { pub ks: SYMCRYPT_KECCAK_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_KMAC256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_KMAC256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(), - 240usize, - "Size of _SYMCRYPT_KMAC256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_KMAC256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ks) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::ks" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_KMAC256_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>() - 240usize]; + ["Alignment of _SYMCRYPT_KMAC256_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_KMAC256_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::ks"] + [::std::mem::offset_of!(_SYMCRYPT_KMAC256_EXPANDED_KEY, ks) - 0usize]; + ["Offset of field: _SYMCRYPT_KMAC256_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_KMAC256_EXPANDED_KEY, magic) - 224usize]; +}; pub type SYMCRYPT_KMAC256_EXPANDED_KEY = _SYMCRYPT_KMAC256_EXPANDED_KEY; #[repr(C)] #[derive(Debug, Copy, Clone)] @@ -1191,31 +723,15 @@ pub struct _SYMCRYPT_OID { pub cbOID: UINT32, pub pbOID: PCBYTE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_OID() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_OID> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_OID>(), - 16usize, - "Size of _SYMCRYPT_OID" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_OID>(), - 8usize, - "Alignment of _SYMCRYPT_OID" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbOID) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_OID::cbOID" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbOID) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_OID::pbOID" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_OID"][::std::mem::size_of::<_SYMCRYPT_OID>() - 16usize]; + ["Alignment of _SYMCRYPT_OID"][::std::mem::align_of::<_SYMCRYPT_OID>() - 8usize]; + ["Offset of field: _SYMCRYPT_OID::cbOID"] + [::std::mem::offset_of!(_SYMCRYPT_OID, cbOID) - 0usize]; + ["Offset of field: _SYMCRYPT_OID::pbOID"] + [::std::mem::offset_of!(_SYMCRYPT_OID, pbOID) - 8usize]; +}; impl Default for _SYMCRYPT_OID { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1227,28 +743,28 @@ impl Default for _SYMCRYPT_OID { } pub type SYMCRYPT_OID = _SYMCRYPT_OID; pub type PCSYMCRYPT_OID = *const SYMCRYPT_OID; -extern "C" { +unsafe extern "C" { pub static SymCryptMd5OidList: [SYMCRYPT_OID; 2usize]; } -extern "C" { +unsafe extern "C" { pub static SymCryptSha1OidList: [SYMCRYPT_OID; 2usize]; } -extern "C" { +unsafe extern "C" { pub static SymCryptSha256OidList: [SYMCRYPT_OID; 2usize]; } -extern "C" { +unsafe extern "C" { pub static SymCryptSha384OidList: [SYMCRYPT_OID; 2usize]; } -extern "C" { +unsafe extern "C" { pub static SymCryptSha512OidList: [SYMCRYPT_OID; 2usize]; } -extern "C" { +unsafe extern "C" { pub static SymCryptSha3_256OidList: [SYMCRYPT_OID; 2usize]; } -extern "C" { +unsafe extern "C" { pub static SymCryptSha3_384OidList: [SYMCRYPT_OID; 2usize]; } -extern "C" { +unsafe extern "C" { pub static SymCryptSha3_512OidList: [SYMCRYPT_OID; 2usize]; } #[repr(C)] @@ -1270,91 +786,39 @@ pub union _SYMCRYPT_HASH_STATE { pub sha3_384State: SYMCRYPT_SHA3_384_STATE, pub sha3_512State: SYMCRYPT_SHA3_512_STATE, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HASH_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HASH_STATE>(), - 240usize, - "Size of _SYMCRYPT_HASH_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HASH_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HASH_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md2State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::md2State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md4State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::md4State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md5State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::md5State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha1State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha1State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha224State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha224State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha256State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha256State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha384State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha384State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha512State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_224State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha512_224State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_256State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha512_256State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_224State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_224State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_256State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_256State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_384State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_384State" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_512State) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH_STATE::sha3_512State" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HASH_STATE"][::std::mem::size_of::<_SYMCRYPT_HASH_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_HASH_STATE"][::std::mem::align_of::<_SYMCRYPT_HASH_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::md2State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, md2State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::md4State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, md4State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::md5State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, md5State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha1State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha1State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha224State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha224State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha256State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha256State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha384State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha384State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha512State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha512State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha512_224State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha512_224State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha512_256State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha512_256State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha3_224State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha3_224State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha3_256State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha3_256State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha3_384State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha3_384State) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH_STATE::sha3_512State"] + [::std::mem::offset_of!(_SYMCRYPT_HASH_STATE, sha3_512State) - 0usize]; +}; impl Default for _SYMCRYPT_HASH_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1392,71 +856,31 @@ pub struct _SYMCRYPT_HASH { pub chainOffset: UINT32, pub chainSize: UINT32, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HASH() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HASH> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HASH>(), - 64usize, - "Size of _SYMCRYPT_HASH" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HASH>(), - 16usize, - "Alignment of _SYMCRYPT_HASH" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).initFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HASH::initFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_HASH::appendFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_HASH::resultFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendBlockFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_HASH::appendBlockFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateCopyFunc) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HASH::stateCopyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateSize) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_HASH::stateSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultSize) as usize - ptr as usize }, - 44usize, - "Offset of field: _SYMCRYPT_HASH::resultSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inputBlockSize) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_HASH::inputBlockSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chainOffset) as usize - ptr as usize }, - 52usize, - "Offset of field: _SYMCRYPT_HASH::chainOffset" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).chainSize) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_HASH::chainSize" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HASH"][::std::mem::size_of::<_SYMCRYPT_HASH>() - 64usize]; + ["Alignment of _SYMCRYPT_HASH"][::std::mem::align_of::<_SYMCRYPT_HASH>() - 16usize]; + ["Offset of field: _SYMCRYPT_HASH::initFunc"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, initFunc) - 0usize]; + ["Offset of field: _SYMCRYPT_HASH::appendFunc"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, appendFunc) - 8usize]; + ["Offset of field: _SYMCRYPT_HASH::resultFunc"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, resultFunc) - 16usize]; + ["Offset of field: _SYMCRYPT_HASH::appendBlockFunc"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, appendBlockFunc) - 24usize]; + ["Offset of field: _SYMCRYPT_HASH::stateCopyFunc"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, stateCopyFunc) - 32usize]; + ["Offset of field: _SYMCRYPT_HASH::stateSize"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, stateSize) - 40usize]; + ["Offset of field: _SYMCRYPT_HASH::resultSize"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, resultSize) - 44usize]; + ["Offset of field: _SYMCRYPT_HASH::inputBlockSize"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, inputBlockSize) - 48usize]; + ["Offset of field: _SYMCRYPT_HASH::chainOffset"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, chainOffset) - 52usize]; + ["Offset of field: _SYMCRYPT_HASH::chainSize"] + [::std::mem::offset_of!(_SYMCRYPT_HASH, chainSize) - 56usize]; +}; #[repr(C)] #[repr(align(16))] #[derive(Debug, Default, Copy, Clone)] @@ -1465,37 +889,19 @@ pub struct _SYMCRYPT_HMAC_MD5_EXPANDED_KEY { pub outerState: SYMCRYPT_MD5_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), - 48usize, - "Size of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>() - 48usize]; + ["Alignment of _SYMCRYPT_HMAC_MD5_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_MD5_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_MD5_EXPANDED_KEY, outerState) - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_MD5_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_MD5_EXPANDED_KEY, magic) - 32usize]; +}; pub type SYMCRYPT_HMAC_MD5_EXPANDED_KEY = _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; pub type PSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_MD5_EXPANDED_KEY; pub type PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY = *const SYMCRYPT_HMAC_MD5_EXPANDED_KEY; @@ -1507,37 +913,19 @@ pub struct _SYMCRYPT_HMAC_MD5_STATE { pub pKey: PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_MD5_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_MD5_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_STATE>(), - 128usize, - "Size of _SYMCRYPT_HMAC_MD5_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_MD5_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 112usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 120usize, - "Offset of field: _SYMCRYPT_HMAC_MD5_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_MD5_STATE"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_MD5_STATE>() - 128usize]; + ["Alignment of _SYMCRYPT_HMAC_MD5_STATE"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_MD5_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_MD5_STATE::hash"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_MD5_STATE, hash) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_MD5_STATE::pKey"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_MD5_STATE, pKey) - 112usize]; + ["Offset of field: _SYMCRYPT_HMAC_MD5_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_MD5_STATE, magic) - 120usize]; +}; impl Default for _SYMCRYPT_HMAC_MD5_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1558,37 +946,19 @@ pub struct _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA1_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(), - 80usize, - "Size of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>() - 80usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY, outerState) - 32usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA1_EXPANDED_KEY, magic) - 64usize]; +}; pub type SYMCRYPT_HMAC_SHA1_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; pub type PSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; pub type PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA1_EXPANDED_KEY; @@ -1600,37 +970,19 @@ pub struct _SYMCRYPT_HMAC_SHA1_STATE { pub pKey: PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA1_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA1_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_STATE>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA1_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA1_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 136usize, - "Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA1_STATE"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA1_STATE>() - 144usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA1_STATE"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA1_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::hash"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA1_STATE, hash) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::pKey"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA1_STATE, pKey) - 128usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA1_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA1_STATE, magic) - 136usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA1_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1651,37 +1003,19 @@ pub struct _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA256_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA224_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>(), - 80usize, - "Size of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>() - 80usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY, outerState) - 32usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA224_EXPANDED_KEY, magic) - 64usize]; +}; pub type SYMCRYPT_HMAC_SHA224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA224_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] @@ -1691,37 +1025,19 @@ pub struct _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA256_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(), - 80usize, - "Size of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>() - 80usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY, outerState) - 32usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA256_EXPANDED_KEY, magic) - 64usize]; +}; pub type SYMCRYPT_HMAC_SHA256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; pub type PSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; pub type PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA256_EXPANDED_KEY; @@ -1733,37 +1049,19 @@ pub struct _SYMCRYPT_HMAC_SHA256_STATE { pub pKey: PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA256_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA256_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_STATE>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA256_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA256_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 136usize, - "Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA256_STATE"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA256_STATE>() - 144usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA256_STATE"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA256_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::hash"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA256_STATE, hash) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::pKey"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA256_STATE, pKey) - 128usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA256_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA256_STATE, magic) - 136usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA256_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1784,37 +1082,19 @@ pub struct _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>() - 144usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY, outerState) - 64usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA384_EXPANDED_KEY, magic) - 128usize]; +}; pub type SYMCRYPT_HMAC_SHA384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; pub type PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; pub type PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA384_EXPANDED_KEY; @@ -1826,37 +1106,19 @@ pub struct _SYMCRYPT_HMAC_SHA384_STATE { pub pKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA384_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA384_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), - 240usize, - "Size of _SYMCRYPT_HMAC_SHA384_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA384_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 232usize, - "Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA384_STATE"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA384_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA384_STATE"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA384_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::hash"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA384_STATE, hash) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::pKey"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA384_STATE, pKey) - 224usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA384_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA384_STATE, magic) - 232usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA384_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1877,37 +1139,19 @@ pub struct _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>() - 144usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY, outerState) - 64usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_EXPANDED_KEY, magic) - 128usize]; +}; pub type SYMCRYPT_HMAC_SHA512_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; pub type PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *mut _SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; pub type PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY = *const SYMCRYPT_HMAC_SHA512_EXPANDED_KEY; @@ -1919,37 +1163,19 @@ pub struct _SYMCRYPT_HMAC_SHA512_STATE { pub pKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_STATE> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), - 240usize, - "Size of _SYMCRYPT_HMAC_SHA512_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::hash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 224usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 232usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA512_STATE"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_STATE>() - 240usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA512_STATE"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::hash"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_STATE, hash) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::pKey"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_STATE, pKey) - 224usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_STATE, magic) - 232usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA512_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -1970,37 +1196,19 @@ pub struct _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>() - 144usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY, outerState) - 64usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY, magic) - 128usize]; +}; pub type SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_224_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] @@ -2010,37 +1218,19 @@ pub struct _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY { pub outerState: SYMCRYPT_SHA512_CHAINING_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>(), - 144usize, - "Size of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>() - 144usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY, innerState) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY, outerState) - 64usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY, magic) - 128usize]; +}; pub type SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA512_256_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] @@ -2052,42 +1242,21 @@ pub struct _SYMCRYPT_HMAC_EXPANDED_KEY { pub outerState: SYMCRYPT_HASH_STATE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pHash) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::pHash" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).innerState) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::innerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerState) as usize - ptr as usize }, - 256usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::outerState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 496usize, - "Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>() - 512usize]; + ["Alignment of _SYMCRYPT_HMAC_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::pHash"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_EXPANDED_KEY, pHash) - 0usize]; + ["Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::innerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_EXPANDED_KEY, innerState) - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::outerState"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_EXPANDED_KEY, outerState) - 256usize]; + ["Offset of field: _SYMCRYPT_HMAC_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_EXPANDED_KEY, magic) - 496usize]; +}; impl Default for _SYMCRYPT_HMAC_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2104,27 +1273,15 @@ pub type SYMCRYPT_HMAC_EXPANDED_KEY = _SYMCRYPT_HMAC_EXPANDED_KEY; pub struct _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY { pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY::generic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>() - 512usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY::generic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY, generic) - 0usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2141,27 +1298,15 @@ pub type SYMCRYPT_HMAC_SHA3_224_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_224_EXPANDED_ pub struct _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY { pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY::generic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>() - 512usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY::generic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY, generic) - 0usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2178,27 +1323,15 @@ pub type SYMCRYPT_HMAC_SHA3_256_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_256_EXPANDED_ pub struct _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY { pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY::generic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>() - 512usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY::generic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY, generic) - 0usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2215,27 +1348,15 @@ pub type SYMCRYPT_HMAC_SHA3_384_EXPANDED_KEY = _SYMCRYPT_HMAC_SHA3_384_EXPANDED_ pub struct _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY { pub generic: SYMCRYPT_HMAC_EXPANDED_KEY, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(), - 512usize, - "Size of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).generic) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY::generic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>() - 512usize]; + ["Alignment of _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY::generic"] + [::std::mem::offset_of!(_SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY, generic) - 0usize]; +}; impl Default for _SYMCRYPT_HMAC_SHA3_512_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2255,42 +1376,21 @@ pub struct _SYMCRYPT_AES_EXPANDED_KEY { pub lastDecRoundKey: *mut [[BYTE; 4usize]; 4usize], pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_AES_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_AES_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_AES_EXPANDED_KEY>(), - 496usize, - "Size of _SYMCRYPT_AES_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_AES_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_AES_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).RoundKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::RoundKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).lastEncRoundKey) as usize - ptr as usize }, - 464usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::lastEncRoundKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).lastDecRoundKey) as usize - ptr as usize }, - 472usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::lastDecRoundKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 480usize, - "Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_AES_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_AES_EXPANDED_KEY>() - 496usize]; + ["Alignment of _SYMCRYPT_AES_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_AES_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::RoundKey"] + [::std::mem::offset_of!(_SYMCRYPT_AES_EXPANDED_KEY, RoundKey) - 0usize]; + ["Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::lastEncRoundKey"] + [::std::mem::offset_of!(_SYMCRYPT_AES_EXPANDED_KEY, lastEncRoundKey) - 464usize]; + ["Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::lastDecRoundKey"] + [::std::mem::offset_of!(_SYMCRYPT_AES_EXPANDED_KEY, lastDecRoundKey) - 472usize]; + ["Offset of field: _SYMCRYPT_AES_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_AES_EXPANDED_KEY, magic) - 480usize]; +}; impl Default for _SYMCRYPT_AES_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2312,42 +1412,21 @@ pub struct _SYMCRYPT_AES_CMAC_EXPANDED_KEY { pub K2: [BYTE; 16usize], pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_AES_CMAC_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_AES_CMAC_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>(), - 544usize, - "Size of _SYMCRYPT_AES_CMAC_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_AES_CMAC_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).aesKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::aesKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).K1) as usize - ptr as usize }, - 496usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::K1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).K2) as usize - ptr as usize }, - 512usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::K2" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 528usize, - "Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_AES_CMAC_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>() - 544usize]; + ["Alignment of _SYMCRYPT_AES_CMAC_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_AES_CMAC_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::aesKey"] + [::std::mem::offset_of!(_SYMCRYPT_AES_CMAC_EXPANDED_KEY, aesKey) - 0usize]; + ["Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::K1"] + [::std::mem::offset_of!(_SYMCRYPT_AES_CMAC_EXPANDED_KEY, K1) - 496usize]; + ["Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::K2"] + [::std::mem::offset_of!(_SYMCRYPT_AES_CMAC_EXPANDED_KEY, K2) - 512usize]; + ["Offset of field: _SYMCRYPT_AES_CMAC_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_AES_CMAC_EXPANDED_KEY, magic) - 528usize]; +}; impl Default for _SYMCRYPT_AES_CMAC_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2360,6 +1439,36 @@ impl Default for _SYMCRYPT_AES_CMAC_EXPANDED_KEY { pub type SYMCRYPT_AES_CMAC_EXPANDED_KEY = _SYMCRYPT_AES_CMAC_EXPANDED_KEY; #[repr(C)] #[repr(align(16))] +#[derive(Debug, Copy, Clone)] +pub struct _SYMCRYPT_XTS_AES_EXPANDED_KEY { + pub key1: SYMCRYPT_AES_EXPANDED_KEY, + pub key2: SYMCRYPT_AES_EXPANDED_KEY, +} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_XTS_AES_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_XTS_AES_EXPANDED_KEY>() - 992usize]; + ["Alignment of _SYMCRYPT_XTS_AES_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_XTS_AES_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_XTS_AES_EXPANDED_KEY::key1"] + [::std::mem::offset_of!(_SYMCRYPT_XTS_AES_EXPANDED_KEY, key1) - 0usize]; + ["Offset of field: _SYMCRYPT_XTS_AES_EXPANDED_KEY::key2"] + [::std::mem::offset_of!(_SYMCRYPT_XTS_AES_EXPANDED_KEY, key2) - 496usize]; +}; +impl Default for _SYMCRYPT_XTS_AES_EXPANDED_KEY { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type SYMCRYPT_XTS_AES_EXPANDED_KEY = _SYMCRYPT_XTS_AES_EXPANDED_KEY; +pub type PSYMCRYPT_XTS_AES_EXPANDED_KEY = *mut _SYMCRYPT_XTS_AES_EXPANDED_KEY; +pub type PCSYMCRYPT_XTS_AES_EXPANDED_KEY = *const SYMCRYPT_XTS_AES_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] #[derive(Copy, Clone)] pub union _SYMCRYPT_MAC_EXPANDED_KEY { pub md5Key: SYMCRYPT_HMAC_MD5_EXPANDED_KEY, @@ -2378,97 +1487,43 @@ pub union _SYMCRYPT_MAC_EXPANDED_KEY { pub kmac128Key: SYMCRYPT_KMAC128_EXPANDED_KEY, pub kmac256Key: SYMCRYPT_KMAC256_EXPANDED_KEY, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MAC_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MAC_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MAC_EXPANDED_KEY>(), - 544usize, - "Size of _SYMCRYPT_MAC_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MAC_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_MAC_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).md5Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::md5Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha1Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha1Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha224Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha224Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha256Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha384Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha384Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_224Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_224Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha512_256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_256Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_224Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_224Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_256Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_384Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_384Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sha3_512Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_512Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).aescmacKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::aescmacKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).kmac128Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac128Key" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).kmac256Key) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac256Key" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MAC_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_MAC_EXPANDED_KEY>() - 544usize]; + ["Alignment of _SYMCRYPT_MAC_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_MAC_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::md5Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, md5Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha1Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha1Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha224Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha224Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha256Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha256Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha384Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha384Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha512Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_224Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha512_224Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha512_256Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha512_256Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_224Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha3_224Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_256Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha3_256Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_384Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha3_384Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::sha3_512Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, sha3_512Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::aescmacKey"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, aescmacKey) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac128Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, kmac128Key) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC_EXPANDED_KEY::kmac256Key"] + [::std::mem::offset_of!(_SYMCRYPT_MAC_EXPANDED_KEY, kmac256Key) - 0usize]; +}; impl Default for _SYMCRYPT_MAC_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2501,66 +1556,29 @@ pub struct _SYMCRYPT_MAC { pub ppHashAlgorithm: *const PCSYMCRYPT_HASH, pub outerChainingStateOffset: UINT32, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MAC() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MAC> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MAC>(), - 72usize, - "Size of _SYMCRYPT_MAC" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MAC>(), - 8usize, - "Alignment of _SYMCRYPT_MAC" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandKeyFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MAC::expandKeyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).initFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MAC::initFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).appendFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MAC::appendFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MAC::resultFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandedKeySize) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MAC::expandedKeySize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).stateSize) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_MAC::stateSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).resultSize) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_MAC::resultSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ppHashAlgorithm) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_MAC::ppHashAlgorithm" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).outerChainingStateOffset) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_MAC::outerChainingStateOffset" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MAC"][::std::mem::size_of::<_SYMCRYPT_MAC>() - 72usize]; + ["Alignment of _SYMCRYPT_MAC"][::std::mem::align_of::<_SYMCRYPT_MAC>() - 8usize]; + ["Offset of field: _SYMCRYPT_MAC::expandKeyFunc"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, expandKeyFunc) - 0usize]; + ["Offset of field: _SYMCRYPT_MAC::initFunc"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, initFunc) - 8usize]; + ["Offset of field: _SYMCRYPT_MAC::appendFunc"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, appendFunc) - 16usize]; + ["Offset of field: _SYMCRYPT_MAC::resultFunc"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, resultFunc) - 24usize]; + ["Offset of field: _SYMCRYPT_MAC::expandedKeySize"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, expandedKeySize) - 32usize]; + ["Offset of field: _SYMCRYPT_MAC::stateSize"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, stateSize) - 40usize]; + ["Offset of field: _SYMCRYPT_MAC::resultSize"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, resultSize) - 48usize]; + ["Offset of field: _SYMCRYPT_MAC::ppHashAlgorithm"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, ppHashAlgorithm) - 56usize]; + ["Offset of field: _SYMCRYPT_MAC::outerChainingStateOffset"] + [::std::mem::offset_of!(_SYMCRYPT_MAC, outerChainingStateOffset) - 64usize]; +}; impl Default for _SYMCRYPT_MAC { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2578,27 +1596,15 @@ pub type PCSYMCRYPT_MAC = *const SYMCRYPT_MAC; pub union _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS { pub aes: SYMCRYPT_AES_EXPANDED_KEY, } -#[test] -fn bindgen_test_layout__SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>(), - 496usize, - "Size of _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>(), - 16usize, - "Alignment of _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).aes) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS::aes" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS"] + [::std::mem::size_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>() - 496usize]; + ["Alignment of _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS"] + [::std::mem::align_of::<_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS>() - 16usize]; + ["Offset of field: _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS::aes"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS, aes) - 0usize]; +}; impl Default for _SYMCRYPT_GCM_SUPPORTED_BLOCKCIPHER_KEYS { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2617,37 +1623,18 @@ pub union _SYMCRYPT_GF128_ELEMENT { pub m128i: __m128i, pub ul: [UINT32; 4usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_GF128_ELEMENT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GF128_ELEMENT> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GF128_ELEMENT>(), - 16usize, - "Size of _SYMCRYPT_GF128_ELEMENT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GF128_ELEMENT>(), - 16usize, - "Alignment of _SYMCRYPT_GF128_ELEMENT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ull) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GF128_ELEMENT::ull" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).m128i) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GF128_ELEMENT::m128i" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ul) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GF128_ELEMENT::ul" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_GF128_ELEMENT"][::std::mem::size_of::<_SYMCRYPT_GF128_ELEMENT>() - 16usize]; + ["Alignment of _SYMCRYPT_GF128_ELEMENT"] + [::std::mem::align_of::<_SYMCRYPT_GF128_ELEMENT>() - 16usize]; + ["Offset of field: _SYMCRYPT_GF128_ELEMENT::ull"] + [::std::mem::offset_of!(_SYMCRYPT_GF128_ELEMENT, ull) - 0usize]; + ["Offset of field: _SYMCRYPT_GF128_ELEMENT::m128i"] + [::std::mem::offset_of!(_SYMCRYPT_GF128_ELEMENT, m128i) - 0usize]; + ["Offset of field: _SYMCRYPT_GF128_ELEMENT::ul"] + [::std::mem::offset_of!(_SYMCRYPT_GF128_ELEMENT, ul) - 0usize]; +}; impl Default for _SYMCRYPT_GF128_ELEMENT { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2664,27 +1651,15 @@ pub type SYMCRYPT_GF128_ELEMENT = _SYMCRYPT_GF128_ELEMENT; pub struct _SYMCRYPT_GHASH_EXPANDED_KEY { pub table: [SYMCRYPT_GF128_ELEMENT; 128usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_GHASH_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GHASH_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>(), - 2048usize, - "Size of _SYMCRYPT_GHASH_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_GHASH_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).table) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GHASH_EXPANDED_KEY::table" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_GHASH_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>() - 2048usize]; + ["Alignment of _SYMCRYPT_GHASH_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_GHASH_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_GHASH_EXPANDED_KEY::table"] + [::std::mem::offset_of!(_SYMCRYPT_GHASH_EXPANDED_KEY, table) - 0usize]; +}; impl Default for _SYMCRYPT_GHASH_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2707,52 +1682,25 @@ pub struct _SYMCRYPT_GCM_EXPANDED_KEY { pub abKey: [BYTE; 32usize], pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_GCM_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GCM_EXPANDED_KEY>(), - 2608usize, - "Size of _SYMCRYPT_GCM_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GCM_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_GCM_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ghashKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::ghashKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pBlockCipher) as usize - ptr as usize }, - 2048usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::pBlockCipher" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).blockcipherKey) as usize - ptr as usize }, - 2064usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::blockcipherKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbKey) as usize - ptr as usize }, - 2560usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::cbKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).abKey) as usize - ptr as usize }, - 2568usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::abKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 2600usize, - "Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_GCM_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_GCM_EXPANDED_KEY>() - 2608usize]; + ["Alignment of _SYMCRYPT_GCM_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_GCM_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::ghashKey"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_EXPANDED_KEY, ghashKey) - 0usize]; + ["Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::pBlockCipher"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_EXPANDED_KEY, pBlockCipher) - 2048usize]; + ["Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::blockcipherKey"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_EXPANDED_KEY, blockcipherKey) - 2064usize]; + ["Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::cbKey"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_EXPANDED_KEY, cbKey) - 2560usize]; + ["Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::abKey"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_EXPANDED_KEY, abKey) - 2568usize]; + ["Offset of field: _SYMCRYPT_GCM_EXPANDED_KEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_EXPANDED_KEY, magic) - 2600usize]; +}; impl Default for _SYMCRYPT_GCM_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2779,66 +1727,29 @@ pub struct _SYMCRYPT_GCM_STATE { pub keystreamBlock: [BYTE; 16usize], pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_GCM_STATE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_GCM_STATE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_GCM_STATE>(), - 112usize, - "Size of _SYMCRYPT_GCM_STATE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_GCM_STATE>(), - 16usize, - "Alignment of _SYMCRYPT_GCM_STATE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_GCM_STATE::pKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbData) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_GCM_STATE::cbData" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbAuthData) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_GCM_STATE::cbAuthData" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).bytesInMacBlock) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_GCM_STATE::bytesInMacBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ghashState) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_GCM_STATE::ghashState" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).counterBlock) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_GCM_STATE::counterBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macBlock) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_GCM_STATE::macBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).keystreamBlock) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_GCM_STATE::keystreamBlock" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_GCM_STATE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_GCM_STATE"][::std::mem::size_of::<_SYMCRYPT_GCM_STATE>() - 112usize]; + ["Alignment of _SYMCRYPT_GCM_STATE"][::std::mem::align_of::<_SYMCRYPT_GCM_STATE>() - 16usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::pKey"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, pKey) - 0usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::cbData"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, cbData) - 8usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::cbAuthData"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, cbAuthData) - 16usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::bytesInMacBlock"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, bytesInMacBlock) - 24usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::ghashState"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, ghashState) - 32usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::counterBlock"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, counterBlock) - 48usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::macBlock"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, macBlock) - 64usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::keystreamBlock"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, keystreamBlock) - 80usize]; + ["Offset of field: _SYMCRYPT_GCM_STATE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_GCM_STATE, magic) - 96usize]; +}; impl Default for _SYMCRYPT_GCM_STATE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -2896,120 +1807,86 @@ pub struct _SYMCRYPT_BLOCKCIPHER { pub blockSize: SIZE_T, pub expandedKeySize: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_BLOCKCIPHER() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_BLOCKCIPHER> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_BLOCKCIPHER>(), - 104usize, - "Size of _SYMCRYPT_BLOCKCIPHER" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_BLOCKCIPHER>(), - 8usize, - "Alignment of _SYMCRYPT_BLOCKCIPHER" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandKeyFunc) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::expandKeyFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).encryptFunc) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::encryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).decryptFunc) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::decryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ecbEncryptFunc) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::ecbEncryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ecbDecryptFunc) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::ecbDecryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbcEncryptFunc) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcEncryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbcDecryptFunc) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcDecryptFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbcMacFunc) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcMacFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ctrMsb64Func) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::ctrMsb64Func" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).gcmEncryptPartFunc) as usize - ptr as usize }, - 72usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::gcmEncryptPartFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).gcmDecryptPartFunc) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::gcmDecryptPartFunc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).blockSize) as usize - ptr as usize }, - 88usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::blockSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).expandedKeySize) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_BLOCKCIPHER::expandedKeySize" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_BLOCKCIPHER"][::std::mem::size_of::<_SYMCRYPT_BLOCKCIPHER>() - 104usize]; + ["Alignment of _SYMCRYPT_BLOCKCIPHER"] + [::std::mem::align_of::<_SYMCRYPT_BLOCKCIPHER>() - 8usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::expandKeyFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, expandKeyFunc) - 0usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::encryptFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, encryptFunc) - 8usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::decryptFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, decryptFunc) - 16usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::ecbEncryptFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, ecbEncryptFunc) - 24usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::ecbDecryptFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, ecbDecryptFunc) - 32usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcEncryptFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, cbcEncryptFunc) - 40usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcDecryptFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, cbcDecryptFunc) - 48usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::cbcMacFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, cbcMacFunc) - 56usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::ctrMsb64Func"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, ctrMsb64Func) - 64usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::gcmEncryptPartFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, gcmEncryptPartFunc) - 72usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::gcmDecryptPartFunc"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, gcmDecryptPartFunc) - 80usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::blockSize"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, blockSize) - 88usize]; + ["Offset of field: _SYMCRYPT_BLOCKCIPHER::expandedKeySize"] + [::std::mem::offset_of!(_SYMCRYPT_BLOCKCIPHER, expandedKeySize) - 96usize]; +}; #[repr(C)] #[repr(align(16))] #[derive(Copy, Clone)] -pub struct _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY { +pub struct _SYMCRYPT_SP800_108_EXPANDED_KEY { pub macKey: SYMCRYPT_MAC_EXPANDED_KEY, pub macAlg: PCSYMCRYPT_MAC, } -#[test] -fn bindgen_test_layout__SYMCRYPT_TLSPRF1_2_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY>(), - 560usize, - "Size of _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY::macKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macAlg) as usize - ptr as usize }, - 544usize, - "Offset of field: _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY::macAlg" - ); +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_SP800_108_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_SP800_108_EXPANDED_KEY>() - 560usize]; + ["Alignment of _SYMCRYPT_SP800_108_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_SP800_108_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_SP800_108_EXPANDED_KEY::macKey"] + [::std::mem::offset_of!(_SYMCRYPT_SP800_108_EXPANDED_KEY, macKey) - 0usize]; + ["Offset of field: _SYMCRYPT_SP800_108_EXPANDED_KEY::macAlg"] + [::std::mem::offset_of!(_SYMCRYPT_SP800_108_EXPANDED_KEY, macAlg) - 544usize]; +}; +impl Default for _SYMCRYPT_SP800_108_EXPANDED_KEY { + fn default() -> Self { + let mut s = ::std::mem::MaybeUninit::::uninit(); + unsafe { + ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1); + s.assume_init() + } + } +} +pub type SYMCRYPT_SP800_108_EXPANDED_KEY = _SYMCRYPT_SP800_108_EXPANDED_KEY; +pub type PSYMCRYPT_SP800_108_EXPANDED_KEY = *mut _SYMCRYPT_SP800_108_EXPANDED_KEY; +pub type PCSYMCRYPT_SP800_108_EXPANDED_KEY = *const SYMCRYPT_SP800_108_EXPANDED_KEY; +#[repr(C)] +#[repr(align(16))] +#[derive(Copy, Clone)] +pub struct _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY { + pub macKey: SYMCRYPT_MAC_EXPANDED_KEY, + pub macAlg: PCSYMCRYPT_MAC, } +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY>() - 560usize]; + ["Alignment of _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY::macKey"] + [::std::mem::offset_of!(_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY, macKey) - 0usize]; + ["Offset of field: _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY::macAlg"] + [::std::mem::offset_of!(_SYMCRYPT_TLSPRF1_2_EXPANDED_KEY, macAlg) - 544usize]; +}; impl Default for _SYMCRYPT_TLSPRF1_2_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3029,32 +1906,17 @@ pub struct _SYMCRYPT_HKDF_EXPANDED_KEY { pub macKey: SYMCRYPT_MAC_EXPANDED_KEY, pub macAlg: PCSYMCRYPT_MAC, } -#[test] -fn bindgen_test_layout__SYMCRYPT_HKDF_EXPANDED_KEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_HKDF_EXPANDED_KEY> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_HKDF_EXPANDED_KEY>(), - 560usize, - "Size of _SYMCRYPT_HKDF_EXPANDED_KEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_HKDF_EXPANDED_KEY>(), - 16usize, - "Alignment of _SYMCRYPT_HKDF_EXPANDED_KEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macKey) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_HKDF_EXPANDED_KEY::macKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).macAlg) as usize - ptr as usize }, - 544usize, - "Offset of field: _SYMCRYPT_HKDF_EXPANDED_KEY::macAlg" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_HKDF_EXPANDED_KEY"] + [::std::mem::size_of::<_SYMCRYPT_HKDF_EXPANDED_KEY>() - 560usize]; + ["Alignment of _SYMCRYPT_HKDF_EXPANDED_KEY"] + [::std::mem::align_of::<_SYMCRYPT_HKDF_EXPANDED_KEY>() - 16usize]; + ["Offset of field: _SYMCRYPT_HKDF_EXPANDED_KEY::macKey"] + [::std::mem::offset_of!(_SYMCRYPT_HKDF_EXPANDED_KEY, macKey) - 0usize]; + ["Offset of field: _SYMCRYPT_HKDF_EXPANDED_KEY::macAlg"] + [::std::mem::offset_of!(_SYMCRYPT_HKDF_EXPANDED_KEY, macAlg) - 544usize]; +}; impl Default for _SYMCRYPT_HKDF_EXPANDED_KEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3097,48 +1959,24 @@ pub union _SYMCRYPT_INT__bindgen_ty_1 { pub struct _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1 { pub uint32: [UINT32; 1usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>(), - 4usize, - "Size of _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>(), - 4usize, - "Alignment of _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).uint32) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1::uint32" - ); -} -#[test] -fn bindgen_test_layout__SYMCRYPT_INT__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1>(), - 4usize, - "Size of _SYMCRYPT_INT__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1>(), - 4usize, - "Alignment of _SYMCRYPT_INT__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fdef) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_INT__bindgen_ty_1::fdef" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>() - 4usize]; + ["Alignment of _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1>() - 4usize]; + ["Offset of field: _SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1::uint32"] + [::std::mem::offset_of!(_SYMCRYPT_INT__bindgen_ty_1__bindgen_ty_1, uint32) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_INT__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_INT__bindgen_ty_1>() - 4usize]; + ["Alignment of _SYMCRYPT_INT__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_INT__bindgen_ty_1>() - 4usize]; + ["Offset of field: _SYMCRYPT_INT__bindgen_ty_1::fdef"] + [::std::mem::offset_of!(_SYMCRYPT_INT__bindgen_ty_1, fdef) - 0usize]; +}; impl Default for _SYMCRYPT_INT__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3148,46 +1986,20 @@ impl Default for _SYMCRYPT_INT__bindgen_ty_1 { } } } -#[test] -fn bindgen_test_layout__SYMCRYPT_INT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_INT> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_INT>(), - 64usize, - "Size of _SYMCRYPT_INT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_INT>(), - 32usize, - "Alignment of _SYMCRYPT_INT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_INT::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_INT::nDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_INT::cbSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_INT::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).ti) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_INT::ti" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_INT"][::std::mem::size_of::<_SYMCRYPT_INT>() - 64usize]; + ["Alignment of _SYMCRYPT_INT"][::std::mem::align_of::<_SYMCRYPT_INT>() - 32usize]; + ["Offset of field: _SYMCRYPT_INT::type_"] + [::std::mem::offset_of!(_SYMCRYPT_INT, type_) - 0usize]; + ["Offset of field: _SYMCRYPT_INT::nDigits"] + [::std::mem::offset_of!(_SYMCRYPT_INT, nDigits) - 4usize]; + ["Offset of field: _SYMCRYPT_INT::cbSize"] + [::std::mem::offset_of!(_SYMCRYPT_INT, cbSize) - 8usize]; + ["Offset of field: _SYMCRYPT_INT::magic"] + [::std::mem::offset_of!(_SYMCRYPT_INT, magic) - 16usize]; + ["Offset of field: _SYMCRYPT_INT::ti"][::std::mem::offset_of!(_SYMCRYPT_INT, ti) - 32usize]; +}; impl Default for _SYMCRYPT_INT { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3219,48 +2031,24 @@ pub union _SYMCRYPT_DIVISOR__bindgen_ty_1 { pub struct _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1 { pub W: UINT64, } -#[test] -fn bindgen_test_layout__SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).W) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1::W" - ); -} -#[test] -fn bindgen_test_layout__SYMCRYPT_DIVISOR__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_DIVISOR__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_DIVISOR__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fdef) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_DIVISOR__bindgen_ty_1::fdef" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>() - 8usize]; + ["Alignment of _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1>() - 8usize]; + ["Offset of field: _SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1::W"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR__bindgen_ty_1__bindgen_ty_1, W) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_DIVISOR__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>() - 8usize]; + ["Alignment of _SYMCRYPT_DIVISOR__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_DIVISOR__bindgen_ty_1>() - 8usize]; + ["Offset of field: _SYMCRYPT_DIVISOR__bindgen_ty_1::fdef"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR__bindgen_ty_1, fdef) - 0usize]; +}; impl Default for _SYMCRYPT_DIVISOR__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3270,56 +2058,25 @@ impl Default for _SYMCRYPT_DIVISOR__bindgen_ty_1 { } } } -#[test] -fn bindgen_test_layout__SYMCRYPT_DIVISOR() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_DIVISOR> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_DIVISOR>(), - 96usize, - "Size of _SYMCRYPT_DIVISOR" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_DIVISOR>(), - 32usize, - "Alignment of _SYMCRYPT_DIVISOR" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_DIVISOR::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_DIVISOR::nDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_DIVISOR::cbSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBits) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_DIVISOR::nBits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_DIVISOR::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).td) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_DIVISOR::td" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).Int) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_DIVISOR::Int" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_DIVISOR"][::std::mem::size_of::<_SYMCRYPT_DIVISOR>() - 96usize]; + ["Alignment of _SYMCRYPT_DIVISOR"][::std::mem::align_of::<_SYMCRYPT_DIVISOR>() - 32usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::type_"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, type_) - 0usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::nDigits"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, nDigits) - 4usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::cbSize"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, cbSize) - 8usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::nBits"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, nBits) - 12usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::magic"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, magic) - 16usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::td"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, td) - 24usize]; + ["Offset of field: _SYMCRYPT_DIVISOR::Int"] + [::std::mem::offset_of!(_SYMCRYPT_DIVISOR, Int) - 32usize]; +}; impl Default for _SYMCRYPT_DIVISOR { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3355,27 +2112,15 @@ pub union _SYMCRYPT_MODULUS__bindgen_ty_1 { pub struct _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1 { pub Rsqr: PCUINT32, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).Rsqr) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1::Rsqr" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>() - 8usize]; + ["Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1>() - 8usize]; + ["Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1::Rsqr"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1, Rsqr) - 0usize]; +}; impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3390,53 +2135,26 @@ impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_1 { pub struct _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2 { pub k: UINT32, } -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>(), - 4usize, - "Size of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>(), - 4usize, - "Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).k) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2::k" - ); -} -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>(), - 8usize, - "Size of _SYMCRYPT_MODULUS__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).montgomery) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1::montgomery" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pseudoMersenne) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1::pseudoMersenne" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2"] + [::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>() - 4usize]; + ["Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2"] + [::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2>() - 4usize]; + ["Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2::k"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS__bindgen_ty_1__bindgen_ty_2, k) - 0usize]; +}; +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MODULUS__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>() - 8usize]; + ["Alignment of _SYMCRYPT_MODULUS__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_MODULUS__bindgen_ty_1>() - 8usize]; + ["Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1::montgomery"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS__bindgen_ty_1, montgomery) - 0usize]; + ["Offset of field: _SYMCRYPT_MODULUS__bindgen_ty_1::pseudoMersenne"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS__bindgen_ty_1, pseudoMersenne) - 0usize]; +}; impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3446,66 +2164,29 @@ impl Default for _SYMCRYPT_MODULUS__bindgen_ty_1 { } } } -#[test] -fn bindgen_test_layout__SYMCRYPT_MODULUS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODULUS> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODULUS>(), - 160usize, - "Size of _SYMCRYPT_MODULUS" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODULUS>(), - 32usize, - "Alignment of _SYMCRYPT_MODULUS" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODULUS::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigits) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_MODULUS::nDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSize) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_MODULUS::cbSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_MODULUS::flags" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbModElement) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_MODULUS::cbModElement" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).inv64) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_MODULUS::inv64" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_MODULUS::magic" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).tm) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_MODULUS::tm" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).Divisor) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_MODULUS::Divisor" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MODULUS"][::std::mem::size_of::<_SYMCRYPT_MODULUS>() - 160usize]; + ["Alignment of _SYMCRYPT_MODULUS"][::std::mem::align_of::<_SYMCRYPT_MODULUS>() - 32usize]; + ["Offset of field: _SYMCRYPT_MODULUS::type_"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, type_) - 0usize]; + ["Offset of field: _SYMCRYPT_MODULUS::nDigits"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, nDigits) - 4usize]; + ["Offset of field: _SYMCRYPT_MODULUS::cbSize"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, cbSize) - 8usize]; + ["Offset of field: _SYMCRYPT_MODULUS::flags"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, flags) - 12usize]; + ["Offset of field: _SYMCRYPT_MODULUS::cbModElement"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, cbModElement) - 16usize]; + ["Offset of field: _SYMCRYPT_MODULUS::inv64"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, inv64) - 24usize]; + ["Offset of field: _SYMCRYPT_MODULUS::magic"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, magic) - 32usize]; + ["Offset of field: _SYMCRYPT_MODULUS::tm"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, tm) - 40usize]; + ["Offset of field: _SYMCRYPT_MODULUS::Divisor"] + [::std::mem::offset_of!(_SYMCRYPT_MODULUS, Divisor) - 64usize]; +}; impl Default for _SYMCRYPT_MODULUS { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3526,27 +2207,15 @@ pub struct _SYMCRYPT_MODELEMENT { pub union _SYMCRYPT_MODELEMENT__bindgen_ty_1 { pub uint32: [UINT32; 1usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_MODELEMENT__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODELEMENT__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>(), - 4usize, - "Size of _SYMCRYPT_MODELEMENT__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>(), - 4usize, - "Alignment of _SYMCRYPT_MODELEMENT__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).uint32) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODELEMENT__bindgen_ty_1::uint32" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MODELEMENT__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>() - 4usize]; + ["Alignment of _SYMCRYPT_MODELEMENT__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_MODELEMENT__bindgen_ty_1>() - 4usize]; + ["Offset of field: _SYMCRYPT_MODELEMENT__bindgen_ty_1::uint32"] + [::std::mem::offset_of!(_SYMCRYPT_MODELEMENT__bindgen_ty_1, uint32) - 0usize]; +}; impl Default for _SYMCRYPT_MODELEMENT__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3556,26 +2225,13 @@ impl Default for _SYMCRYPT_MODELEMENT__bindgen_ty_1 { } } } -#[test] -fn bindgen_test_layout__SYMCRYPT_MODELEMENT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_MODELEMENT> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_MODELEMENT>(), - 32usize, - "Size of _SYMCRYPT_MODELEMENT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_MODELEMENT>(), - 32usize, - "Alignment of _SYMCRYPT_MODELEMENT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_MODELEMENT::d" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_MODELEMENT"][::std::mem::size_of::<_SYMCRYPT_MODELEMENT>() - 32usize]; + ["Alignment of _SYMCRYPT_MODELEMENT"][::std::mem::align_of::<_SYMCRYPT_MODELEMENT>() - 32usize]; + ["Offset of field: _SYMCRYPT_MODELEMENT::d"] + [::std::mem::offset_of!(_SYMCRYPT_MODELEMENT, d) - 0usize]; +}; impl Default for _SYMCRYPT_MODELEMENT { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3612,131 +2268,55 @@ pub struct _SYMCRYPT_RSAKEY { pub piCrtPrivExps: [PSYMCRYPT_INT; 2usize], pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_RSAKEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_RSAKEY> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_RSAKEY>(), - 192usize, - "Size of _SYMCRYPT_RSAKEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_RSAKEY>(), - 32usize, - "Alignment of _SYMCRYPT_RSAKEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fAlgorithmInfo) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_RSAKEY::fAlgorithmInfo" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbTotalSize) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_RSAKEY::cbTotalSize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hasPrivateKey) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_RSAKEY::hasPrivateKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nSetBitsOfModulus) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_RSAKEY::nSetBitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBitsOfModulus) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_RSAKEY::nBitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigitsOfModulus) as usize - ptr as usize }, - 20usize, - "Offset of field: _SYMCRYPT_RSAKEY::nDigitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPubExp) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_RSAKEY::nPubExp" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPrimes) as usize - ptr as usize }, - 28usize, - "Offset of field: _SYMCRYPT_RSAKEY::nPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBitsOfPrimes) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_RSAKEY::nBitsOfPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nDigitsOfPrimes) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_RSAKEY::nDigitsOfPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nMaxDigitsOfPrimes) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_RSAKEY::nMaxDigitsOfPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).au64PubExp) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_RSAKEY::au64PubExp" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbPrimes) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbCrtInverses) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbCrtInverses" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbPrivExps) as usize - ptr as usize }, - 96usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pbCrtPrivExps) as usize - ptr as usize }, - 104usize, - "Offset of field: _SYMCRYPT_RSAKEY::pbCrtPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pmModulus) as usize - ptr as usize }, - 120usize, - "Offset of field: _SYMCRYPT_RSAKEY::pmModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pmPrimes) as usize - ptr as usize }, - 128usize, - "Offset of field: _SYMCRYPT_RSAKEY::pmPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).peCrtInverses) as usize - ptr as usize }, - 144usize, - "Offset of field: _SYMCRYPT_RSAKEY::peCrtInverses" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).piPrivExps) as usize - ptr as usize }, - 160usize, - "Offset of field: _SYMCRYPT_RSAKEY::piPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).piCrtPrivExps) as usize - ptr as usize }, - 168usize, - "Offset of field: _SYMCRYPT_RSAKEY::piCrtPrivExps" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 184usize, - "Offset of field: _SYMCRYPT_RSAKEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_RSAKEY"][::std::mem::size_of::<_SYMCRYPT_RSAKEY>() - 192usize]; + ["Alignment of _SYMCRYPT_RSAKEY"][::std::mem::align_of::<_SYMCRYPT_RSAKEY>() - 32usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::fAlgorithmInfo"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, fAlgorithmInfo) - 0usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::cbTotalSize"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, cbTotalSize) - 4usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::hasPrivateKey"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, hasPrivateKey) - 8usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nSetBitsOfModulus"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nSetBitsOfModulus) - 12usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nBitsOfModulus"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nBitsOfModulus) - 16usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nDigitsOfModulus"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nDigitsOfModulus) - 20usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nPubExp"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nPubExp) - 24usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nPrimes) - 28usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nBitsOfPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nBitsOfPrimes) - 32usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nDigitsOfPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nDigitsOfPrimes) - 40usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::nMaxDigitsOfPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, nMaxDigitsOfPrimes) - 48usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::au64PubExp"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, au64PubExp) - 56usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::pbPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, pbPrimes) - 64usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::pbCrtInverses"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, pbCrtInverses) - 80usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::pbPrivExps"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, pbPrivExps) - 96usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::pbCrtPrivExps"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, pbCrtPrivExps) - 104usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::pmModulus"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, pmModulus) - 120usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::pmPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, pmPrimes) - 128usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::peCrtInverses"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, peCrtInverses) - 144usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::piPrivExps"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, piPrivExps) - 160usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::piCrtPrivExps"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, piCrtPrivExps) - 168usize]; + ["Offset of field: _SYMCRYPT_RSAKEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_RSAKEY, magic) - 184usize]; +}; impl Default for _SYMCRYPT_RSAKEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3773,42 +2353,21 @@ pub struct _SYMCRYPT_ECURVE_INFO_PRECOMP { pub nRecodedDigits: UINT32, pub poPrecompPoints: [PSYMCRYPT_ECPOINT; 64usize], } -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE_INFO_PRECOMP() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE_INFO_PRECOMP> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(), - 528usize, - "Size of _SYMCRYPT_ECURVE_INFO_PRECOMP" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>(), - 8usize, - "Alignment of _SYMCRYPT_ECURVE_INFO_PRECOMP" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).window) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::window" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPrecompPoints) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nPrecompPoints" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nRecodedDigits) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nRecodedDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).poPrecompPoints) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::poPrecompPoints" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_ECURVE_INFO_PRECOMP"] + [::std::mem::size_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>() - 528usize]; + ["Alignment of _SYMCRYPT_ECURVE_INFO_PRECOMP"] + [::std::mem::align_of::<_SYMCRYPT_ECURVE_INFO_PRECOMP>() - 8usize]; + ["Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::window"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_INFO_PRECOMP, window) - 0usize]; + ["Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nPrecompPoints"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_INFO_PRECOMP, nPrecompPoints) - 4usize]; + ["Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::nRecodedDigits"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_INFO_PRECOMP, nRecodedDigits) - 8usize]; + ["Offset of field: _SYMCRYPT_ECURVE_INFO_PRECOMP::poPrecompPoints"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_INFO_PRECOMP, poPrecompPoints) - 16usize]; +}; impl Default for _SYMCRYPT_ECURVE_INFO_PRECOMP { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3868,27 +2427,15 @@ pub struct _SYMCRYPT_ECURVE { pub union _SYMCRYPT_ECURVE__bindgen_ty_1 { pub sw: SYMCRYPT_ECURVE_INFO_PRECOMP, } -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE__bindgen_ty_1() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE__bindgen_ty_1> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(), - 528usize, - "Size of _SYMCRYPT_ECURVE__bindgen_ty_1" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>(), - 8usize, - "Alignment of _SYMCRYPT_ECURVE__bindgen_ty_1" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).sw) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE__bindgen_ty_1::sw" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_ECURVE__bindgen_ty_1"] + [::std::mem::size_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>() - 528usize]; + ["Alignment of _SYMCRYPT_ECURVE__bindgen_ty_1"] + [::std::mem::align_of::<_SYMCRYPT_ECURVE__bindgen_ty_1>() - 8usize]; + ["Offset of field: _SYMCRYPT_ECURVE__bindgen_ty_1::sw"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE__bindgen_ty_1, sw) - 0usize]; +}; impl Default for _SYMCRYPT_ECURVE__bindgen_ty_1 { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -3898,166 +2445,69 @@ impl Default for _SYMCRYPT_ECURVE__bindgen_ty_1 { } } } -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE>(), - 672usize, - "Size of _SYMCRYPT_ECURVE" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE>(), - 32usize, - "Alignment of _SYMCRYPT_ECURVE" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE::version" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECURVE::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).eCoordinates) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECURVE::eCoordinates" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FModBitsize) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_ECURVE::FModBitsize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FModDigits) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECURVE::FModDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FModBytesize) as usize - ptr as usize }, - 20usize, - "Offset of field: _SYMCRYPT_ECURVE::FModBytesize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrdBitsize) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrdBitsize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrdDigits) as usize - ptr as usize }, - 28usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrdDigits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrdBytesize) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrdBytesize" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbModElement) as usize - ptr as usize }, - 36usize, - "Offset of field: _SYMCRYPT_ECURVE::cbModElement" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbAlloc) as usize - ptr as usize }, - 40usize, - "Offset of field: _SYMCRYPT_ECURVE::cbAlloc" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchCommon) as usize - ptr as usize }, - 44usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchCommon" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchScalar) as usize - ptr as usize }, - 48usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchScalar" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchScalarMulti) as usize - ptr as usize }, - 52usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchScalarMulti" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchGetSetValue) as usize - ptr as usize }, - 56usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchGetSetValue" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbScratchEckey) as usize - ptr as usize }, - 60usize, - "Offset of field: _SYMCRYPT_ECURVE::cbScratchEckey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).coFactorPower) as usize - ptr as usize }, - 64usize, - "Offset of field: _SYMCRYPT_ECURVE::coFactorPower" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).PrivateKeyDefaultFormat) as usize - ptr as usize }, - 68usize, - "Offset of field: _SYMCRYPT_ECURVE::PrivateKeyDefaultFormat" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionNumOfBits) as usize - ptr as usize }, - 72usize, - "Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionNumOfBits" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionPosition) as usize - ptr as usize }, - 76usize, - "Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionPosition" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).HighBitRestrictionValue) as usize - ptr as usize }, - 80usize, - "Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionValue" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).info) as usize - ptr as usize }, - 88usize, - "Offset of field: _SYMCRYPT_ECURVE::info" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).FMod) as usize - ptr as usize }, - 616usize, - "Offset of field: _SYMCRYPT_ECURVE::FMod" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).GOrd) as usize - ptr as usize }, - 624usize, - "Offset of field: _SYMCRYPT_ECURVE::GOrd" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).A) as usize - ptr as usize }, - 632usize, - "Offset of field: _SYMCRYPT_ECURVE::A" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).B) as usize - ptr as usize }, - 640usize, - "Offset of field: _SYMCRYPT_ECURVE::B" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).G) as usize - ptr as usize }, - 648usize, - "Offset of field: _SYMCRYPT_ECURVE::G" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).H) as usize - ptr as usize }, - 656usize, - "Offset of field: _SYMCRYPT_ECURVE::H" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 664usize, - "Offset of field: _SYMCRYPT_ECURVE::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_ECURVE"][::std::mem::size_of::<_SYMCRYPT_ECURVE>() - 672usize]; + ["Alignment of _SYMCRYPT_ECURVE"][::std::mem::align_of::<_SYMCRYPT_ECURVE>() - 32usize]; + ["Offset of field: _SYMCRYPT_ECURVE::version"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, version) - 0usize]; + ["Offset of field: _SYMCRYPT_ECURVE::type_"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, type_) - 4usize]; + ["Offset of field: _SYMCRYPT_ECURVE::eCoordinates"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, eCoordinates) - 8usize]; + ["Offset of field: _SYMCRYPT_ECURVE::FModBitsize"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, FModBitsize) - 12usize]; + ["Offset of field: _SYMCRYPT_ECURVE::FModDigits"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, FModDigits) - 16usize]; + ["Offset of field: _SYMCRYPT_ECURVE::FModBytesize"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, FModBytesize) - 20usize]; + ["Offset of field: _SYMCRYPT_ECURVE::GOrdBitsize"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, GOrdBitsize) - 24usize]; + ["Offset of field: _SYMCRYPT_ECURVE::GOrdDigits"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, GOrdDigits) - 28usize]; + ["Offset of field: _SYMCRYPT_ECURVE::GOrdBytesize"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, GOrdBytesize) - 32usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbModElement"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbModElement) - 36usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbAlloc"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbAlloc) - 40usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbScratchCommon"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbScratchCommon) - 44usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbScratchScalar"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbScratchScalar) - 48usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbScratchScalarMulti"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbScratchScalarMulti) - 52usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbScratchGetSetValue"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbScratchGetSetValue) - 56usize]; + ["Offset of field: _SYMCRYPT_ECURVE::cbScratchEckey"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, cbScratchEckey) - 60usize]; + ["Offset of field: _SYMCRYPT_ECURVE::coFactorPower"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, coFactorPower) - 64usize]; + ["Offset of field: _SYMCRYPT_ECURVE::PrivateKeyDefaultFormat"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, PrivateKeyDefaultFormat) - 68usize]; + ["Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionNumOfBits"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, HighBitRestrictionNumOfBits) - 72usize]; + ["Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionPosition"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, HighBitRestrictionPosition) - 76usize]; + ["Offset of field: _SYMCRYPT_ECURVE::HighBitRestrictionValue"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, HighBitRestrictionValue) - 80usize]; + ["Offset of field: _SYMCRYPT_ECURVE::info"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, info) - 88usize]; + ["Offset of field: _SYMCRYPT_ECURVE::FMod"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, FMod) - 616usize]; + ["Offset of field: _SYMCRYPT_ECURVE::GOrd"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, GOrd) - 624usize]; + ["Offset of field: _SYMCRYPT_ECURVE::A"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, A) - 632usize]; + ["Offset of field: _SYMCRYPT_ECURVE::B"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, B) - 640usize]; + ["Offset of field: _SYMCRYPT_ECURVE::G"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, G) - 648usize]; + ["Offset of field: _SYMCRYPT_ECURVE::H"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, H) - 656usize]; + ["Offset of field: _SYMCRYPT_ECURVE::magic"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE, magic) - 664usize]; +}; impl Default for _SYMCRYPT_ECURVE { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -4078,36 +2528,17 @@ pub struct _SYMCRYPT_ECPOINT { pub pCurve: PCSYMCRYPT_ECURVE, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_ECPOINT() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECPOINT> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECPOINT>(), - 32usize, - "Size of _SYMCRYPT_ECPOINT" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECPOINT>(), - 32usize, - "Alignment of _SYMCRYPT_ECPOINT" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).normalized) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECPOINT::normalized" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pCurve) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECPOINT::pCurve" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECPOINT::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_ECPOINT"][::std::mem::size_of::<_SYMCRYPT_ECPOINT>() - 32usize]; + ["Alignment of _SYMCRYPT_ECPOINT"][::std::mem::align_of::<_SYMCRYPT_ECPOINT>() - 32usize]; + ["Offset of field: _SYMCRYPT_ECPOINT::normalized"] + [::std::mem::offset_of!(_SYMCRYPT_ECPOINT, normalized) - 0usize]; + ["Offset of field: _SYMCRYPT_ECPOINT::pCurve"] + [::std::mem::offset_of!(_SYMCRYPT_ECPOINT, pCurve) - 8usize]; + ["Offset of field: _SYMCRYPT_ECPOINT::magic"] + [::std::mem::offset_of!(_SYMCRYPT_ECPOINT, magic) - 16usize]; +}; impl Default for _SYMCRYPT_ECPOINT { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -4128,51 +2559,23 @@ pub struct _SYMCRYPT_ECKEY { pub piPrivateKey: PSYMCRYPT_INT, pub magic: SIZE_T, } -#[test] -fn bindgen_test_layout__SYMCRYPT_ECKEY() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECKEY> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECKEY>(), - 64usize, - "Size of _SYMCRYPT_ECKEY" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECKEY>(), - 32usize, - "Alignment of _SYMCRYPT_ECKEY" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).fAlgorithmInfo) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECKEY::fAlgorithmInfo" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).hasPrivateKey) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECKEY::hasPrivateKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).pCurve) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECKEY::pCurve" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).poPublicKey) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECKEY::poPublicKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).piPrivateKey) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_ECKEY::piPrivateKey" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).magic) as usize - ptr as usize }, - 32usize, - "Offset of field: _SYMCRYPT_ECKEY::magic" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_ECKEY"][::std::mem::size_of::<_SYMCRYPT_ECKEY>() - 64usize]; + ["Alignment of _SYMCRYPT_ECKEY"][::std::mem::align_of::<_SYMCRYPT_ECKEY>() - 32usize]; + ["Offset of field: _SYMCRYPT_ECKEY::fAlgorithmInfo"] + [::std::mem::offset_of!(_SYMCRYPT_ECKEY, fAlgorithmInfo) - 0usize]; + ["Offset of field: _SYMCRYPT_ECKEY::hasPrivateKey"] + [::std::mem::offset_of!(_SYMCRYPT_ECKEY, hasPrivateKey) - 4usize]; + ["Offset of field: _SYMCRYPT_ECKEY::pCurve"] + [::std::mem::offset_of!(_SYMCRYPT_ECKEY, pCurve) - 8usize]; + ["Offset of field: _SYMCRYPT_ECKEY::poPublicKey"] + [::std::mem::offset_of!(_SYMCRYPT_ECKEY, poPublicKey) - 16usize]; + ["Offset of field: _SYMCRYPT_ECKEY::piPrivateKey"] + [::std::mem::offset_of!(_SYMCRYPT_ECKEY, piPrivateKey) - 24usize]; + ["Offset of field: _SYMCRYPT_ECKEY::magic"] + [::std::mem::offset_of!(_SYMCRYPT_ECKEY, magic) - 32usize]; +}; impl Default for _SYMCRYPT_ECKEY { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -4185,188 +2588,183 @@ impl Default for _SYMCRYPT_ECKEY { pub type SYMCRYPT_ECKEY = _SYMCRYPT_ECKEY; pub type PSYMCRYPT_ECKEY = *mut SYMCRYPT_ECKEY; pub type PCSYMCRYPT_ECKEY = *const SYMCRYPT_ECKEY; -extern "C" { +unsafe extern "C" { pub fn SymCryptWipe(pbData: PVOID, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptLoadMsbFirstUint64( pbSrc: PCBYTE, cbSrc: SIZE_T, pDst: PUINT64, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptStoreMsbFirstUint64(src: UINT64, pbDst: PBYTE, cbDst: SIZE_T) -> SYMCRYPT_ERROR; } -#[cfg(not(feature = "dynamic"))] -extern "C" { - pub fn SymCryptInit(); -} -#[cfg(feature = "dynamic")] -extern "C" { +unsafe extern "C" { pub fn SymCryptModuleInit(api: UINT32, minor: UINT32); } -extern "C" { +unsafe extern "C" { pub fn SymCryptMd5(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptMd5Init(pState: PSYMCRYPT_MD5_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptMd5Append(pState: PSYMCRYPT_MD5_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptMd5Result(pState: PSYMCRYPT_MD5_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptMd5StateCopy(pSrc: PCSYMCRYPT_MD5_STATE, pDst: PSYMCRYPT_MD5_STATE); } -extern "C" { +unsafe extern "C" { pub static SymCryptMd5Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha1(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha1Init(pState: PSYMCRYPT_SHA1_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha1Append(pState: PSYMCRYPT_SHA1_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha1Result(pState: PSYMCRYPT_SHA1_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha1StateCopy(pSrc: PCSYMCRYPT_SHA1_STATE, pDst: PSYMCRYPT_SHA1_STATE); } -extern "C" { +unsafe extern "C" { pub static SymCryptSha1Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha256(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha256Init(pState: PSYMCRYPT_SHA256_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha256Append(pState: PSYMCRYPT_SHA256_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha256Result(pState: PSYMCRYPT_SHA256_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha256StateCopy(pSrc: PCSYMCRYPT_SHA256_STATE, pDst: PSYMCRYPT_SHA256_STATE); } -extern "C" { +unsafe extern "C" { pub static SymCryptSha256Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha384(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha384Init(pState: PSYMCRYPT_SHA384_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha384Append(pState: PSYMCRYPT_SHA384_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha384Result(pState: PSYMCRYPT_SHA384_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha384StateCopy(pSrc: PCSYMCRYPT_SHA384_STATE, pDst: PSYMCRYPT_SHA384_STATE); } -extern "C" { +unsafe extern "C" { pub static SymCryptSha384Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha512(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha512Init(pState: PSYMCRYPT_SHA512_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha512Append(pState: PSYMCRYPT_SHA512_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha512Result(pState: PSYMCRYPT_SHA512_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha512StateCopy(pSrc: PCSYMCRYPT_SHA512_STATE, pDst: PSYMCRYPT_SHA512_STATE); } -extern "C" { +unsafe extern "C" { pub static SymCryptSha512Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_256(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_256Init(pState: PSYMCRYPT_SHA3_256_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_256Append(pState: PSYMCRYPT_SHA3_256_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_256Result(pState: PSYMCRYPT_SHA3_256_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_256StateCopy( pSrc: PCSYMCRYPT_SHA3_256_STATE, pDst: PSYMCRYPT_SHA3_256_STATE, ); } -extern "C" { +unsafe extern "C" { pub static SymCryptSha3_256Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_384(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_384Init(pState: PSYMCRYPT_SHA3_384_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_384Append(pState: PSYMCRYPT_SHA3_384_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_384Result(pState: PSYMCRYPT_SHA3_384_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_384StateCopy( pSrc: PCSYMCRYPT_SHA3_384_STATE, pDst: PSYMCRYPT_SHA3_384_STATE, ); } -extern "C" { +unsafe extern "C" { pub static SymCryptSha3_384Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_512(pbData: PCBYTE, cbData: SIZE_T, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_512Init(pState: PSYMCRYPT_SHA3_512_STATE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_512Append(pState: PSYMCRYPT_SHA3_512_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_512Result(pState: PSYMCRYPT_SHA3_512_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptSha3_512StateCopy( pSrc: PCSYMCRYPT_SHA3_512_STATE, pDst: PSYMCRYPT_SHA3_512_STATE, ); } -extern "C" { +unsafe extern "C" { pub static SymCryptSha3_512Algorithm: PCSYMCRYPT_HASH; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacMd5ExpandKey( pExpandedKey: PSYMCRYPT_HMAC_MD5_EXPANDED_KEY, pbKey: PCBYTE, cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacMd5( pExpandedKey: PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY, pbData: PCBYTE, @@ -4374,36 +2772,36 @@ extern "C" { pbResult: PBYTE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacMd5StateCopy( pSrc: PCSYMCRYPT_HMAC_MD5_STATE, pExpandedKey: PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY, pDst: PSYMCRYPT_HMAC_MD5_STATE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacMd5Init( pState: PSYMCRYPT_HMAC_MD5_STATE, pExpandedKey: PCSYMCRYPT_HMAC_MD5_EXPANDED_KEY, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacMd5Append(pState: PSYMCRYPT_HMAC_MD5_STATE, pbData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacMd5Result(pState: PSYMCRYPT_HMAC_MD5_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub static SymCryptHmacMd5Algorithm: PCSYMCRYPT_MAC; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha1ExpandKey( pExpandedKey: PSYMCRYPT_HMAC_SHA1_EXPANDED_KEY, pbKey: PCBYTE, cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha1( pExpandedKey: PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY, pbData: PCBYTE, @@ -4411,40 +2809,40 @@ extern "C" { pbResult: PBYTE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha1StateCopy( pSrc: PCSYMCRYPT_HMAC_SHA1_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY, pDst: PSYMCRYPT_HMAC_SHA1_STATE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha1Init( pState: PSYMCRYPT_HMAC_SHA1_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA1_EXPANDED_KEY, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha1Append( pState: PSYMCRYPT_HMAC_SHA1_STATE, pbData: PCBYTE, cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha1Result(pState: PSYMCRYPT_HMAC_SHA1_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub static SymCryptHmacSha1Algorithm: PCSYMCRYPT_MAC; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha256ExpandKey( pExpandedKey: PSYMCRYPT_HMAC_SHA256_EXPANDED_KEY, pbKey: PCBYTE, cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha256( pExpandedKey: PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY, pbData: PCBYTE, @@ -4452,40 +2850,40 @@ extern "C" { pbResult: PBYTE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha256StateCopy( pSrc: PCSYMCRYPT_HMAC_SHA256_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY, pDst: PSYMCRYPT_HMAC_SHA256_STATE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha256Init( pState: PSYMCRYPT_HMAC_SHA256_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA256_EXPANDED_KEY, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha256Append( pState: PSYMCRYPT_HMAC_SHA256_STATE, pbData: PCBYTE, cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha256Result(pState: PSYMCRYPT_HMAC_SHA256_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub static SymCryptHmacSha256Algorithm: PCSYMCRYPT_MAC; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha384ExpandKey( pExpandedKey: PSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, pbKey: PCBYTE, cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha384( pExpandedKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, pbData: PCBYTE, @@ -4493,40 +2891,40 @@ extern "C" { pbResult: PBYTE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha384StateCopy( pSrc: PCSYMCRYPT_HMAC_SHA384_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, pDst: PSYMCRYPT_HMAC_SHA384_STATE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha384Init( pState: PSYMCRYPT_HMAC_SHA384_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA384_EXPANDED_KEY, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha384Append( pState: PSYMCRYPT_HMAC_SHA384_STATE, pbData: PCBYTE, cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha384Result(pState: PSYMCRYPT_HMAC_SHA384_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub static SymCryptHmacSha384Algorithm: PCSYMCRYPT_MAC; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha512ExpandKey( pExpandedKey: PSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, pbKey: PCBYTE, cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha512( pExpandedKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, pbData: PCBYTE, @@ -4534,33 +2932,33 @@ extern "C" { pbResult: PBYTE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha512StateCopy( pSrc: PCSYMCRYPT_HMAC_SHA512_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, pDst: PSYMCRYPT_HMAC_SHA512_STATE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha512Init( pState: PSYMCRYPT_HMAC_SHA512_STATE, pExpandedKey: PCSYMCRYPT_HMAC_SHA512_EXPANDED_KEY, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha512Append( pState: PSYMCRYPT_HMAC_SHA512_STATE, pbData: PCBYTE, cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptHmacSha512Result(pState: PSYMCRYPT_HMAC_SHA512_STATE, pbResult: PBYTE); } -extern "C" { +unsafe extern "C" { pub static SymCryptHmacSha512Algorithm: PCSYMCRYPT_MAC; } -extern "C" { +unsafe extern "C" { pub fn SymCryptChaCha20Poly1305Encrypt( pbKey: PCBYTE, cbKey: SIZE_T, @@ -4575,7 +2973,7 @@ extern "C" { cbTag: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptChaCha20Poly1305Decrypt( pbKey: PCBYTE, cbKey: SIZE_T, @@ -4590,14 +2988,14 @@ extern "C" { cbTag: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptAesExpandKey( pExpandedKey: PSYMCRYPT_AES_EXPANDED_KEY, pbKey: PCBYTE, cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptAesCbcEncrypt( pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY, pbChainingValue: PBYTE, @@ -4606,7 +3004,7 @@ extern "C" { cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptAesCbcDecrypt( pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY, pbChainingValue: PBYTE, @@ -4615,10 +3013,10 @@ extern "C" { cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub static SymCryptAesBlockCipher: PCSYMCRYPT_BLOCKCIPHER; } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmValidateParameters( pBlockCipher: PCSYMCRYPT_BLOCKCIPHER, cbNonce: SIZE_T, @@ -4627,7 +3025,7 @@ extern "C" { cbTag: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmExpandKey( pExpandedKey: PSYMCRYPT_GCM_EXPANDED_KEY, pBlockCipher: PCSYMCRYPT_BLOCKCIPHER, @@ -4635,7 +3033,7 @@ extern "C" { cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmEncrypt( pExpandedKey: PCSYMCRYPT_GCM_EXPANDED_KEY, pbNonce: PCBYTE, @@ -4649,7 +3047,7 @@ extern "C" { cbTag: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmDecrypt( pExpandedKey: PCSYMCRYPT_GCM_EXPANDED_KEY, pbNonce: PCBYTE, @@ -4663,7 +3061,7 @@ extern "C" { cbTag: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmInit( pState: PSYMCRYPT_GCM_STATE, pExpandedKey: PCSYMCRYPT_GCM_EXPANDED_KEY, @@ -4671,17 +3069,17 @@ extern "C" { cbNonce: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmStateCopy( pSrc: PCSYMCRYPT_GCM_STATE, pExpandedKeyCopy: PCSYMCRYPT_GCM_EXPANDED_KEY, pDst: PSYMCRYPT_GCM_STATE, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmAuthPart(pState: PSYMCRYPT_GCM_STATE, pbAuthData: PCBYTE, cbData: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmEncryptPart( pState: PSYMCRYPT_GCM_STATE, pbSrc: PCBYTE, @@ -4689,10 +3087,10 @@ extern "C" { cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmEncryptFinal(pState: PSYMCRYPT_GCM_STATE, pbTag: PBYTE, cbTag: SIZE_T); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmDecryptPart( pState: PSYMCRYPT_GCM_STATE, pbSrc: PCBYTE, @@ -4700,14 +3098,58 @@ extern "C" { cbData: SIZE_T, ); } -extern "C" { +unsafe extern "C" { pub fn SymCryptGcmDecryptFinal( pState: PSYMCRYPT_GCM_STATE, pbTag: PCBYTE, cbTag: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { + pub fn SymCryptSp800_108ExpandKey( + pExpandedKey: PSYMCRYPT_SP800_108_EXPANDED_KEY, + macAlgorithm: PCSYMCRYPT_MAC, + pbKey: PCBYTE, + cbKey: SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptSp800_108Derive( + pExpandedKey: PCSYMCRYPT_SP800_108_EXPANDED_KEY, + pbLabel: PCBYTE, + cbLabel: SIZE_T, + pbContext: PCBYTE, + cbContext: SIZE_T, + pbResult: PBYTE, + cbResult: SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptSp800_108( + macAlgorithm: PCSYMCRYPT_MAC, + pbKey: PCBYTE, + cbKey: SIZE_T, + pbLabel: PCBYTE, + cbLabel: SIZE_T, + pbContext: PCBYTE, + cbContext: SIZE_T, + pbResult: PBYTE, + cbResult: SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptSp800_108_HmacSha1SelfTest(); +} +unsafe extern "C" { + pub fn SymCryptSp800_108_HmacSha256SelfTest(); +} +unsafe extern "C" { + pub fn SymCryptSp800_108_HmacSha384SelfTest(); +} +unsafe extern "C" { + pub fn SymCryptSp800_108_HmacSha512SelfTest(); +} +unsafe extern "C" { pub fn SymCryptTlsPrf1_2ExpandKey( pExpandedKey: PSYMCRYPT_TLSPRF1_2_EXPANDED_KEY, macAlgorithm: PCSYMCRYPT_MAC, @@ -4715,7 +3157,7 @@ extern "C" { cbKey: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptTlsPrf1_2Derive( pExpandedKey: PCSYMCRYPT_TLSPRF1_2_EXPANDED_KEY, pbLabel: PCBYTE, @@ -4726,7 +3168,7 @@ extern "C" { cbResult: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptTlsPrf1_2( macAlgorithm: PCSYMCRYPT_MAC, pbKey: PCBYTE, @@ -4739,7 +3181,7 @@ extern "C" { cbResult: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHkdfExpandKey( pExpandedKey: PSYMCRYPT_HKDF_EXPANDED_KEY, macAlgorithm: PCSYMCRYPT_MAC, @@ -4749,7 +3191,7 @@ extern "C" { cbSalt: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHkdfExtractPrk( macAlgorithm: PCSYMCRYPT_MAC, pbIkm: PCBYTE, @@ -4760,7 +3202,7 @@ extern "C" { cbPrk: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHkdfPrkExpandKey( pExpandedKey: PSYMCRYPT_HKDF_EXPANDED_KEY, macAlgorithm: PCSYMCRYPT_MAC, @@ -4768,7 +3210,7 @@ extern "C" { cbPrk: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHkdfDerive( pExpandedKey: PCSYMCRYPT_HKDF_EXPANDED_KEY, pbInfo: PCBYTE, @@ -4777,7 +3219,7 @@ extern "C" { cbResult: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHkdf( macAlgorithm: PCSYMCRYPT_MAC, pbIkm: PCBYTE, @@ -4790,16 +3232,112 @@ extern "C" { cbResult: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptHkdfSelfTest(); } -#[cfg(feature = "dynamic")] -extern "C" { +unsafe extern "C" { pub fn SymCryptRandom(pbRandom: PBYTE, cbRandom: SIZE_T); } -#[cfg(not(feature = "dynamic"))] -extern "C" { - pub fn SymCryptCallbackRandom(pbBuffer: PBYTE, cbBuffer: SIZE_T) -> SYMCRYPT_ERROR; +unsafe extern "C" { + pub fn SymCryptXtsAesExpandKey( + pExpandedKey: PSYMCRYPT_XTS_AES_EXPANDED_KEY, + pbKey: PCBYTE, + cbKey: SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptXtsAesExpandKeyEx( + pExpandedKey: PSYMCRYPT_XTS_AES_EXPANDED_KEY, + pbKey: PCBYTE, + cbKey: SIZE_T, + flags: UINT32, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptXtsAesKeyCopy( + pSrc: PCSYMCRYPT_XTS_AES_EXPANDED_KEY, + pDst: PSYMCRYPT_XTS_AES_EXPANDED_KEY, + ); +} +unsafe extern "C" { + pub fn SymCryptXtsAesEncrypt( + pExpandedKey: PCSYMCRYPT_XTS_AES_EXPANDED_KEY, + cbDataUnit: SIZE_T, + tweak: UINT64, + pbSrc: PCBYTE, + pbDst: PBYTE, + cbData: SIZE_T, + ); +} +unsafe extern "C" { + pub fn SymCryptXtsAesDecrypt( + pExpandedKey: PCSYMCRYPT_XTS_AES_EXPANDED_KEY, + cbDataUnit: SIZE_T, + tweak: UINT64, + pbSrc: PCBYTE, + pbDst: PBYTE, + cbData: SIZE_T, + ); +} +unsafe extern "C" { + pub fn SymCryptXtsAesEncryptWith128bTweak( + pExpandedKey: PCSYMCRYPT_XTS_AES_EXPANDED_KEY, + cbDataUnit: SIZE_T, + pbTweak: PCBYTE, + pbSrc: PCBYTE, + pbDst: PBYTE, + cbData: SIZE_T, + ); +} +unsafe extern "C" { + pub fn SymCryptXtsAesDecryptWith128bTweak( + pExpandedKey: PCSYMCRYPT_XTS_AES_EXPANDED_KEY, + cbDataUnit: SIZE_T, + pbTweak: PCBYTE, + pbSrc: PCBYTE, + pbDst: PBYTE, + cbData: SIZE_T, + ); +} +unsafe extern "C" { + pub fn SymCryptAesKwEncrypt( + pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY, + pbSrc: PCBYTE, + cbSrc: SIZE_T, + pbDst: PBYTE, + cbDst: SIZE_T, + pcbResult: *mut SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptAesKwDecrypt( + pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY, + pbSrc: PCBYTE, + cbSrc: SIZE_T, + pbDst: PBYTE, + cbDst: SIZE_T, + pcbResult: *mut SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptAesKwpEncrypt( + pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY, + pbSrc: PCBYTE, + cbSrc: SIZE_T, + pbDst: PBYTE, + cbDst: SIZE_T, + pcbResult: *mut SIZE_T, + ) -> SYMCRYPT_ERROR; +} +unsafe extern "C" { + pub fn SymCryptAesKwpDecrypt( + pExpandedKey: PCSYMCRYPT_AES_EXPANDED_KEY, + pbSrc: PCBYTE, + cbSrc: SIZE_T, + pbDst: PBYTE, + cbDst: SIZE_T, + pcbResult: *mut SIZE_T, + ) -> SYMCRYPT_ERROR; } pub const _SYMCRYPT_NUMBER_FORMAT_SYMCRYPT_NUMBER_FORMAT_LSB_FIRST: _SYMCRYPT_NUMBER_FORMAT = 1; pub const _SYMCRYPT_NUMBER_FORMAT_SYMCRYPT_NUMBER_FORMAT_MSB_FIRST: _SYMCRYPT_NUMBER_FORMAT = 2; @@ -4813,41 +3351,19 @@ pub struct _SYMCRYPT_RSA_PARAMS { pub nPrimes: UINT32, pub nPubExp: UINT32, } -#[test] -fn bindgen_test_layout__SYMCRYPT_RSA_PARAMS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_RSA_PARAMS> = ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_RSA_PARAMS>(), - 16usize, - "Size of _SYMCRYPT_RSA_PARAMS" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_RSA_PARAMS>(), - 4usize, - "Alignment of _SYMCRYPT_RSA_PARAMS" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_RSA_PARAMS::version" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nBitsOfModulus) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_RSA_PARAMS::nBitsOfModulus" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPrimes) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_RSA_PARAMS::nPrimes" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).nPubExp) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_RSA_PARAMS::nPubExp" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_RSA_PARAMS"][::std::mem::size_of::<_SYMCRYPT_RSA_PARAMS>() - 16usize]; + ["Alignment of _SYMCRYPT_RSA_PARAMS"][::std::mem::align_of::<_SYMCRYPT_RSA_PARAMS>() - 4usize]; + ["Offset of field: _SYMCRYPT_RSA_PARAMS::version"] + [::std::mem::offset_of!(_SYMCRYPT_RSA_PARAMS, version) - 0usize]; + ["Offset of field: _SYMCRYPT_RSA_PARAMS::nBitsOfModulus"] + [::std::mem::offset_of!(_SYMCRYPT_RSA_PARAMS, nBitsOfModulus) - 4usize]; + ["Offset of field: _SYMCRYPT_RSA_PARAMS::nPrimes"] + [::std::mem::offset_of!(_SYMCRYPT_RSA_PARAMS, nPrimes) - 8usize]; + ["Offset of field: _SYMCRYPT_RSA_PARAMS::nPubExp"] + [::std::mem::offset_of!(_SYMCRYPT_RSA_PARAMS, nPubExp) - 12usize]; +}; pub type SYMCRYPT_RSA_PARAMS = _SYMCRYPT_RSA_PARAMS; pub type PCSYMCRYPT_RSA_PARAMS = *const SYMCRYPT_RSA_PARAMS; pub const _SYMCRYPT_ECURVE_GEN_ALG_ID_SYMCRYPT_ECURVE_GEN_ALG_ID_NULL: _SYMCRYPT_ECURVE_GEN_ALG_ID = @@ -4865,57 +3381,26 @@ pub struct _SYMCRYPT_ECURVE_PARAMS { pub cbCofactor: UINT32, pub cbSeed: UINT32, } -#[test] -fn bindgen_test_layout__SYMCRYPT_ECURVE_PARAMS() { - const UNINIT: ::std::mem::MaybeUninit<_SYMCRYPT_ECURVE_PARAMS> = - ::std::mem::MaybeUninit::uninit(); - let ptr = UNINIT.as_ptr(); - assert_eq!( - ::std::mem::size_of::<_SYMCRYPT_ECURVE_PARAMS>(), - 28usize, - "Size of _SYMCRYPT_ECURVE_PARAMS" - ); - assert_eq!( - ::std::mem::align_of::<_SYMCRYPT_ECURVE_PARAMS>(), - 4usize, - "Alignment of _SYMCRYPT_ECURVE_PARAMS" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).version) as usize - ptr as usize }, - 0usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::version" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize }, - 4usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::type_" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).algId) as usize - ptr as usize }, - 8usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::algId" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbFieldLength) as usize - ptr as usize }, - 12usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbFieldLength" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSubgroupOrder) as usize - ptr as usize }, - 16usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbSubgroupOrder" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbCofactor) as usize - ptr as usize }, - 20usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbCofactor" - ); - assert_eq!( - unsafe { ::std::ptr::addr_of!((*ptr).cbSeed) as usize - ptr as usize }, - 24usize, - "Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbSeed" - ); -} +#[allow(clippy::unnecessary_operation, clippy::identity_op)] +const _: () = { + ["Size of _SYMCRYPT_ECURVE_PARAMS"][::std::mem::size_of::<_SYMCRYPT_ECURVE_PARAMS>() - 28usize]; + ["Alignment of _SYMCRYPT_ECURVE_PARAMS"] + [::std::mem::align_of::<_SYMCRYPT_ECURVE_PARAMS>() - 4usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::version"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, version) - 0usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::type_"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, type_) - 4usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::algId"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, algId) - 8usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbFieldLength"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, cbFieldLength) - 12usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbSubgroupOrder"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, cbSubgroupOrder) - 16usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbCofactor"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, cbCofactor) - 20usize]; + ["Offset of field: _SYMCRYPT_ECURVE_PARAMS::cbSeed"] + [::std::mem::offset_of!(_SYMCRYPT_ECURVE_PARAMS, cbSeed) - 24usize]; +}; impl Default for _SYMCRYPT_ECURVE_PARAMS { fn default() -> Self { let mut s = ::std::mem::MaybeUninit::::uninit(); @@ -4931,52 +3416,52 @@ pub const _SYMCRYPT_ECPOINT_FORMAT_SYMCRYPT_ECPOINT_FORMAT_X: _SYMCRYPT_ECPOINT_ pub const _SYMCRYPT_ECPOINT_FORMAT_SYMCRYPT_ECPOINT_FORMAT_XY: _SYMCRYPT_ECPOINT_FORMAT = 2; pub type _SYMCRYPT_ECPOINT_FORMAT = ::std::os::raw::c_uint; pub use self::_SYMCRYPT_ECPOINT_FORMAT as SYMCRYPT_ECPOINT_FORMAT; -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyAllocate( pParams: PCSYMCRYPT_RSA_PARAMS, flags: UINT32, ) -> PSYMCRYPT_RSAKEY; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyFree(pkObj: PSYMCRYPT_RSAKEY); } -extern "C" { +unsafe extern "C" { pub fn SymCryptEcurveAllocate( pParams: PCSYMCRYPT_ECURVE_PARAMS, flags: UINT32, ) -> PSYMCRYPT_ECURVE; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEcurveFree(pCurve: PSYMCRYPT_ECURVE); } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeyAllocate(pCurve: PCSYMCRYPT_ECURVE) -> PSYMCRYPT_ECKEY; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeyFree(pkObj: PSYMCRYPT_ECKEY); } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyHasPrivateKey(pkRsakey: PCSYMCRYPT_RSAKEY) -> BOOLEAN; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeySizeofModulus(pkRsakey: PCSYMCRYPT_RSAKEY) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyModulusBits(pkRsakey: PCSYMCRYPT_RSAKEY) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeySizeofPublicExponent(pRsakey: PCSYMCRYPT_RSAKEY, index: UINT32) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeySizeofPrime(pkRsakey: PCSYMCRYPT_RSAKEY, index: UINT32) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyGetNumberOfPublicExponents(pkRsakey: PCSYMCRYPT_RSAKEY) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyGetNumberOfPrimes(pkRsakey: PCSYMCRYPT_RSAKEY) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyGenerate( pkRsakey: PSYMCRYPT_RSAKEY, pu64PubExp: PCUINT64, @@ -4984,7 +3469,7 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeySetValue( pbModulus: PCBYTE, cbModulus: SIZE_T, @@ -4998,7 +3483,7 @@ extern "C" { pkRsakey: PSYMCRYPT_RSAKEY, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeySetValueFromPrivateExponent( pbModulus: PCBYTE, cbModulus: SIZE_T, @@ -5010,7 +3495,7 @@ extern "C" { pkRsakey: PSYMCRYPT_RSAKEY, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyGetValue( pkRsakey: PCSYMCRYPT_RSAKEY, pbModulus: PBYTE, @@ -5024,7 +3509,7 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyGetCrtValue( pkRsakey: PCSYMCRYPT_RSAKEY, ppCrtExponents: *mut PBYTE, @@ -5038,37 +3523,37 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsakeyExtendKeyUsage( pkRsakey: PSYMCRYPT_RSAKEY, flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEcurveSizeofFieldElement(pCurve: PCSYMCRYPT_ECURVE) -> UINT32; } -extern "C" { +unsafe extern "C" { pub static SymCryptEcurveParamsNistP256: PCSYMCRYPT_ECURVE_PARAMS; } -extern "C" { +unsafe extern "C" { pub static SymCryptEcurveParamsNistP384: PCSYMCRYPT_ECURVE_PARAMS; } -extern "C" { +unsafe extern "C" { pub static SymCryptEcurveParamsNistP521: PCSYMCRYPT_ECURVE_PARAMS; } -extern "C" { +unsafe extern "C" { pub static SymCryptEcurveParamsCurve25519: PCSYMCRYPT_ECURVE_PARAMS; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeySizeofPublicKey( pkEckey: PCSYMCRYPT_ECKEY, ecPointFormat: SYMCRYPT_ECPOINT_FORMAT, ) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeySizeofPrivateKey(pkEckey: PCSYMCRYPT_ECKEY) -> UINT32; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeySetValue( pbPrivateKey: PCBYTE, cbPrivateKey: SIZE_T, @@ -5080,10 +3565,10 @@ extern "C" { pEckey: PSYMCRYPT_ECKEY, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeySetRandom(flags: UINT32, pEckey: PSYMCRYPT_ECKEY) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEckeyGetValue( pEckey: PCSYMCRYPT_ECKEY, pbPrivateKey: PBYTE, @@ -5095,7 +3580,7 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaPkcs1Encrypt( pkRsakey: PCSYMCRYPT_RSAKEY, pbSrc: PCBYTE, @@ -5107,7 +3592,7 @@ extern "C" { pcbDst: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaPkcs1Decrypt( pkRsakey: PCSYMCRYPT_RSAKEY, pbSrc: PCBYTE, @@ -5119,7 +3604,7 @@ extern "C" { pcbDst: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaOaepEncrypt( pkRsakey: PCSYMCRYPT_RSAKEY, pbSrc: PCBYTE, @@ -5134,7 +3619,7 @@ extern "C" { pcbDst: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaOaepDecrypt( pkRsakey: PCSYMCRYPT_RSAKEY, pbSrc: PCBYTE, @@ -5149,7 +3634,7 @@ extern "C" { pcbDst: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaPkcs1Sign( pkRsakey: PCSYMCRYPT_RSAKEY, pbHashValue: PCBYTE, @@ -5163,7 +3648,7 @@ extern "C" { pcbSignature: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaPkcs1Verify( pkRsakey: PCSYMCRYPT_RSAKEY, pbHashValue: PCBYTE, @@ -5176,7 +3661,7 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaPssSign( pkRsakey: PCSYMCRYPT_RSAKEY, pbHashValue: PCBYTE, @@ -5190,7 +3675,7 @@ extern "C" { pcbSignature: *mut SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptRsaPssVerify( pkRsakey: PCSYMCRYPT_RSAKEY, pbHashValue: PCBYTE, @@ -5203,7 +3688,7 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEcDsaSign( pKey: PCSYMCRYPT_ECKEY, pbHashValue: PCBYTE, @@ -5214,7 +3699,7 @@ extern "C" { cbSignature: SIZE_T, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEcDsaVerify( pKey: PCSYMCRYPT_ECKEY, pbHashValue: PCBYTE, @@ -5225,7 +3710,7 @@ extern "C" { flags: UINT32, ) -> SYMCRYPT_ERROR; } -extern "C" { +unsafe extern "C" { pub fn SymCryptEcDhSecretAgreement( pkPrivate: PCSYMCRYPT_ECKEY, pkPublic: PCSYMCRYPT_ECKEY, diff --git a/symcrypt-sys/symcrypt b/symcrypt-sys/symcrypt index 53be637d..748c20f1 160000 --- a/symcrypt-sys/symcrypt +++ b/symcrypt-sys/symcrypt @@ -1 +1 @@ -Subproject commit 53be637dab201a4c9d95e1cf58040c85d71cf3c2 +Subproject commit 748c20f1fc486beca1a2679ed06492712cfdc950