diff --git a/lib/src/boringssl/bindings/ffigen.yaml b/lib/src/boringssl/bindings/ffigen.yaml
index 04ece16d..06860161 100644
--- a/lib/src/boringssl/bindings/ffigen.yaml
+++ b/lib/src/boringssl/bindings/ffigen.yaml
@@ -21,7 +21,8 @@ structs:
   dependency-only: opaque
 functions:
   include:
-    - webcrypto_lookup_symbol
+    - webcrypto_get_CBB_size
+    - webcrypto_get_EVP_PKEY_free_address
 preamble: |
   // Copyright 2021 Google LLC
   //
diff --git a/lib/src/boringssl/lookup/direct_bindings.generated.dart b/lib/src/boringssl/lookup/direct_bindings.generated.dart
new file mode 100644
index 00000000..8b6cb806
--- /dev/null
+++ b/lib/src/boringssl/lookup/direct_bindings.generated.dart
@@ -0,0 +1,2142 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// AUTO GENERATED FILE, DO NOT EDIT.
+//
+// Generated by `tool/generate_direct_bindings.dart`.
+// ignore_for_file: constant_identifier_names
+// ignore_for_file: non_constant_identifier_names
+// ignore_for_file: type=lint
+
+import 'dart:ffi' as ffi;
+
+import '../../third_party/boringssl/generated_bindings.dart';
+
+const _assetId = 'package:webcrypto/webcrypto.dart';
+
+class WebcryptoBoringSsl {
+  const WebcryptoBoringSsl();
+
+  ffi.Pointer<BIGNUM> BN_bin2bn(
+    ffi.Pointer<ffi.Uint8> in1,
+    int len,
+    ffi.Pointer<BIGNUM> ret,
+  ) {
+    return _native_BN_bin2bn(in1, len, ret);
+  }
+
+  @ffi.Native<
+    ffi.Pointer<BIGNUM> Function(
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Size,
+      ffi.Pointer<BIGNUM>,
+    )
+  >(symbol: 'webcrypto_BN_bin2bn', assetId: _assetId)
+  external static ffi.Pointer<BIGNUM> _native_BN_bin2bn(
+    ffi.Pointer<ffi.Uint8> in1,
+    int len,
+    ffi.Pointer<BIGNUM> ret,
+  );
+
+  int BN_bn2bin_padded(
+    ffi.Pointer<ffi.Uint8> out,
+    int len,
+    ffi.Pointer<BIGNUM> in1,
+  ) {
+    return _native_BN_bn2bin_padded(out, len, in1);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(ffi.Pointer<ffi.Uint8>, ffi.Size, ffi.Pointer<BIGNUM>)
+  >(symbol: 'webcrypto_BN_bn2bin_padded', assetId: _assetId)
+  external static int _native_BN_bn2bin_padded(
+    ffi.Pointer<ffi.Uint8> out,
+    int len,
+    ffi.Pointer<BIGNUM> in1,
+  );
+
+  void BN_free(ffi.Pointer<BIGNUM> bn) {
+    return _native_BN_free(bn);
+  }
+
+  @ffi.Native<ffi.Void Function(ffi.Pointer<BIGNUM>)>(
+    symbol: 'webcrypto_BN_free',
+    assetId: _assetId,
+  )
+  external static void _native_BN_free(ffi.Pointer<BIGNUM> bn);
+
+  ffi.Pointer<BIGNUM> BN_new() {
+    return _native_BN_new();
+  }
+
+  @ffi.Native<ffi.Pointer<BIGNUM> Function()>(
+    symbol: 'webcrypto_BN_new',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<BIGNUM> _native_BN_new();
+
+  int BN_num_bytes(ffi.Pointer<BIGNUM> bn) {
+    return _native_BN_num_bytes(bn);
+  }
+
+  @ffi.Native<ffi.UnsignedInt Function(ffi.Pointer<BIGNUM>)>(
+    symbol: 'webcrypto_BN_num_bytes',
+    assetId: _assetId,
+  )
+  external static int _native_BN_num_bytes(ffi.Pointer<BIGNUM> bn);
+
+  int BN_set_word(ffi.Pointer<BIGNUM> bn, int value) {
+    return _native_BN_set_word(bn, value);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<BIGNUM>, BN_ULONG)>(
+    symbol: 'webcrypto_BN_set_word',
+    assetId: _assetId,
+  )
+  external static int _native_BN_set_word(ffi.Pointer<BIGNUM> bn, int value);
+
+  void CBB_cleanup(ffi.Pointer<CBB> cbb) {
+    return _native_CBB_cleanup(cbb);
+  }
+
+  @ffi.Native<ffi.Void Function(ffi.Pointer<CBB>)>(
+    symbol: 'webcrypto_CBB_cleanup',
+    assetId: _assetId,
+  )
+  external static void _native_CBB_cleanup(ffi.Pointer<CBB> cbb);
+
+  ffi.Pointer<ffi.Uint8> CBB_data(ffi.Pointer<CBB> cbb) {
+    return _native_CBB_data(cbb);
+  }
+
+  @ffi.Native<ffi.Pointer<ffi.Uint8> Function(ffi.Pointer<CBB>)>(
+    symbol: 'webcrypto_CBB_data',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<ffi.Uint8> _native_CBB_data(ffi.Pointer<CBB> cbb);
+
+  int CBB_flush(ffi.Pointer<CBB> cbb) {
+    return _native_CBB_flush(cbb);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<CBB>)>(
+    symbol: 'webcrypto_CBB_flush',
+    assetId: _assetId,
+  )
+  external static int _native_CBB_flush(ffi.Pointer<CBB> cbb);
+
+  int CBB_init(ffi.Pointer<CBB> cbb, int initial_capacity) {
+    return _native_CBB_init(cbb, initial_capacity);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<CBB>, ffi.Size)>(
+    symbol: 'webcrypto_CBB_init',
+    assetId: _assetId,
+  )
+  external static int _native_CBB_init(
+    ffi.Pointer<CBB> cbb,
+    int initial_capacity,
+  );
+
+  int CBB_len(ffi.Pointer<CBB> cbb) {
+    return _native_CBB_len(cbb);
+  }
+
+  @ffi.Native<ffi.Size Function(ffi.Pointer<CBB>)>(
+    symbol: 'webcrypto_CBB_len',
+    assetId: _assetId,
+  )
+  external static int _native_CBB_len(ffi.Pointer<CBB> cbb);
+
+  void CBB_zero(ffi.Pointer<CBB> cbb) {
+    return _native_CBB_zero(cbb);
+  }
+
+  @ffi.Native<ffi.Void Function(ffi.Pointer<CBB>)>(
+    symbol: 'webcrypto_CBB_zero',
+    assetId: _assetId,
+  )
+  external static void _native_CBB_zero(ffi.Pointer<CBB> cbb);
+
+  int CRYPTO_memcmp(ffi.Pointer<ffi.Void> a, ffi.Pointer<ffi.Void> b, int len) {
+    return _native_CRYPTO_memcmp(a, b, len);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>, ffi.Size)
+  >(symbol: 'webcrypto_CRYPTO_memcmp', assetId: _assetId)
+  external static int _native_CRYPTO_memcmp(
+    ffi.Pointer<ffi.Void> a,
+    ffi.Pointer<ffi.Void> b,
+    int len,
+  );
+
+  int ECDH_compute_key(
+    ffi.Pointer<ffi.Void> out,
+    int outlen,
+    ffi.Pointer<EC_POINT> pub_key,
+    ffi.Pointer<EC_KEY> priv_key,
+    ffi.Pointer<
+      ffi.NativeFunction<
+        ffi.Pointer<ffi.Void> Function(
+          ffi.Pointer<ffi.Void> in1,
+          ffi.Size inlen,
+          ffi.Pointer<ffi.Void> out,
+          ffi.Pointer<ffi.Size> outlen,
+        )
+      >
+    >
+    kdf,
+  ) {
+    return _native_ECDH_compute_key(out, outlen, pub_key, priv_key, kdf);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<ffi.Void>,
+      ffi.Size,
+      ffi.Pointer<EC_POINT>,
+      ffi.Pointer<EC_KEY>,
+      ffi.Pointer<
+        ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+            ffi.Pointer<ffi.Void> in1,
+            ffi.Size inlen,
+            ffi.Pointer<ffi.Void> out,
+            ffi.Pointer<ffi.Size> outlen,
+          )
+        >
+      >,
+    )
+  >(symbol: 'webcrypto_ECDH_compute_key', assetId: _assetId)
+  external static int _native_ECDH_compute_key(
+    ffi.Pointer<ffi.Void> out,
+    int outlen,
+    ffi.Pointer<EC_POINT> pub_key,
+    ffi.Pointer<EC_KEY> priv_key,
+    ffi.Pointer<
+      ffi.NativeFunction<
+        ffi.Pointer<ffi.Void> Function(
+          ffi.Pointer<ffi.Void> in1,
+          ffi.Size inlen,
+          ffi.Pointer<ffi.Void> out,
+          ffi.Pointer<ffi.Size> outlen,
+        )
+      >
+    >
+    kdf,
+  );
+
+  void ECDSA_SIG_free(ffi.Pointer<ECDSA_SIG> sig) {
+    return _native_ECDSA_SIG_free(sig);
+  }
+
+  @ffi.Native<ffi.Void Function(ffi.Pointer<ECDSA_SIG>)>(
+    symbol: 'webcrypto_ECDSA_SIG_free',
+    assetId: _assetId,
+  )
+  external static void _native_ECDSA_SIG_free(ffi.Pointer<ECDSA_SIG> sig);
+
+  void ECDSA_SIG_get0(
+    ffi.Pointer<ECDSA_SIG> sig,
+    ffi.Pointer<ffi.Pointer<BIGNUM>> out_r,
+    ffi.Pointer<ffi.Pointer<BIGNUM>> out_s,
+  ) {
+    return _native_ECDSA_SIG_get0(sig, out_r, out_s);
+  }
+
+  @ffi.Native<
+    ffi.Void Function(
+      ffi.Pointer<ECDSA_SIG>,
+      ffi.Pointer<ffi.Pointer<BIGNUM>>,
+      ffi.Pointer<ffi.Pointer<BIGNUM>>,
+    )
+  >(symbol: 'webcrypto_ECDSA_SIG_get0', assetId: _assetId)
+  external static void _native_ECDSA_SIG_get0(
+    ffi.Pointer<ECDSA_SIG> sig,
+    ffi.Pointer<ffi.Pointer<BIGNUM>> out_r,
+    ffi.Pointer<ffi.Pointer<BIGNUM>> out_s,
+  );
+
+  int ECDSA_SIG_marshal(ffi.Pointer<CBB> cbb, ffi.Pointer<ECDSA_SIG> sig) {
+    return _native_ECDSA_SIG_marshal(cbb, sig);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<CBB>, ffi.Pointer<ECDSA_SIG>)>(
+    symbol: 'webcrypto_ECDSA_SIG_marshal',
+    assetId: _assetId,
+  )
+  external static int _native_ECDSA_SIG_marshal(
+    ffi.Pointer<CBB> cbb,
+    ffi.Pointer<ECDSA_SIG> sig,
+  );
+
+  ffi.Pointer<ECDSA_SIG> ECDSA_SIG_new() {
+    return _native_ECDSA_SIG_new();
+  }
+
+  @ffi.Native<ffi.Pointer<ECDSA_SIG> Function()>(
+    symbol: 'webcrypto_ECDSA_SIG_new',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<ECDSA_SIG> _native_ECDSA_SIG_new();
+
+  ffi.Pointer<ECDSA_SIG> ECDSA_SIG_parse(ffi.Pointer<CBS> cbs) {
+    return _native_ECDSA_SIG_parse(cbs);
+  }
+
+  @ffi.Native<ffi.Pointer<ECDSA_SIG> Function(ffi.Pointer<CBS>)>(
+    symbol: 'webcrypto_ECDSA_SIG_parse',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<ECDSA_SIG> _native_ECDSA_SIG_parse(
+    ffi.Pointer<CBS> cbs,
+  );
+
+  ffi.Pointer<BIGNUM> EC_GROUP_get0_order(ffi.Pointer<EC_GROUP> group) {
+    return _native_EC_GROUP_get0_order(group);
+  }
+
+  @ffi.Native<ffi.Pointer<BIGNUM> Function(ffi.Pointer<EC_GROUP>)>(
+    symbol: 'webcrypto_EC_GROUP_get0_order',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<BIGNUM> _native_EC_GROUP_get0_order(
+    ffi.Pointer<EC_GROUP> group,
+  );
+
+  int EC_GROUP_get_curve_name(ffi.Pointer<EC_GROUP> group) {
+    return _native_EC_GROUP_get_curve_name(group);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<EC_GROUP>)>(
+    symbol: 'webcrypto_EC_GROUP_get_curve_name',
+    assetId: _assetId,
+  )
+  external static int _native_EC_GROUP_get_curve_name(
+    ffi.Pointer<EC_GROUP> group,
+  );
+
+  int EC_GROUP_get_degree(ffi.Pointer<EC_GROUP> group) {
+    return _native_EC_GROUP_get_degree(group);
+  }
+
+  @ffi.Native<ffi.UnsignedInt Function(ffi.Pointer<EC_GROUP>)>(
+    symbol: 'webcrypto_EC_GROUP_get_degree',
+    assetId: _assetId,
+  )
+  external static int _native_EC_GROUP_get_degree(ffi.Pointer<EC_GROUP> group);
+
+  int EC_KEY_check_key(ffi.Pointer<EC_KEY> key) {
+    return _native_EC_KEY_check_key(key);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<EC_KEY>)>(
+    symbol: 'webcrypto_EC_KEY_check_key',
+    assetId: _assetId,
+  )
+  external static int _native_EC_KEY_check_key(ffi.Pointer<EC_KEY> key);
+
+  void EC_KEY_free(ffi.Pointer<EC_KEY> key) {
+    return _native_EC_KEY_free(key);
+  }
+
+  @ffi.Native<ffi.Void Function(ffi.Pointer<EC_KEY>)>(
+    symbol: 'webcrypto_EC_KEY_free',
+    assetId: _assetId,
+  )
+  external static void _native_EC_KEY_free(ffi.Pointer<EC_KEY> key);
+
+  int EC_KEY_generate_key(ffi.Pointer<EC_KEY> key) {
+    return _native_EC_KEY_generate_key(key);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<EC_KEY>)>(
+    symbol: 'webcrypto_EC_KEY_generate_key',
+    assetId: _assetId,
+  )
+  external static int _native_EC_KEY_generate_key(ffi.Pointer<EC_KEY> key);
+
+  ffi.Pointer<EC_GROUP> EC_KEY_get0_group(ffi.Pointer<EC_KEY> key) {
+    return _native_EC_KEY_get0_group(key);
+  }
+
+  @ffi.Native<ffi.Pointer<EC_GROUP> Function(ffi.Pointer<EC_KEY>)>(
+    symbol: 'webcrypto_EC_KEY_get0_group',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<EC_GROUP> _native_EC_KEY_get0_group(
+    ffi.Pointer<EC_KEY> key,
+  );
+
+  ffi.Pointer<BIGNUM> EC_KEY_get0_private_key(ffi.Pointer<EC_KEY> key) {
+    return _native_EC_KEY_get0_private_key(key);
+  }
+
+  @ffi.Native<ffi.Pointer<BIGNUM> Function(ffi.Pointer<EC_KEY>)>(
+    symbol: 'webcrypto_EC_KEY_get0_private_key',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<BIGNUM> _native_EC_KEY_get0_private_key(
+    ffi.Pointer<EC_KEY> key,
+  );
+
+  ffi.Pointer<EC_POINT> EC_KEY_get0_public_key(ffi.Pointer<EC_KEY> key) {
+    return _native_EC_KEY_get0_public_key(key);
+  }
+
+  @ffi.Native<ffi.Pointer<EC_POINT> Function(ffi.Pointer<EC_KEY>)>(
+    symbol: 'webcrypto_EC_KEY_get0_public_key',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<EC_POINT> _native_EC_KEY_get0_public_key(
+    ffi.Pointer<EC_KEY> key,
+  );
+
+  int EC_KEY_get_enc_flags(ffi.Pointer<EC_KEY> key) {
+    return _native_EC_KEY_get_enc_flags(key);
+  }
+
+  @ffi.Native<ffi.UnsignedInt Function(ffi.Pointer<EC_KEY>)>(
+    symbol: 'webcrypto_EC_KEY_get_enc_flags',
+    assetId: _assetId,
+  )
+  external static int _native_EC_KEY_get_enc_flags(ffi.Pointer<EC_KEY> key);
+
+  ffi.Pointer<EC_KEY> EC_KEY_new_by_curve_name(int nid) {
+    return _native_EC_KEY_new_by_curve_name(nid);
+  }
+
+  @ffi.Native<ffi.Pointer<EC_KEY> Function(ffi.Int)>(
+    symbol: 'webcrypto_EC_KEY_new_by_curve_name',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<EC_KEY> _native_EC_KEY_new_by_curve_name(int nid);
+
+  void EC_KEY_set_enc_flags(ffi.Pointer<EC_KEY> key, int flags) {
+    return _native_EC_KEY_set_enc_flags(key, flags);
+  }
+
+  @ffi.Native<ffi.Void Function(ffi.Pointer<EC_KEY>, ffi.UnsignedInt)>(
+    symbol: 'webcrypto_EC_KEY_set_enc_flags',
+    assetId: _assetId,
+  )
+  external static void _native_EC_KEY_set_enc_flags(
+    ffi.Pointer<EC_KEY> key,
+    int flags,
+  );
+
+  int EC_KEY_set_private_key(
+    ffi.Pointer<EC_KEY> key,
+    ffi.Pointer<BIGNUM> priv,
+  ) {
+    return _native_EC_KEY_set_private_key(key, priv);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<EC_KEY>, ffi.Pointer<BIGNUM>)>(
+    symbol: 'webcrypto_EC_KEY_set_private_key',
+    assetId: _assetId,
+  )
+  external static int _native_EC_KEY_set_private_key(
+    ffi.Pointer<EC_KEY> key,
+    ffi.Pointer<BIGNUM> priv,
+  );
+
+  int EC_KEY_set_public_key(
+    ffi.Pointer<EC_KEY> key,
+    ffi.Pointer<EC_POINT> pub,
+  ) {
+    return _native_EC_KEY_set_public_key(key, pub);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<EC_KEY>, ffi.Pointer<EC_POINT>)>(
+    symbol: 'webcrypto_EC_KEY_set_public_key',
+    assetId: _assetId,
+  )
+  external static int _native_EC_KEY_set_public_key(
+    ffi.Pointer<EC_KEY> key,
+    ffi.Pointer<EC_POINT> pub,
+  );
+
+  int EC_KEY_set_public_key_affine_coordinates(
+    ffi.Pointer<EC_KEY> key,
+    ffi.Pointer<BIGNUM> x,
+    ffi.Pointer<BIGNUM> y,
+  ) {
+    return _native_EC_KEY_set_public_key_affine_coordinates(key, x, y);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<EC_KEY>,
+      ffi.Pointer<BIGNUM>,
+      ffi.Pointer<BIGNUM>,
+    )
+  >(
+    symbol: 'webcrypto_EC_KEY_set_public_key_affine_coordinates',
+    assetId: _assetId,
+  )
+  external static int _native_EC_KEY_set_public_key_affine_coordinates(
+    ffi.Pointer<EC_KEY> key,
+    ffi.Pointer<BIGNUM> x,
+    ffi.Pointer<BIGNUM> y,
+  );
+
+  void EC_POINT_free(ffi.Pointer<EC_POINT> point) {
+    return _native_EC_POINT_free(point);
+  }
+
+  @ffi.Native<ffi.Void Function(ffi.Pointer<EC_POINT>)>(
+    symbol: 'webcrypto_EC_POINT_free',
+    assetId: _assetId,
+  )
+  external static void _native_EC_POINT_free(ffi.Pointer<EC_POINT> point);
+
+  int EC_POINT_get_affine_coordinates_GFp(
+    ffi.Pointer<EC_GROUP> group,
+    ffi.Pointer<EC_POINT> point,
+    ffi.Pointer<BIGNUM> x,
+    ffi.Pointer<BIGNUM> y,
+    ffi.Pointer<BN_CTX> ctx,
+  ) {
+    return _native_EC_POINT_get_affine_coordinates_GFp(group, point, x, y, ctx);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<EC_GROUP>,
+      ffi.Pointer<EC_POINT>,
+      ffi.Pointer<BIGNUM>,
+      ffi.Pointer<BIGNUM>,
+      ffi.Pointer<BN_CTX>,
+    )
+  >(symbol: 'webcrypto_EC_POINT_get_affine_coordinates_GFp', assetId: _assetId)
+  external static int _native_EC_POINT_get_affine_coordinates_GFp(
+    ffi.Pointer<EC_GROUP> group,
+    ffi.Pointer<EC_POINT> point,
+    ffi.Pointer<BIGNUM> x,
+    ffi.Pointer<BIGNUM> y,
+    ffi.Pointer<BN_CTX> ctx,
+  );
+
+  ffi.Pointer<EC_POINT> EC_POINT_new(ffi.Pointer<EC_GROUP> group) {
+    return _native_EC_POINT_new(group);
+  }
+
+  @ffi.Native<ffi.Pointer<EC_POINT> Function(ffi.Pointer<EC_GROUP>)>(
+    symbol: 'webcrypto_EC_POINT_new',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<EC_POINT> _native_EC_POINT_new(
+    ffi.Pointer<EC_GROUP> group,
+  );
+
+  int EC_POINT_oct2point(
+    ffi.Pointer<EC_GROUP> group,
+    ffi.Pointer<EC_POINT> point,
+    ffi.Pointer<ffi.Uint8> buf,
+    int len,
+    ffi.Pointer<BN_CTX> ctx,
+  ) {
+    return _native_EC_POINT_oct2point(group, point, buf, len, ctx);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<EC_GROUP>,
+      ffi.Pointer<EC_POINT>,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Size,
+      ffi.Pointer<BN_CTX>,
+    )
+  >(symbol: 'webcrypto_EC_POINT_oct2point', assetId: _assetId)
+  external static int _native_EC_POINT_oct2point(
+    ffi.Pointer<EC_GROUP> group,
+    ffi.Pointer<EC_POINT> point,
+    ffi.Pointer<ffi.Uint8> buf,
+    int len,
+    ffi.Pointer<BN_CTX> ctx,
+  );
+
+  int EC_POINT_point2cbb(
+    ffi.Pointer<CBB> out,
+    ffi.Pointer<EC_GROUP> group,
+    ffi.Pointer<EC_POINT> point,
+    int form,
+    ffi.Pointer<BN_CTX> ctx,
+  ) {
+    return _native_EC_POINT_point2cbb(out, group, point, form, ctx);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<CBB>,
+      ffi.Pointer<EC_GROUP>,
+      ffi.Pointer<EC_POINT>,
+      ffi.Int32,
+      ffi.Pointer<BN_CTX>,
+    )
+  >(symbol: 'webcrypto_EC_POINT_point2cbb', assetId: _assetId)
+  external static int _native_EC_POINT_point2cbb(
+    ffi.Pointer<CBB> out,
+    ffi.Pointer<EC_GROUP> group,
+    ffi.Pointer<EC_POINT> point,
+    int form,
+    ffi.Pointer<BN_CTX> ctx,
+  );
+
+  void ERR_clear_error() {
+    return _native_ERR_clear_error();
+  }
+
+  @ffi.Native<ffi.Void Function()>(
+    symbol: 'webcrypto_ERR_clear_error',
+    assetId: _assetId,
+  )
+  external static void _native_ERR_clear_error();
+
+  ffi.Pointer<ffi.Char> ERR_error_string_n(
+    int packed_error,
+    ffi.Pointer<ffi.Char> buf,
+    int len,
+  ) {
+    return _native_ERR_error_string_n(packed_error, buf, len);
+  }
+
+  @ffi.Native<
+    ffi.Pointer<ffi.Char> Function(ffi.Uint32, ffi.Pointer<ffi.Char>, ffi.Size)
+  >(symbol: 'webcrypto_ERR_error_string_n', assetId: _assetId)
+  external static ffi.Pointer<ffi.Char> _native_ERR_error_string_n(
+    int packed_error,
+    ffi.Pointer<ffi.Char> buf,
+    int len,
+  );
+
+  int ERR_get_error() {
+    return _native_ERR_get_error();
+  }
+
+  @ffi.Native<ffi.Uint32 Function()>(
+    symbol: 'webcrypto_ERR_get_error',
+    assetId: _assetId,
+  )
+  external static int _native_ERR_get_error();
+
+  int ERR_peek_error() {
+    return _native_ERR_peek_error();
+  }
+
+  @ffi.Native<ffi.Uint32 Function()>(
+    symbol: 'webcrypto_ERR_peek_error',
+    assetId: _assetId,
+  )
+  external static int _native_ERR_peek_error();
+
+  ffi.Pointer<EVP_AEAD> EVP_aead_aes_128_gcm() {
+    return _native_EVP_aead_aes_128_gcm();
+  }
+
+  @ffi.Native<ffi.Pointer<EVP_AEAD> Function()>(
+    symbol: 'webcrypto_EVP_aead_aes_128_gcm',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<EVP_AEAD> _native_EVP_aead_aes_128_gcm();
+
+  ffi.Pointer<EVP_AEAD> EVP_aead_aes_256_gcm() {
+    return _native_EVP_aead_aes_256_gcm();
+  }
+
+  @ffi.Native<ffi.Pointer<EVP_AEAD> Function()>(
+    symbol: 'webcrypto_EVP_aead_aes_256_gcm',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<EVP_AEAD> _native_EVP_aead_aes_256_gcm();
+
+  void EVP_AEAD_CTX_free(ffi.Pointer<EVP_AEAD_CTX> ctx) {
+    return _native_EVP_AEAD_CTX_free(ctx);
+  }
+
+  @ffi.Native<ffi.Void Function(ffi.Pointer<EVP_AEAD_CTX>)>(
+    symbol: 'webcrypto_EVP_AEAD_CTX_free',
+    assetId: _assetId,
+  )
+  external static void _native_EVP_AEAD_CTX_free(ffi.Pointer<EVP_AEAD_CTX> ctx);
+
+  ffi.Pointer<EVP_AEAD_CTX> EVP_AEAD_CTX_new(
+    ffi.Pointer<EVP_AEAD> aead,
+    ffi.Pointer<ffi.Uint8> key,
+    int key_len,
+    int tag_len,
+  ) {
+    return _native_EVP_AEAD_CTX_new(aead, key, key_len, tag_len);
+  }
+
+  @ffi.Native<
+    ffi.Pointer<EVP_AEAD_CTX> Function(
+      ffi.Pointer<EVP_AEAD>,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Size,
+      ffi.Size,
+    )
+  >(symbol: 'webcrypto_EVP_AEAD_CTX_new', assetId: _assetId)
+  external static ffi.Pointer<EVP_AEAD_CTX> _native_EVP_AEAD_CTX_new(
+    ffi.Pointer<EVP_AEAD> aead,
+    ffi.Pointer<ffi.Uint8> key,
+    int key_len,
+    int tag_len,
+  );
+
+  int EVP_AEAD_CTX_open(
+    ffi.Pointer<EVP_AEAD_CTX> ctx,
+    ffi.Pointer<ffi.Uint8> out,
+    ffi.Pointer<ffi.Size> out_len,
+    int max_out_len,
+    ffi.Pointer<ffi.Uint8> nonce,
+    int nonce_len,
+    ffi.Pointer<ffi.Uint8> in1,
+    int in_len,
+    ffi.Pointer<ffi.Uint8> ad,
+    int ad_len,
+  ) {
+    return _native_EVP_AEAD_CTX_open(
+      ctx,
+      out,
+      out_len,
+      max_out_len,
+      nonce,
+      nonce_len,
+      in1,
+      in_len,
+      ad,
+      ad_len,
+    );
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<EVP_AEAD_CTX>,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Pointer<ffi.Size>,
+      ffi.Size,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Size,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Size,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Size,
+    )
+  >(symbol: 'webcrypto_EVP_AEAD_CTX_open', assetId: _assetId)
+  external static int _native_EVP_AEAD_CTX_open(
+    ffi.Pointer<EVP_AEAD_CTX> ctx,
+    ffi.Pointer<ffi.Uint8> out,
+    ffi.Pointer<ffi.Size> out_len,
+    int max_out_len,
+    ffi.Pointer<ffi.Uint8> nonce,
+    int nonce_len,
+    ffi.Pointer<ffi.Uint8> in1,
+    int in_len,
+    ffi.Pointer<ffi.Uint8> ad,
+    int ad_len,
+  );
+
+  int EVP_AEAD_CTX_seal(
+    ffi.Pointer<EVP_AEAD_CTX> ctx,
+    ffi.Pointer<ffi.Uint8> out,
+    ffi.Pointer<ffi.Size> out_len,
+    int max_out_len,
+    ffi.Pointer<ffi.Uint8> nonce,
+    int nonce_len,
+    ffi.Pointer<ffi.Uint8> in1,
+    int in_len,
+    ffi.Pointer<ffi.Uint8> ad,
+    int ad_len,
+  ) {
+    return _native_EVP_AEAD_CTX_seal(
+      ctx,
+      out,
+      out_len,
+      max_out_len,
+      nonce,
+      nonce_len,
+      in1,
+      in_len,
+      ad,
+      ad_len,
+    );
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<EVP_AEAD_CTX>,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Pointer<ffi.Size>,
+      ffi.Size,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Size,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Size,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Size,
+    )
+  >(symbol: 'webcrypto_EVP_AEAD_CTX_seal', assetId: _assetId)
+  external static int _native_EVP_AEAD_CTX_seal(
+    ffi.Pointer<EVP_AEAD_CTX> ctx,
+    ffi.Pointer<ffi.Uint8> out,
+    ffi.Pointer<ffi.Size> out_len,
+    int max_out_len,
+    ffi.Pointer<ffi.Uint8> nonce,
+    int nonce_len,
+    ffi.Pointer<ffi.Uint8> in1,
+    int in_len,
+    ffi.Pointer<ffi.Uint8> ad,
+    int ad_len,
+  );
+
+  int EVP_AEAD_max_overhead(ffi.Pointer<EVP_AEAD> aead) {
+    return _native_EVP_AEAD_max_overhead(aead);
+  }
+
+  @ffi.Native<ffi.Size Function(ffi.Pointer<EVP_AEAD>)>(
+    symbol: 'webcrypto_EVP_AEAD_max_overhead',
+    assetId: _assetId,
+  )
+  external static int _native_EVP_AEAD_max_overhead(ffi.Pointer<EVP_AEAD> aead);
+
+  ffi.Pointer<EVP_CIPHER> EVP_aes_128_cbc() {
+    return _native_EVP_aes_128_cbc();
+  }
+
+  @ffi.Native<ffi.Pointer<EVP_CIPHER> Function()>(
+    symbol: 'webcrypto_EVP_aes_128_cbc',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<EVP_CIPHER> _native_EVP_aes_128_cbc();
+
+  ffi.Pointer<EVP_CIPHER> EVP_aes_128_ctr() {
+    return _native_EVP_aes_128_ctr();
+  }
+
+  @ffi.Native<ffi.Pointer<EVP_CIPHER> Function()>(
+    symbol: 'webcrypto_EVP_aes_128_ctr',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<EVP_CIPHER> _native_EVP_aes_128_ctr();
+
+  ffi.Pointer<EVP_CIPHER> EVP_aes_256_cbc() {
+    return _native_EVP_aes_256_cbc();
+  }
+
+  @ffi.Native<ffi.Pointer<EVP_CIPHER> Function()>(
+    symbol: 'webcrypto_EVP_aes_256_cbc',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<EVP_CIPHER> _native_EVP_aes_256_cbc();
+
+  ffi.Pointer<EVP_CIPHER> EVP_aes_256_ctr() {
+    return _native_EVP_aes_256_ctr();
+  }
+
+  @ffi.Native<ffi.Pointer<EVP_CIPHER> Function()>(
+    symbol: 'webcrypto_EVP_aes_256_ctr',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<EVP_CIPHER> _native_EVP_aes_256_ctr();
+
+  void EVP_CIPHER_CTX_free(ffi.Pointer<EVP_CIPHER_CTX> ctx) {
+    return _native_EVP_CIPHER_CTX_free(ctx);
+  }
+
+  @ffi.Native<ffi.Void Function(ffi.Pointer<EVP_CIPHER_CTX>)>(
+    symbol: 'webcrypto_EVP_CIPHER_CTX_free',
+    assetId: _assetId,
+  )
+  external static void _native_EVP_CIPHER_CTX_free(
+    ffi.Pointer<EVP_CIPHER_CTX> ctx,
+  );
+
+  ffi.Pointer<EVP_CIPHER_CTX> EVP_CIPHER_CTX_new() {
+    return _native_EVP_CIPHER_CTX_new();
+  }
+
+  @ffi.Native<ffi.Pointer<EVP_CIPHER_CTX> Function()>(
+    symbol: 'webcrypto_EVP_CIPHER_CTX_new',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<EVP_CIPHER_CTX> _native_EVP_CIPHER_CTX_new();
+
+  int EVP_CipherFinal_ex(
+    ffi.Pointer<EVP_CIPHER_CTX> ctx,
+    ffi.Pointer<ffi.Uint8> out,
+    ffi.Pointer<ffi.Int> out_len,
+  ) {
+    return _native_EVP_CipherFinal_ex(ctx, out, out_len);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<EVP_CIPHER_CTX>,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Pointer<ffi.Int>,
+    )
+  >(symbol: 'webcrypto_EVP_CipherFinal_ex', assetId: _assetId)
+  external static int _native_EVP_CipherFinal_ex(
+    ffi.Pointer<EVP_CIPHER_CTX> ctx,
+    ffi.Pointer<ffi.Uint8> out,
+    ffi.Pointer<ffi.Int> out_len,
+  );
+
+  int EVP_CipherInit_ex(
+    ffi.Pointer<EVP_CIPHER_CTX> ctx,
+    ffi.Pointer<EVP_CIPHER> cipher,
+    ffi.Pointer<ENGINE> engine,
+    ffi.Pointer<ffi.Uint8> key,
+    ffi.Pointer<ffi.Uint8> iv,
+    int enc,
+  ) {
+    return _native_EVP_CipherInit_ex(ctx, cipher, engine, key, iv, enc);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<EVP_CIPHER_CTX>,
+      ffi.Pointer<EVP_CIPHER>,
+      ffi.Pointer<ENGINE>,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Int,
+    )
+  >(symbol: 'webcrypto_EVP_CipherInit_ex', assetId: _assetId)
+  external static int _native_EVP_CipherInit_ex(
+    ffi.Pointer<EVP_CIPHER_CTX> ctx,
+    ffi.Pointer<EVP_CIPHER> cipher,
+    ffi.Pointer<ENGINE> engine,
+    ffi.Pointer<ffi.Uint8> key,
+    ffi.Pointer<ffi.Uint8> iv,
+    int enc,
+  );
+
+  int EVP_CIPHER_iv_length(ffi.Pointer<EVP_CIPHER> cipher) {
+    return _native_EVP_CIPHER_iv_length(cipher);
+  }
+
+  @ffi.Native<ffi.UnsignedInt Function(ffi.Pointer<EVP_CIPHER>)>(
+    symbol: 'webcrypto_EVP_CIPHER_iv_length',
+    assetId: _assetId,
+  )
+  external static int _native_EVP_CIPHER_iv_length(
+    ffi.Pointer<EVP_CIPHER> cipher,
+  );
+
+  int EVP_CipherUpdate(
+    ffi.Pointer<EVP_CIPHER_CTX> ctx,
+    ffi.Pointer<ffi.Uint8> out,
+    ffi.Pointer<ffi.Int> out_len,
+    ffi.Pointer<ffi.Uint8> in1,
+    int in_len,
+  ) {
+    return _native_EVP_CipherUpdate(ctx, out, out_len, in1, in_len);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<EVP_CIPHER_CTX>,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Pointer<ffi.Int>,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Int,
+    )
+  >(symbol: 'webcrypto_EVP_CipherUpdate', assetId: _assetId)
+  external static int _native_EVP_CipherUpdate(
+    ffi.Pointer<EVP_CIPHER_CTX> ctx,
+    ffi.Pointer<ffi.Uint8> out,
+    ffi.Pointer<ffi.Int> out_len,
+    ffi.Pointer<ffi.Uint8> in1,
+    int in_len,
+  );
+
+  int EVP_DigestFinal(
+    ffi.Pointer<EVP_MD_CTX> ctx,
+    ffi.Pointer<ffi.Uint8> md_out,
+    ffi.Pointer<ffi.UnsignedInt> out_size,
+  ) {
+    return _native_EVP_DigestFinal(ctx, md_out, out_size);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<EVP_MD_CTX>,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Pointer<ffi.UnsignedInt>,
+    )
+  >(symbol: 'webcrypto_EVP_DigestFinal', assetId: _assetId)
+  external static int _native_EVP_DigestFinal(
+    ffi.Pointer<EVP_MD_CTX> ctx,
+    ffi.Pointer<ffi.Uint8> md_out,
+    ffi.Pointer<ffi.UnsignedInt> out_size,
+  );
+
+  int EVP_DigestInit(ffi.Pointer<EVP_MD_CTX> ctx, ffi.Pointer<EVP_MD> type) {
+    return _native_EVP_DigestInit(ctx, type);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<EVP_MD_CTX>, ffi.Pointer<EVP_MD>)>(
+    symbol: 'webcrypto_EVP_DigestInit',
+    assetId: _assetId,
+  )
+  external static int _native_EVP_DigestInit(
+    ffi.Pointer<EVP_MD_CTX> ctx,
+    ffi.Pointer<EVP_MD> type,
+  );
+
+  int EVP_DigestSignFinal(
+    ffi.Pointer<EVP_MD_CTX> ctx,
+    ffi.Pointer<ffi.Uint8> out_sig,
+    ffi.Pointer<ffi.Size> out_sig_len,
+  ) {
+    return _native_EVP_DigestSignFinal(ctx, out_sig, out_sig_len);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<EVP_MD_CTX>,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Pointer<ffi.Size>,
+    )
+  >(symbol: 'webcrypto_EVP_DigestSignFinal', assetId: _assetId)
+  external static int _native_EVP_DigestSignFinal(
+    ffi.Pointer<EVP_MD_CTX> ctx,
+    ffi.Pointer<ffi.Uint8> out_sig,
+    ffi.Pointer<ffi.Size> out_sig_len,
+  );
+
+  int EVP_DigestSignInit(
+    ffi.Pointer<EVP_MD_CTX> ctx,
+    ffi.Pointer<ffi.Pointer<EVP_PKEY_CTX>> pctx,
+    ffi.Pointer<EVP_MD> type,
+    ffi.Pointer<ENGINE> e,
+    ffi.Pointer<EVP_PKEY> pkey,
+  ) {
+    return _native_EVP_DigestSignInit(ctx, pctx, type, e, pkey);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<EVP_MD_CTX>,
+      ffi.Pointer<ffi.Pointer<EVP_PKEY_CTX>>,
+      ffi.Pointer<EVP_MD>,
+      ffi.Pointer<ENGINE>,
+      ffi.Pointer<EVP_PKEY>,
+    )
+  >(symbol: 'webcrypto_EVP_DigestSignInit', assetId: _assetId)
+  external static int _native_EVP_DigestSignInit(
+    ffi.Pointer<EVP_MD_CTX> ctx,
+    ffi.Pointer<ffi.Pointer<EVP_PKEY_CTX>> pctx,
+    ffi.Pointer<EVP_MD> type,
+    ffi.Pointer<ENGINE> e,
+    ffi.Pointer<EVP_PKEY> pkey,
+  );
+
+  int EVP_DigestSignUpdate(
+    ffi.Pointer<EVP_MD_CTX> ctx,
+    ffi.Pointer<ffi.Void> data,
+    int len,
+  ) {
+    return _native_EVP_DigestSignUpdate(ctx, data, len);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(ffi.Pointer<EVP_MD_CTX>, ffi.Pointer<ffi.Void>, ffi.Size)
+  >(symbol: 'webcrypto_EVP_DigestSignUpdate', assetId: _assetId)
+  external static int _native_EVP_DigestSignUpdate(
+    ffi.Pointer<EVP_MD_CTX> ctx,
+    ffi.Pointer<ffi.Void> data,
+    int len,
+  );
+
+  int EVP_DigestUpdate(
+    ffi.Pointer<EVP_MD_CTX> ctx,
+    ffi.Pointer<ffi.Void> data,
+    int len,
+  ) {
+    return _native_EVP_DigestUpdate(ctx, data, len);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(ffi.Pointer<EVP_MD_CTX>, ffi.Pointer<ffi.Void>, ffi.Size)
+  >(symbol: 'webcrypto_EVP_DigestUpdate', assetId: _assetId)
+  external static int _native_EVP_DigestUpdate(
+    ffi.Pointer<EVP_MD_CTX> ctx,
+    ffi.Pointer<ffi.Void> data,
+    int len,
+  );
+
+  int EVP_DigestVerifyFinal(
+    ffi.Pointer<EVP_MD_CTX> ctx,
+    ffi.Pointer<ffi.Uint8> sig,
+    int sig_len,
+  ) {
+    return _native_EVP_DigestVerifyFinal(ctx, sig, sig_len);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(ffi.Pointer<EVP_MD_CTX>, ffi.Pointer<ffi.Uint8>, ffi.Size)
+  >(symbol: 'webcrypto_EVP_DigestVerifyFinal', assetId: _assetId)
+  external static int _native_EVP_DigestVerifyFinal(
+    ffi.Pointer<EVP_MD_CTX> ctx,
+    ffi.Pointer<ffi.Uint8> sig,
+    int sig_len,
+  );
+
+  int EVP_DigestVerifyInit(
+    ffi.Pointer<EVP_MD_CTX> ctx,
+    ffi.Pointer<ffi.Pointer<EVP_PKEY_CTX>> pctx,
+    ffi.Pointer<EVP_MD> type,
+    ffi.Pointer<ENGINE> e,
+    ffi.Pointer<EVP_PKEY> pkey,
+  ) {
+    return _native_EVP_DigestVerifyInit(ctx, pctx, type, e, pkey);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<EVP_MD_CTX>,
+      ffi.Pointer<ffi.Pointer<EVP_PKEY_CTX>>,
+      ffi.Pointer<EVP_MD>,
+      ffi.Pointer<ENGINE>,
+      ffi.Pointer<EVP_PKEY>,
+    )
+  >(symbol: 'webcrypto_EVP_DigestVerifyInit', assetId: _assetId)
+  external static int _native_EVP_DigestVerifyInit(
+    ffi.Pointer<EVP_MD_CTX> ctx,
+    ffi.Pointer<ffi.Pointer<EVP_PKEY_CTX>> pctx,
+    ffi.Pointer<EVP_MD> type,
+    ffi.Pointer<ENGINE> e,
+    ffi.Pointer<EVP_PKEY> pkey,
+  );
+
+  int EVP_DigestVerifyUpdate(
+    ffi.Pointer<EVP_MD_CTX> ctx,
+    ffi.Pointer<ffi.Void> data,
+    int len,
+  ) {
+    return _native_EVP_DigestVerifyUpdate(ctx, data, len);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(ffi.Pointer<EVP_MD_CTX>, ffi.Pointer<ffi.Void>, ffi.Size)
+  >(symbol: 'webcrypto_EVP_DigestVerifyUpdate', assetId: _assetId)
+  external static int _native_EVP_DigestVerifyUpdate(
+    ffi.Pointer<EVP_MD_CTX> ctx,
+    ffi.Pointer<ffi.Void> data,
+    int len,
+  );
+
+  int EVP_marshal_private_key(ffi.Pointer<CBB> cbb, ffi.Pointer<EVP_PKEY> key) {
+    return _native_EVP_marshal_private_key(cbb, key);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<CBB>, ffi.Pointer<EVP_PKEY>)>(
+    symbol: 'webcrypto_EVP_marshal_private_key',
+    assetId: _assetId,
+  )
+  external static int _native_EVP_marshal_private_key(
+    ffi.Pointer<CBB> cbb,
+    ffi.Pointer<EVP_PKEY> key,
+  );
+
+  int EVP_marshal_public_key(ffi.Pointer<CBB> cbb, ffi.Pointer<EVP_PKEY> key) {
+    return _native_EVP_marshal_public_key(cbb, key);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<CBB>, ffi.Pointer<EVP_PKEY>)>(
+    symbol: 'webcrypto_EVP_marshal_public_key',
+    assetId: _assetId,
+  )
+  external static int _native_EVP_marshal_public_key(
+    ffi.Pointer<CBB> cbb,
+    ffi.Pointer<EVP_PKEY> key,
+  );
+
+  void EVP_MD_CTX_free(ffi.Pointer<EVP_MD_CTX> ctx) {
+    return _native_EVP_MD_CTX_free(ctx);
+  }
+
+  @ffi.Native<ffi.Void Function(ffi.Pointer<EVP_MD_CTX>)>(
+    symbol: 'webcrypto_EVP_MD_CTX_free',
+    assetId: _assetId,
+  )
+  external static void _native_EVP_MD_CTX_free(ffi.Pointer<EVP_MD_CTX> ctx);
+
+  ffi.Pointer<EVP_MD_CTX> EVP_MD_CTX_new() {
+    return _native_EVP_MD_CTX_new();
+  }
+
+  @ffi.Native<ffi.Pointer<EVP_MD_CTX> Function()>(
+    symbol: 'webcrypto_EVP_MD_CTX_new',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<EVP_MD_CTX> _native_EVP_MD_CTX_new();
+
+  int EVP_MD_CTX_size(ffi.Pointer<EVP_MD_CTX> ctx) {
+    return _native_EVP_MD_CTX_size(ctx);
+  }
+
+  @ffi.Native<ffi.Size Function(ffi.Pointer<EVP_MD_CTX>)>(
+    symbol: 'webcrypto_EVP_MD_CTX_size',
+    assetId: _assetId,
+  )
+  external static int _native_EVP_MD_CTX_size(ffi.Pointer<EVP_MD_CTX> ctx);
+
+  ffi.Pointer<EVP_PKEY> EVP_parse_private_key(ffi.Pointer<CBS> cbs) {
+    return _native_EVP_parse_private_key(cbs);
+  }
+
+  @ffi.Native<ffi.Pointer<EVP_PKEY> Function(ffi.Pointer<CBS>)>(
+    symbol: 'webcrypto_EVP_parse_private_key',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<EVP_PKEY> _native_EVP_parse_private_key(
+    ffi.Pointer<CBS> cbs,
+  );
+
+  ffi.Pointer<EVP_PKEY> EVP_parse_public_key(ffi.Pointer<CBS> cbs) {
+    return _native_EVP_parse_public_key(cbs);
+  }
+
+  @ffi.Native<ffi.Pointer<EVP_PKEY> Function(ffi.Pointer<CBS>)>(
+    symbol: 'webcrypto_EVP_parse_public_key',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<EVP_PKEY> _native_EVP_parse_public_key(
+    ffi.Pointer<CBS> cbs,
+  );
+
+  void EVP_PKEY_CTX_free(ffi.Pointer<EVP_PKEY_CTX> ctx) {
+    return _native_EVP_PKEY_CTX_free(ctx);
+  }
+
+  @ffi.Native<ffi.Void Function(ffi.Pointer<EVP_PKEY_CTX>)>(
+    symbol: 'webcrypto_EVP_PKEY_CTX_free',
+    assetId: _assetId,
+  )
+  external static void _native_EVP_PKEY_CTX_free(ffi.Pointer<EVP_PKEY_CTX> ctx);
+
+  ffi.Pointer<EVP_PKEY_CTX> EVP_PKEY_CTX_new(
+    ffi.Pointer<EVP_PKEY> pkey,
+    ffi.Pointer<ENGINE> e,
+  ) {
+    return _native_EVP_PKEY_CTX_new(pkey, e);
+  }
+
+  @ffi.Native<
+    ffi.Pointer<EVP_PKEY_CTX> Function(
+      ffi.Pointer<EVP_PKEY>,
+      ffi.Pointer<ENGINE>,
+    )
+  >(symbol: 'webcrypto_EVP_PKEY_CTX_new', assetId: _assetId)
+  external static ffi.Pointer<EVP_PKEY_CTX> _native_EVP_PKEY_CTX_new(
+    ffi.Pointer<EVP_PKEY> pkey,
+    ffi.Pointer<ENGINE> e,
+  );
+
+  int EVP_PKEY_CTX_set0_rsa_oaep_label(
+    ffi.Pointer<EVP_PKEY_CTX> ctx,
+    ffi.Pointer<ffi.Uint8> label,
+    int label_len,
+  ) {
+    return _native_EVP_PKEY_CTX_set0_rsa_oaep_label(ctx, label, label_len);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<EVP_PKEY_CTX>,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Size,
+    )
+  >(symbol: 'webcrypto_EVP_PKEY_CTX_set0_rsa_oaep_label', assetId: _assetId)
+  external static int _native_EVP_PKEY_CTX_set0_rsa_oaep_label(
+    ffi.Pointer<EVP_PKEY_CTX> ctx,
+    ffi.Pointer<ffi.Uint8> label,
+    int label_len,
+  );
+
+  int EVP_PKEY_CTX_set_rsa_mgf1_md(
+    ffi.Pointer<EVP_PKEY_CTX> ctx,
+    ffi.Pointer<EVP_MD> md,
+  ) {
+    return _native_EVP_PKEY_CTX_set_rsa_mgf1_md(ctx, md);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<EVP_PKEY_CTX>, ffi.Pointer<EVP_MD>)>(
+    symbol: 'webcrypto_EVP_PKEY_CTX_set_rsa_mgf1_md',
+    assetId: _assetId,
+  )
+  external static int _native_EVP_PKEY_CTX_set_rsa_mgf1_md(
+    ffi.Pointer<EVP_PKEY_CTX> ctx,
+    ffi.Pointer<EVP_MD> md,
+  );
+
+  int EVP_PKEY_CTX_set_rsa_oaep_md(
+    ffi.Pointer<EVP_PKEY_CTX> ctx,
+    ffi.Pointer<EVP_MD> md,
+  ) {
+    return _native_EVP_PKEY_CTX_set_rsa_oaep_md(ctx, md);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<EVP_PKEY_CTX>, ffi.Pointer<EVP_MD>)>(
+    symbol: 'webcrypto_EVP_PKEY_CTX_set_rsa_oaep_md',
+    assetId: _assetId,
+  )
+  external static int _native_EVP_PKEY_CTX_set_rsa_oaep_md(
+    ffi.Pointer<EVP_PKEY_CTX> ctx,
+    ffi.Pointer<EVP_MD> md,
+  );
+
+  int EVP_PKEY_CTX_set_rsa_padding(ffi.Pointer<EVP_PKEY_CTX> ctx, int padding) {
+    return _native_EVP_PKEY_CTX_set_rsa_padding(ctx, padding);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<EVP_PKEY_CTX>, ffi.Int)>(
+    symbol: 'webcrypto_EVP_PKEY_CTX_set_rsa_padding',
+    assetId: _assetId,
+  )
+  external static int _native_EVP_PKEY_CTX_set_rsa_padding(
+    ffi.Pointer<EVP_PKEY_CTX> ctx,
+    int padding,
+  );
+
+  int EVP_PKEY_CTX_set_rsa_pss_saltlen(
+    ffi.Pointer<EVP_PKEY_CTX> ctx,
+    int salt_len,
+  ) {
+    return _native_EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, salt_len);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<EVP_PKEY_CTX>, ffi.Int)>(
+    symbol: 'webcrypto_EVP_PKEY_CTX_set_rsa_pss_saltlen',
+    assetId: _assetId,
+  )
+  external static int _native_EVP_PKEY_CTX_set_rsa_pss_saltlen(
+    ffi.Pointer<EVP_PKEY_CTX> ctx,
+    int salt_len,
+  );
+
+  int EVP_PKEY_decrypt(
+    ffi.Pointer<EVP_PKEY_CTX> ctx,
+    ffi.Pointer<ffi.Uint8> out,
+    ffi.Pointer<ffi.Size> out_len,
+    ffi.Pointer<ffi.Uint8> in1,
+    int in_len,
+  ) {
+    return _native_EVP_PKEY_decrypt(ctx, out, out_len, in1, in_len);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<EVP_PKEY_CTX>,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Pointer<ffi.Size>,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Size,
+    )
+  >(symbol: 'webcrypto_EVP_PKEY_decrypt', assetId: _assetId)
+  external static int _native_EVP_PKEY_decrypt(
+    ffi.Pointer<EVP_PKEY_CTX> ctx,
+    ffi.Pointer<ffi.Uint8> out,
+    ffi.Pointer<ffi.Size> out_len,
+    ffi.Pointer<ffi.Uint8> in1,
+    int in_len,
+  );
+
+  int EVP_PKEY_decrypt_init(ffi.Pointer<EVP_PKEY_CTX> ctx) {
+    return _native_EVP_PKEY_decrypt_init(ctx);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<EVP_PKEY_CTX>)>(
+    symbol: 'webcrypto_EVP_PKEY_decrypt_init',
+    assetId: _assetId,
+  )
+  external static int _native_EVP_PKEY_decrypt_init(
+    ffi.Pointer<EVP_PKEY_CTX> ctx,
+  );
+
+  int EVP_PKEY_encrypt(
+    ffi.Pointer<EVP_PKEY_CTX> ctx,
+    ffi.Pointer<ffi.Uint8> out,
+    ffi.Pointer<ffi.Size> out_len,
+    ffi.Pointer<ffi.Uint8> in1,
+    int in_len,
+  ) {
+    return _native_EVP_PKEY_encrypt(ctx, out, out_len, in1, in_len);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<EVP_PKEY_CTX>,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Pointer<ffi.Size>,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Size,
+    )
+  >(symbol: 'webcrypto_EVP_PKEY_encrypt', assetId: _assetId)
+  external static int _native_EVP_PKEY_encrypt(
+    ffi.Pointer<EVP_PKEY_CTX> ctx,
+    ffi.Pointer<ffi.Uint8> out,
+    ffi.Pointer<ffi.Size> out_len,
+    ffi.Pointer<ffi.Uint8> in1,
+    int in_len,
+  );
+
+  int EVP_PKEY_encrypt_init(ffi.Pointer<EVP_PKEY_CTX> ctx) {
+    return _native_EVP_PKEY_encrypt_init(ctx);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<EVP_PKEY_CTX>)>(
+    symbol: 'webcrypto_EVP_PKEY_encrypt_init',
+    assetId: _assetId,
+  )
+  external static int _native_EVP_PKEY_encrypt_init(
+    ffi.Pointer<EVP_PKEY_CTX> ctx,
+  );
+
+  void EVP_PKEY_free(ffi.Pointer<EVP_PKEY> pkey) {
+    return _native_EVP_PKEY_free(pkey);
+  }
+
+  @ffi.Native<ffi.Void Function(ffi.Pointer<EVP_PKEY>)>(
+    symbol: 'webcrypto_EVP_PKEY_free',
+    assetId: _assetId,
+  )
+  external static void _native_EVP_PKEY_free(ffi.Pointer<EVP_PKEY> pkey);
+
+  ffi.Pointer<EC_KEY> EVP_PKEY_get1_EC_KEY(ffi.Pointer<EVP_PKEY> pkey) {
+    return _native_EVP_PKEY_get1_EC_KEY(pkey);
+  }
+
+  @ffi.Native<ffi.Pointer<EC_KEY> Function(ffi.Pointer<EVP_PKEY>)>(
+    symbol: 'webcrypto_EVP_PKEY_get1_EC_KEY',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<EC_KEY> _native_EVP_PKEY_get1_EC_KEY(
+    ffi.Pointer<EVP_PKEY> pkey,
+  );
+
+  ffi.Pointer<RSA> EVP_PKEY_get1_RSA(ffi.Pointer<EVP_PKEY> pkey) {
+    return _native_EVP_PKEY_get1_RSA(pkey);
+  }
+
+  @ffi.Native<ffi.Pointer<RSA> Function(ffi.Pointer<EVP_PKEY>)>(
+    symbol: 'webcrypto_EVP_PKEY_get1_RSA',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<RSA> _native_EVP_PKEY_get1_RSA(
+    ffi.Pointer<EVP_PKEY> pkey,
+  );
+
+  int EVP_PKEY_id(ffi.Pointer<EVP_PKEY> pkey) {
+    return _native_EVP_PKEY_id(pkey);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<EVP_PKEY>)>(
+    symbol: 'webcrypto_EVP_PKEY_id',
+    assetId: _assetId,
+  )
+  external static int _native_EVP_PKEY_id(ffi.Pointer<EVP_PKEY> pkey);
+
+  ffi.Pointer<EVP_PKEY> EVP_PKEY_new() {
+    return _native_EVP_PKEY_new();
+  }
+
+  @ffi.Native<ffi.Pointer<EVP_PKEY> Function()>(
+    symbol: 'webcrypto_EVP_PKEY_new',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<EVP_PKEY> _native_EVP_PKEY_new();
+
+  int EVP_PKEY_set1_EC_KEY(
+    ffi.Pointer<EVP_PKEY> pkey,
+    ffi.Pointer<EC_KEY> key,
+  ) {
+    return _native_EVP_PKEY_set1_EC_KEY(pkey, key);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<EVP_PKEY>, ffi.Pointer<EC_KEY>)>(
+    symbol: 'webcrypto_EVP_PKEY_set1_EC_KEY',
+    assetId: _assetId,
+  )
+  external static int _native_EVP_PKEY_set1_EC_KEY(
+    ffi.Pointer<EVP_PKEY> pkey,
+    ffi.Pointer<EC_KEY> key,
+  );
+
+  int EVP_PKEY_set1_RSA(ffi.Pointer<EVP_PKEY> pkey, ffi.Pointer<RSA> key) {
+    return _native_EVP_PKEY_set1_RSA(pkey, key);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<EVP_PKEY>, ffi.Pointer<RSA>)>(
+    symbol: 'webcrypto_EVP_PKEY_set1_RSA',
+    assetId: _assetId,
+  )
+  external static int _native_EVP_PKEY_set1_RSA(
+    ffi.Pointer<EVP_PKEY> pkey,
+    ffi.Pointer<RSA> key,
+  );
+
+  ffi.Pointer<EVP_MD> EVP_sha1() {
+    return _native_EVP_sha1();
+  }
+
+  @ffi.Native<ffi.Pointer<EVP_MD> Function()>(
+    symbol: 'webcrypto_EVP_sha1',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<EVP_MD> _native_EVP_sha1();
+
+  ffi.Pointer<EVP_MD> EVP_sha256() {
+    return _native_EVP_sha256();
+  }
+
+  @ffi.Native<ffi.Pointer<EVP_MD> Function()>(
+    symbol: 'webcrypto_EVP_sha256',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<EVP_MD> _native_EVP_sha256();
+
+  ffi.Pointer<EVP_MD> EVP_sha384() {
+    return _native_EVP_sha384();
+  }
+
+  @ffi.Native<ffi.Pointer<EVP_MD> Function()>(
+    symbol: 'webcrypto_EVP_sha384',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<EVP_MD> _native_EVP_sha384();
+
+  ffi.Pointer<EVP_MD> EVP_sha512() {
+    return _native_EVP_sha512();
+  }
+
+  @ffi.Native<ffi.Pointer<EVP_MD> Function()>(
+    symbol: 'webcrypto_EVP_sha512',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<EVP_MD> _native_EVP_sha512();
+
+  int HKDF(
+    ffi.Pointer<ffi.Uint8> out_key,
+    int out_len,
+    ffi.Pointer<EVP_MD> digest,
+    ffi.Pointer<ffi.Uint8> secret,
+    int secret_len,
+    ffi.Pointer<ffi.Uint8> salt,
+    int salt_len,
+    ffi.Pointer<ffi.Uint8> info,
+    int info_len,
+  ) {
+    return _native_HKDF(
+      out_key,
+      out_len,
+      digest,
+      secret,
+      secret_len,
+      salt,
+      salt_len,
+      info,
+      info_len,
+    );
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Size,
+      ffi.Pointer<EVP_MD>,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Size,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Size,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Size,
+    )
+  >(symbol: 'webcrypto_HKDF', assetId: _assetId)
+  external static int _native_HKDF(
+    ffi.Pointer<ffi.Uint8> out_key,
+    int out_len,
+    ffi.Pointer<EVP_MD> digest,
+    ffi.Pointer<ffi.Uint8> secret,
+    int secret_len,
+    ffi.Pointer<ffi.Uint8> salt,
+    int salt_len,
+    ffi.Pointer<ffi.Uint8> info,
+    int info_len,
+  );
+
+  void HMAC_CTX_free(ffi.Pointer<HMAC_CTX> ctx) {
+    return _native_HMAC_CTX_free(ctx);
+  }
+
+  @ffi.Native<ffi.Void Function(ffi.Pointer<HMAC_CTX>)>(
+    symbol: 'webcrypto_HMAC_CTX_free',
+    assetId: _assetId,
+  )
+  external static void _native_HMAC_CTX_free(ffi.Pointer<HMAC_CTX> ctx);
+
+  ffi.Pointer<HMAC_CTX> HMAC_CTX_new() {
+    return _native_HMAC_CTX_new();
+  }
+
+  @ffi.Native<ffi.Pointer<HMAC_CTX> Function()>(
+    symbol: 'webcrypto_HMAC_CTX_new',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<HMAC_CTX> _native_HMAC_CTX_new();
+
+  int HMAC_Final(
+    ffi.Pointer<HMAC_CTX> ctx,
+    ffi.Pointer<ffi.Uint8> out,
+    ffi.Pointer<ffi.UnsignedInt> out_len,
+  ) {
+    return _native_HMAC_Final(ctx, out, out_len);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<HMAC_CTX>,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Pointer<ffi.UnsignedInt>,
+    )
+  >(symbol: 'webcrypto_HMAC_Final', assetId: _assetId)
+  external static int _native_HMAC_Final(
+    ffi.Pointer<HMAC_CTX> ctx,
+    ffi.Pointer<ffi.Uint8> out,
+    ffi.Pointer<ffi.UnsignedInt> out_len,
+  );
+
+  int HMAC_Init_ex(
+    ffi.Pointer<HMAC_CTX> ctx,
+    ffi.Pointer<ffi.Void> key,
+    int key_len,
+    ffi.Pointer<EVP_MD> md,
+    ffi.Pointer<ENGINE> impl,
+  ) {
+    return _native_HMAC_Init_ex(ctx, key, key_len, md, impl);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<HMAC_CTX>,
+      ffi.Pointer<ffi.Void>,
+      ffi.Size,
+      ffi.Pointer<EVP_MD>,
+      ffi.Pointer<ENGINE>,
+    )
+  >(symbol: 'webcrypto_HMAC_Init_ex', assetId: _assetId)
+  external static int _native_HMAC_Init_ex(
+    ffi.Pointer<HMAC_CTX> ctx,
+    ffi.Pointer<ffi.Void> key,
+    int key_len,
+    ffi.Pointer<EVP_MD> md,
+    ffi.Pointer<ENGINE> impl,
+  );
+
+  int HMAC_size(ffi.Pointer<HMAC_CTX> ctx) {
+    return _native_HMAC_size(ctx);
+  }
+
+  @ffi.Native<ffi.Size Function(ffi.Pointer<HMAC_CTX>)>(
+    symbol: 'webcrypto_HMAC_size',
+    assetId: _assetId,
+  )
+  external static int _native_HMAC_size(ffi.Pointer<HMAC_CTX> ctx);
+
+  int HMAC_Update(
+    ffi.Pointer<HMAC_CTX> ctx,
+    ffi.Pointer<ffi.Uint8> data,
+    int data_len,
+  ) {
+    return _native_HMAC_Update(ctx, data, data_len);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(ffi.Pointer<HMAC_CTX>, ffi.Pointer<ffi.Uint8>, ffi.Size)
+  >(symbol: 'webcrypto_HMAC_Update', assetId: _assetId)
+  external static int _native_HMAC_Update(
+    ffi.Pointer<HMAC_CTX> ctx,
+    ffi.Pointer<ffi.Uint8> data,
+    int data_len,
+  );
+
+  ffi.Pointer<ffi.Void> OPENSSL_malloc(int size) {
+    return _native_OPENSSL_malloc(size);
+  }
+
+  @ffi.Native<ffi.Pointer<ffi.Void> Function(ffi.Size)>(
+    symbol: 'webcrypto_OPENSSL_malloc',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<ffi.Void> _native_OPENSSL_malloc(int size);
+
+  int PKCS5_PBKDF2_HMAC(
+    ffi.Pointer<ffi.Char> password,
+    int password_len,
+    ffi.Pointer<ffi.Uint8> salt,
+    int salt_len,
+    int iterations,
+    ffi.Pointer<EVP_MD> digest,
+    int key_len,
+    ffi.Pointer<ffi.Uint8> out_key,
+  ) {
+    return _native_PKCS5_PBKDF2_HMAC(
+      password,
+      password_len,
+      salt,
+      salt_len,
+      iterations,
+      digest,
+      key_len,
+      out_key,
+    );
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<ffi.Char>,
+      ffi.Size,
+      ffi.Pointer<ffi.Uint8>,
+      ffi.Size,
+      ffi.Uint32,
+      ffi.Pointer<EVP_MD>,
+      ffi.Size,
+      ffi.Pointer<ffi.Uint8>,
+    )
+  >(symbol: 'webcrypto_PKCS5_PBKDF2_HMAC', assetId: _assetId)
+  external static int _native_PKCS5_PBKDF2_HMAC(
+    ffi.Pointer<ffi.Char> password,
+    int password_len,
+    ffi.Pointer<ffi.Uint8> salt,
+    int salt_len,
+    int iterations,
+    ffi.Pointer<EVP_MD> digest,
+    int key_len,
+    ffi.Pointer<ffi.Uint8> out_key,
+  );
+
+  int RAND_bytes(ffi.Pointer<ffi.Uint8> buf, int len) {
+    return _native_RAND_bytes(buf, len);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<ffi.Uint8>, ffi.Size)>(
+    symbol: 'webcrypto_RAND_bytes',
+    assetId: _assetId,
+  )
+  external static int _native_RAND_bytes(ffi.Pointer<ffi.Uint8> buf, int len);
+
+  int RSA_check_key(ffi.Pointer<RSA> rsa) {
+    return _native_RSA_check_key(rsa);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<RSA>)>(
+    symbol: 'webcrypto_RSA_check_key',
+    assetId: _assetId,
+  )
+  external static int _native_RSA_check_key(ffi.Pointer<RSA> rsa);
+
+  void RSA_free(ffi.Pointer<RSA> rsa) {
+    return _native_RSA_free(rsa);
+  }
+
+  @ffi.Native<ffi.Void Function(ffi.Pointer<RSA>)>(
+    symbol: 'webcrypto_RSA_free',
+    assetId: _assetId,
+  )
+  external static void _native_RSA_free(ffi.Pointer<RSA> rsa);
+
+  int RSA_generate_key_ex(
+    ffi.Pointer<RSA> rsa,
+    int bits,
+    ffi.Pointer<BIGNUM> e,
+    ffi.Pointer<BN_GENCB> cb,
+  ) {
+    return _native_RSA_generate_key_ex(rsa, bits, e, cb);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<RSA>,
+      ffi.Int,
+      ffi.Pointer<BIGNUM>,
+      ffi.Pointer<BN_GENCB>,
+    )
+  >(symbol: 'webcrypto_RSA_generate_key_ex', assetId: _assetId)
+  external static int _native_RSA_generate_key_ex(
+    ffi.Pointer<RSA> rsa,
+    int bits,
+    ffi.Pointer<BIGNUM> e,
+    ffi.Pointer<BN_GENCB> cb,
+  );
+
+  void RSA_get0_crt_params(
+    ffi.Pointer<RSA> rsa,
+    ffi.Pointer<ffi.Pointer<BIGNUM>> out_dmp1,
+    ffi.Pointer<ffi.Pointer<BIGNUM>> out_dmq1,
+    ffi.Pointer<ffi.Pointer<BIGNUM>> out_iqmp,
+  ) {
+    return _native_RSA_get0_crt_params(rsa, out_dmp1, out_dmq1, out_iqmp);
+  }
+
+  @ffi.Native<
+    ffi.Void Function(
+      ffi.Pointer<RSA>,
+      ffi.Pointer<ffi.Pointer<BIGNUM>>,
+      ffi.Pointer<ffi.Pointer<BIGNUM>>,
+      ffi.Pointer<ffi.Pointer<BIGNUM>>,
+    )
+  >(symbol: 'webcrypto_RSA_get0_crt_params', assetId: _assetId)
+  external static void _native_RSA_get0_crt_params(
+    ffi.Pointer<RSA> rsa,
+    ffi.Pointer<ffi.Pointer<BIGNUM>> out_dmp1,
+    ffi.Pointer<ffi.Pointer<BIGNUM>> out_dmq1,
+    ffi.Pointer<ffi.Pointer<BIGNUM>> out_iqmp,
+  );
+
+  void RSA_get0_factors(
+    ffi.Pointer<RSA> rsa,
+    ffi.Pointer<ffi.Pointer<BIGNUM>> out_p,
+    ffi.Pointer<ffi.Pointer<BIGNUM>> out_q,
+  ) {
+    return _native_RSA_get0_factors(rsa, out_p, out_q);
+  }
+
+  @ffi.Native<
+    ffi.Void Function(
+      ffi.Pointer<RSA>,
+      ffi.Pointer<ffi.Pointer<BIGNUM>>,
+      ffi.Pointer<ffi.Pointer<BIGNUM>>,
+    )
+  >(symbol: 'webcrypto_RSA_get0_factors', assetId: _assetId)
+  external static void _native_RSA_get0_factors(
+    ffi.Pointer<RSA> rsa,
+    ffi.Pointer<ffi.Pointer<BIGNUM>> out_p,
+    ffi.Pointer<ffi.Pointer<BIGNUM>> out_q,
+  );
+
+  void RSA_get0_key(
+    ffi.Pointer<RSA> rsa,
+    ffi.Pointer<ffi.Pointer<BIGNUM>> out_n,
+    ffi.Pointer<ffi.Pointer<BIGNUM>> out_e,
+    ffi.Pointer<ffi.Pointer<BIGNUM>> out_d,
+  ) {
+    return _native_RSA_get0_key(rsa, out_n, out_e, out_d);
+  }
+
+  @ffi.Native<
+    ffi.Void Function(
+      ffi.Pointer<RSA>,
+      ffi.Pointer<ffi.Pointer<BIGNUM>>,
+      ffi.Pointer<ffi.Pointer<BIGNUM>>,
+      ffi.Pointer<ffi.Pointer<BIGNUM>>,
+    )
+  >(symbol: 'webcrypto_RSA_get0_key', assetId: _assetId)
+  external static void _native_RSA_get0_key(
+    ffi.Pointer<RSA> rsa,
+    ffi.Pointer<ffi.Pointer<BIGNUM>> out_n,
+    ffi.Pointer<ffi.Pointer<BIGNUM>> out_e,
+    ffi.Pointer<ffi.Pointer<BIGNUM>> out_d,
+  );
+
+  ffi.Pointer<RSA> RSA_new() {
+    return _native_RSA_new();
+  }
+
+  @ffi.Native<ffi.Pointer<RSA> Function()>(
+    symbol: 'webcrypto_RSA_new',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<RSA> _native_RSA_new();
+
+  ffi.Pointer<RSA> RSAPublicKey_dup(ffi.Pointer<RSA> rsa) {
+    return _native_RSAPublicKey_dup(rsa);
+  }
+
+  @ffi.Native<ffi.Pointer<RSA> Function(ffi.Pointer<RSA>)>(
+    symbol: 'webcrypto_RSAPublicKey_dup',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<RSA> _native_RSAPublicKey_dup(
+    ffi.Pointer<RSA> rsa,
+  );
+
+  int RSA_set0_crt_params(
+    ffi.Pointer<RSA> rsa,
+    ffi.Pointer<BIGNUM> dmp1,
+    ffi.Pointer<BIGNUM> dmq1,
+    ffi.Pointer<BIGNUM> iqmp,
+  ) {
+    return _native_RSA_set0_crt_params(rsa, dmp1, dmq1, iqmp);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<RSA>,
+      ffi.Pointer<BIGNUM>,
+      ffi.Pointer<BIGNUM>,
+      ffi.Pointer<BIGNUM>,
+    )
+  >(symbol: 'webcrypto_RSA_set0_crt_params', assetId: _assetId)
+  external static int _native_RSA_set0_crt_params(
+    ffi.Pointer<RSA> rsa,
+    ffi.Pointer<BIGNUM> dmp1,
+    ffi.Pointer<BIGNUM> dmq1,
+    ffi.Pointer<BIGNUM> iqmp,
+  );
+
+  int RSA_set0_factors(
+    ffi.Pointer<RSA> rsa,
+    ffi.Pointer<BIGNUM> p,
+    ffi.Pointer<BIGNUM> q,
+  ) {
+    return _native_RSA_set0_factors(rsa, p, q);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(ffi.Pointer<RSA>, ffi.Pointer<BIGNUM>, ffi.Pointer<BIGNUM>)
+  >(symbol: 'webcrypto_RSA_set0_factors', assetId: _assetId)
+  external static int _native_RSA_set0_factors(
+    ffi.Pointer<RSA> rsa,
+    ffi.Pointer<BIGNUM> p,
+    ffi.Pointer<BIGNUM> q,
+  );
+
+  int RSA_set0_key(
+    ffi.Pointer<RSA> rsa,
+    ffi.Pointer<BIGNUM> n,
+    ffi.Pointer<BIGNUM> e,
+    ffi.Pointer<BIGNUM> d,
+  ) {
+    return _native_RSA_set0_key(rsa, n, e, d);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<RSA>,
+      ffi.Pointer<BIGNUM>,
+      ffi.Pointer<BIGNUM>,
+      ffi.Pointer<BIGNUM>,
+    )
+  >(symbol: 'webcrypto_RSA_set0_key', assetId: _assetId)
+  external static int _native_RSA_set0_key(
+    ffi.Pointer<RSA> rsa,
+    ffi.Pointer<BIGNUM> n,
+    ffi.Pointer<BIGNUM> e,
+    ffi.Pointer<BIGNUM> d,
+  );
+
+  void OPENSSL_free(ffi.Pointer<ffi.Void> ptr) {
+    return _native_OPENSSL_free(ptr);
+  }
+
+  @ffi.Native<ffi.Void Function(ffi.Pointer<ffi.Void>)>(
+    symbol: 'webcrypto_OPENSSL_free',
+    assetId: _assetId,
+  )
+  external static void _native_OPENSSL_free(ffi.Pointer<ffi.Void> ptr);
+
+  ffi.Pointer<ffi.Void> OPENSSL_memdup(ffi.Pointer<ffi.Void> data, int size) {
+    return _native_OPENSSL_memdup(data, size);
+  }
+
+  @ffi.Native<ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>, ffi.Size)>(
+    symbol: 'webcrypto_OPENSSL_memdup',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<ffi.Void> _native_OPENSSL_memdup(
+    ffi.Pointer<ffi.Void> data,
+    int size,
+  );
+
+  int EVP_MD_size(ffi.Pointer<EVP_MD> md) {
+    return _native_EVP_MD_size(md);
+  }
+
+  @ffi.Native<ffi.Size Function(ffi.Pointer<EVP_MD>)>(
+    symbol: 'webcrypto_EVP_MD_size',
+    assetId: _assetId,
+  )
+  external static int _native_EVP_MD_size(ffi.Pointer<EVP_MD> md);
+
+  int EVP_AEAD_nonce_length(ffi.Pointer<EVP_AEAD> aead) {
+    return _native_EVP_AEAD_nonce_length(aead);
+  }
+
+  @ffi.Native<ffi.Size Function(ffi.Pointer<EVP_AEAD>)>(
+    symbol: 'webcrypto_EVP_AEAD_nonce_length',
+    assetId: _assetId,
+  )
+  external static int _native_EVP_AEAD_nonce_length(ffi.Pointer<EVP_AEAD> aead);
+
+  int EVP_AEAD_max_tag_len(ffi.Pointer<EVP_AEAD> aead) {
+    return _native_EVP_AEAD_max_tag_len(aead);
+  }
+
+  @ffi.Native<ffi.Size Function(ffi.Pointer<EVP_AEAD>)>(
+    symbol: 'webcrypto_EVP_AEAD_max_tag_len',
+    assetId: _assetId,
+  )
+  external static int _native_EVP_AEAD_max_tag_len(ffi.Pointer<EVP_AEAD> aead);
+
+  int EVP_AEAD_key_length(ffi.Pointer<EVP_AEAD> aead) {
+    return _native_EVP_AEAD_key_length(aead);
+  }
+
+  @ffi.Native<ffi.Size Function(ffi.Pointer<EVP_AEAD>)>(
+    symbol: 'webcrypto_EVP_AEAD_key_length',
+    assetId: _assetId,
+  )
+  external static int _native_EVP_AEAD_key_length(ffi.Pointer<EVP_AEAD> aead);
+
+  ffi.Pointer<BIGNUM> BN_value_one() {
+    return _native_BN_value_one();
+  }
+
+  @ffi.Native<ffi.Pointer<BIGNUM> Function()>(
+    symbol: 'webcrypto_BN_value_one',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<BIGNUM> _native_BN_value_one();
+
+  int BN_add(
+    ffi.Pointer<BIGNUM> r,
+    ffi.Pointer<BIGNUM> a,
+    ffi.Pointer<BIGNUM> b,
+  ) {
+    return _native_BN_add(r, a, b);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<BIGNUM>,
+      ffi.Pointer<BIGNUM>,
+      ffi.Pointer<BIGNUM>,
+    )
+  >(symbol: 'webcrypto_BN_add', assetId: _assetId)
+  external static int _native_BN_add(
+    ffi.Pointer<BIGNUM> r,
+    ffi.Pointer<BIGNUM> a,
+    ffi.Pointer<BIGNUM> b,
+  );
+
+  int BN_sub(
+    ffi.Pointer<BIGNUM> r,
+    ffi.Pointer<BIGNUM> a,
+    ffi.Pointer<BIGNUM> b,
+  ) {
+    return _native_BN_sub(r, a, b);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(
+      ffi.Pointer<BIGNUM>,
+      ffi.Pointer<BIGNUM>,
+      ffi.Pointer<BIGNUM>,
+    )
+  >(symbol: 'webcrypto_BN_sub', assetId: _assetId)
+  external static int _native_BN_sub(
+    ffi.Pointer<BIGNUM> r,
+    ffi.Pointer<BIGNUM> a,
+    ffi.Pointer<BIGNUM> b,
+  );
+
+  int BN_cmp(ffi.Pointer<BIGNUM> a, ffi.Pointer<BIGNUM> b) {
+    return _native_BN_cmp(a, b);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<BIGNUM>, ffi.Pointer<BIGNUM>)>(
+    symbol: 'webcrypto_BN_cmp',
+    assetId: _assetId,
+  )
+  external static int _native_BN_cmp(
+    ffi.Pointer<BIGNUM> a,
+    ffi.Pointer<BIGNUM> b,
+  );
+
+  int BN_lshift(ffi.Pointer<BIGNUM> r, ffi.Pointer<BIGNUM> a, int n) {
+    return _native_BN_lshift(r, a, n);
+  }
+
+  @ffi.Native<
+    ffi.Int Function(ffi.Pointer<BIGNUM>, ffi.Pointer<BIGNUM>, ffi.Int)
+  >(symbol: 'webcrypto_BN_lshift', assetId: _assetId)
+  external static int _native_BN_lshift(
+    ffi.Pointer<BIGNUM> r,
+    ffi.Pointer<BIGNUM> a,
+    int n,
+  );
+
+  int EVP_CIPHER_block_size(ffi.Pointer<EVP_CIPHER> cipher) {
+    return _native_EVP_CIPHER_block_size(cipher);
+  }
+
+  @ffi.Native<ffi.UnsignedInt Function(ffi.Pointer<EVP_CIPHER>)>(
+    symbol: 'webcrypto_EVP_CIPHER_block_size',
+    assetId: _assetId,
+  )
+  external static int _native_EVP_CIPHER_block_size(
+    ffi.Pointer<EVP_CIPHER> cipher,
+  );
+
+  ffi.Pointer<EC_GROUP> EC_GROUP_new_by_curve_name(int nid) {
+    return _native_EC_GROUP_new_by_curve_name(nid);
+  }
+
+  @ffi.Native<ffi.Pointer<EC_GROUP> Function(ffi.Int)>(
+    symbol: 'webcrypto_EC_GROUP_new_by_curve_name',
+    assetId: _assetId,
+  )
+  external static ffi.Pointer<EC_GROUP> _native_EC_GROUP_new_by_curve_name(
+    int nid,
+  );
+
+  void EC_GROUP_free(ffi.Pointer<EC_GROUP> group) {
+    return _native_EC_GROUP_free(group);
+  }
+
+  @ffi.Native<ffi.Void Function(ffi.Pointer<EC_GROUP>)>(
+    symbol: 'webcrypto_EC_GROUP_free',
+    assetId: _assetId,
+  )
+  external static void _native_EC_GROUP_free(ffi.Pointer<EC_GROUP> group);
+
+  int EVP_PKEY_set_type(ffi.Pointer<EVP_PKEY> pkey, int type) {
+    return _native_EVP_PKEY_set_type(pkey, type);
+  }
+
+  @ffi.Native<ffi.Int Function(ffi.Pointer<EVP_PKEY>, ffi.Int)>(
+    symbol: 'webcrypto_EVP_PKEY_set_type',
+    assetId: _assetId,
+  )
+  external static int _native_EVP_PKEY_set_type(
+    ffi.Pointer<EVP_PKEY> pkey,
+    int type,
+  );
+
+  int BORINGSSL_self_test() {
+    return _native_BORINGSSL_self_test();
+  }
+
+  @ffi.Native<ffi.Int Function()>(
+    symbol: 'webcrypto_BORINGSSL_self_test',
+    assetId: _assetId,
+  )
+  external static int _native_BORINGSSL_self_test();
+}
diff --git a/lib/src/boringssl/lookup/lookup.dart b/lib/src/boringssl/lookup/lookup.dart
index 4581ccf9..9fbf2cc4 100644
--- a/lib/src/boringssl/lookup/lookup.dart
+++ b/lib/src/boringssl/lookup/lookup.dart
@@ -18,15 +18,7 @@ import 'dart:ffi';
 
 import '../../third_party/boringssl/generated_bindings.dart';
 
-import 'symbols.generated.dart';
-
-export 'symbols.generated.dart' show Sym;
-
-@Native<Pointer<Void> Function(Int32)>(
-  symbol: 'webcrypto_lookup_symbol',
-  assetId: 'package:webcrypto/webcrypto.dart',
-)
-external Pointer<Void> _nativeWebcryptoLookupSymbol(int index);
+import 'direct_bindings.generated.dart';
 
 @Native<Size Function()>(
   symbol: 'webcrypto_get_CBB_size',
@@ -34,18 +26,22 @@ external Pointer<Void> _nativeWebcryptoLookupSymbol(int index);
 )
 external int _nativeWebcryptoGetCbbSize();
 
-/// Resolve lookup from the bundled native asset for `package:webcrypto`.
-Pointer<T> lookup<T extends NativeType>(String symbolName) {
-  final sym = symFromString(symbolName);
-  return _nativeWebcryptoLookupSymbol(sym.index).cast<T>();
-}
+@Native<Pointer<Void> Function()>(
+  symbol: 'webcrypto_get_EVP_PKEY_free_address',
+  assetId: 'package:webcrypto/webcrypto.dart',
+)
+external Pointer<Void> _nativeWebcryptoGetEvpPkeyFreeAddress();
 
-/// Gives access to BoringSSL symbols.
-final BoringSsl ssl = BoringSsl.fromLookup(lookup);
+/// Gives access to BoringSSL symbols exported directly from the bundled asset.
+final WebcryptoBoringSsl ssl = const WebcryptoBoringSsl();
 
 /// Gets the native `sizeof(CBB)` value from the bundled helper library.
 int nativeWebcryptoGetCbbSize() => _nativeWebcryptoGetCbbSize();
 
+/// Gets the native address of `EVP_PKEY_free` for [NativeFinalizer].
+Pointer<NativeFunction<Void Function(Pointer<EVP_PKEY>)>>
+nativeEvpPkeyFreeAddress() => _nativeWebcryptoGetEvpPkeyFreeAddress().cast();
+
 /// ERR_GET_LIB returns the library code for the error. This is one of the
 /// ERR_LIB_* values.
 ///
diff --git a/lib/src/boringssl/lookup/utils.dart b/lib/src/boringssl/lookup/utils.dart
index 457df6f2..899929b7 100644
--- a/lib/src/boringssl/lookup/utils.dart
+++ b/lib/src/boringssl/lookup/utils.dart
@@ -17,9 +17,6 @@
 import 'dart:io' show Platform, Directory, File;
 import 'dart:ffi';
 
-import 'symbols.generated.dart';
-import '../bindings/generated_bindings.dart';
-
 /// Get platform-dependent library filename for the binary webcrypto library.
 String get libraryFileName {
   const libraryName = 'webcrypto';
@@ -53,16 +50,7 @@ lookupLibraryInDotDartTool() {
   );
   if (libraryFile.existsSync()) {
     final library = DynamicLibrary.open(libraryFile.path);
-
-    // Try to lookup the 'webcrypto_lookup_symbol' symbol.
-    final webcrypto = WebCrypto(library);
-    final webcrypto_lookup_symbol = webcrypto.webcrypto_lookup_symbol;
-
-    // Return a function from Sym to lookup using `webcrypto_lookup_symbol`
-    Pointer<T> lookup<T extends NativeType>(String s) =>
-        webcrypto_lookup_symbol(symFromString(s).index).cast<T>();
-
-    return lookup;
+    return library.lookup;
   }
   return null;
 }
diff --git a/lib/src/impl_ffi/impl_ffi.dart b/lib/src/impl_ffi/impl_ffi.dart
index e53bebbf..5794fe10 100644
--- a/lib/src/impl_ffi/impl_ffi.dart
+++ b/lib/src/impl_ffi/impl_ffi.dart
@@ -30,7 +30,12 @@ import '../jsonwebkey.dart' show JsonWebKey;
 import '../webcrypto/webcrypto.dart';
 import '../impl_interface/impl_interface.dart';
 import '../boringssl/lookup/lookup.dart'
-    show ssl, nativeWebcryptoGetCbbSize, ERR_GET_LIB, ERR_GET_REASON;
+    show
+        ssl,
+        nativeWebcryptoGetCbbSize,
+        nativeEvpPkeyFreeAddress,
+        ERR_GET_LIB,
+        ERR_GET_REASON;
 
 part 'impl_ffi.aescbc.dart';
 part 'impl_ffi.aesctr.dart';
diff --git a/lib/src/impl_ffi/impl_ffi.utils.dart b/lib/src/impl_ffi/impl_ffi.utils.dart
index a44df3e3..f1494dd0 100644
--- a/lib/src/impl_ffi/impl_ffi.utils.dart
+++ b/lib/src/impl_ffi/impl_ffi.utils.dart
@@ -25,7 +25,7 @@ class _EvpPKey implements ffi.Finalizable {
   static const _externalSizeEstimate = 4096;
 
   static final _finalizer = ffi.NativeFinalizer(
-    ssl.addresses.EVP_PKEY_free.cast(),
+    nativeEvpPkeyFreeAddress().cast(),
   );
 
   final ffi.Pointer<EVP_PKEY> _pkey;
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index a5a7e283..0ec1d21e 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -49,6 +49,7 @@ include(
 # Tradeoff performance for smaller binary size, see:
 # https://boringssl.googlesource.com/boringssl/+/HEAD/BUILDING.md#binary-size
 add_definitions(-DOPENSSL_SMALL)
+add_definitions(-DBORINGSSL_PREFIX=webcrypto)
 
 # Logic from CMakeLists.txt in BoringSSL
 if("${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "x86_64")
@@ -140,23 +141,33 @@ endif()
 
 add_library(
   webcrypto
-  
+
   # Build a shared library
   SHARED
-  
+
   # Source files
   ../src/webcrypto.c
-  ../src/symbols.generated.c
   ${crypto_sources}
   ${crypto_sources_${PLATFORM}_${ARCH}}
 )
 
+if(WIN32)
+  target_sources(
+    webcrypto
+
+    PRIVATE
+
+    ../src/webcrypto_exports.def
+  )
+endif()
+
 target_include_directories(
   webcrypto
 
   PRIVATE
 
   ../third_party/boringssl/src/include/
+  ../third_party/boringssl/src/gen/
 )
 
 set_target_properties(
@@ -166,6 +177,7 @@ set_target_properties(
   
   C_VISIBILITY_PRESET hidden
   VISIBILITY_INLINES_HIDDEN 1
+  WINDOWS_EXPORT_ALL_SYMBOLS TRUE
 )
 
 install(
diff --git a/src/symbols.yaml b/src/symbols.yaml
index db96c5ac..1e361ade 100644
--- a/src/symbols.yaml
+++ b/src/symbols.yaml
@@ -13,38 +13,19 @@
 # limitations under the License.
 
 ### List of BoringSSL symbols used
-# This file is the source of truth for which BoringSSL symbols can be used from
-# in the Dart code using`dart:ffi`.
+# This file is the source of truth for which prefixed BoringSSL entry points
+# `package:webcrypto` binds directly with `dart:ffi`.
 #
-# Symbols have to be looked up using the `webcrypto_lookup_symbol(index)`
-# function defined in `webcrypto.c`, using `index` from the `Symbol` enum
-# defined in `lib/src/boringssl/symbols.generated.dart`.
+# The vendored BoringSSL build is compiled with `BORINGSSL_PREFIX=webcrypto`,
+# so symbols listed here are exported from the bundled native asset as
+# `webcrypto_<symbol>`.
 #
-# This ensures that we have no symbol conflicts with other versions of BoringSSL
-# or OpenSSL that might be linked into the final application, because we only
-# expose the `webcrypto_lookup_symbol` symbol.
+# `tool/generate_direct_bindings.dart` uses this list together with
+# `lib/src/third_party/boringssl/generated_bindings.dart` to generate the direct
+# `@Native(..., assetId: ...)` binding layer in
+# `lib/src/boringssl/lookup/direct_bindings.generated.dart`.
 #
-# On most platforms, like Android, the BoringSSL sources and `webcrypto.c`
-# is compiled to a dynamic library `webcrypto.so`, in this case symbol conflicts
-# is unlikely (if loaded correctly).
-#
-# But on iOS the BoringSSL sources and `webcrypto.c` is compiled into a static
-# library and linked into the final application binary. Symbol conflicts are
-# averted here because BoringSSL is compiled with `-fvisibility=hidden` and,
-# thus, only the `webcrypto_lookup_symbol` symbol is visible when the static
-# library is linked into the final application.
-#
-# Having fewer symbol names in the final application binary (and shared library)
-# also reduces the overall code size. Though symbol names only take up ~2kb.
-#
-# The following files:
-#  - `src/symbols.generated.c`
-#  - `lib/src/boringssl/lookup/symbols.generated.dart`
-# will be generated using `tool/generate_symbols_table.dart`, using the symbols
-# listed in this file.
-#
-# Keep consistent with lib/src/third_party/boringssl/ffigen.yaml and
-# lib/src/boringssl/bindings/ffigen.yaml.
+# Keep consistent with lib/src/third_party/boringssl/ffigen.yaml.
 - BN_bin2bn
 - BN_bn2bin_padded
 - BN_free
@@ -57,7 +38,6 @@
 - CBB_init
 - CBB_len
 - CBB_zero
-- CBS_init
 - CRYPTO_memcmp
 - ECDH_compute_key
 - ECDSA_SIG_free
diff --git a/src/webcrypto.c b/src/webcrypto.c
index 48d25358..ee608e25 100644
--- a/src/webcrypto.c
+++ b/src/webcrypto.c
@@ -14,15 +14,15 @@
  * limitations under the License.
  */
 
-#include <assert.h>
+#include <openssl/bytestring.h>
+#include <openssl/evp.h>
 
-#include "symbols.h"
 #include "webcrypto.h"
 
-WEBCRYPTO_EXPORT void* webcrypto_lookup_symbol(int32_t index) {
-  return _webcrypto_symbol_table[index];
-}
-
 WEBCRYPTO_EXPORT size_t webcrypto_get_CBB_size(void) {
   return sizeof(CBB);
 }
+
+WEBCRYPTO_EXPORT void* webcrypto_get_EVP_PKEY_free_address(void) {
+  return (void*)&EVP_PKEY_free;
+}
diff --git a/src/webcrypto.h b/src/webcrypto.h
index f29466d1..e11f146f 100644
--- a/src/webcrypto.h
+++ b/src/webcrypto.h
@@ -14,6 +14,9 @@
  * limitations under the License.
  */
 
+#ifndef WEBCRYPTO_H
+#define WEBCRYPTO_H
+
 #include <stddef.h>
 #include <stdint.h>
 
@@ -25,9 +28,10 @@
   __attribute__((visibility("default"))) __attribute__((used))
 #endif
 
-// Function to lookup BoringSSL symbols based on index in the Sym enum.
-// See src/symbols.yaml for details.
-WEBCRYPTO_EXPORT void* webcrypto_lookup_symbol(int32_t index);
-
 // Helper function to get the size of CBB structure for FFI allocation.
 WEBCRYPTO_EXPORT size_t webcrypto_get_CBB_size(void);
+
+// Helper function to retrieve the address of EVP_PKEY_free for NativeFinalizer.
+WEBCRYPTO_EXPORT void* webcrypto_get_EVP_PKEY_free_address(void);
+
+#endif  // WEBCRYPTO_H
diff --git a/src/webcrypto_exports.def b/src/webcrypto_exports.def
new file mode 100644
index 00000000..3e3f792c
--- /dev/null
+++ b/src/webcrypto_exports.def
@@ -0,0 +1,140 @@
+; AUTO GENERATED FILE, DO NOT EDIT.
+; Generated by `tool/generate_direct_bindings.dart`.
+EXPORTS
+webcrypto_get_CBB_size
+webcrypto_get_EVP_PKEY_free_address
+webcrypto_BN_bin2bn
+webcrypto_BN_bn2bin_padded
+webcrypto_BN_free
+webcrypto_BN_new
+webcrypto_BN_num_bytes
+webcrypto_BN_set_word
+webcrypto_CBB_cleanup
+webcrypto_CBB_data
+webcrypto_CBB_flush
+webcrypto_CBB_init
+webcrypto_CBB_len
+webcrypto_CBB_zero
+webcrypto_CRYPTO_memcmp
+webcrypto_ECDH_compute_key
+webcrypto_ECDSA_SIG_free
+webcrypto_ECDSA_SIG_get0
+webcrypto_ECDSA_SIG_marshal
+webcrypto_ECDSA_SIG_new
+webcrypto_ECDSA_SIG_parse
+webcrypto_EC_GROUP_get0_order
+webcrypto_EC_GROUP_get_curve_name
+webcrypto_EC_GROUP_get_degree
+webcrypto_EC_KEY_check_key
+webcrypto_EC_KEY_free
+webcrypto_EC_KEY_generate_key
+webcrypto_EC_KEY_get0_group
+webcrypto_EC_KEY_get0_private_key
+webcrypto_EC_KEY_get0_public_key
+webcrypto_EC_KEY_get_enc_flags
+webcrypto_EC_KEY_new_by_curve_name
+webcrypto_EC_KEY_set_enc_flags
+webcrypto_EC_KEY_set_private_key
+webcrypto_EC_KEY_set_public_key
+webcrypto_EC_KEY_set_public_key_affine_coordinates
+webcrypto_EC_POINT_free
+webcrypto_EC_POINT_get_affine_coordinates_GFp
+webcrypto_EC_POINT_new
+webcrypto_EC_POINT_oct2point
+webcrypto_EC_POINT_point2cbb
+webcrypto_ERR_clear_error
+webcrypto_ERR_error_string_n
+webcrypto_ERR_get_error
+webcrypto_ERR_peek_error
+webcrypto_EVP_aead_aes_128_gcm
+webcrypto_EVP_aead_aes_256_gcm
+webcrypto_EVP_AEAD_CTX_free
+webcrypto_EVP_AEAD_CTX_new
+webcrypto_EVP_AEAD_CTX_open
+webcrypto_EVP_AEAD_CTX_seal
+webcrypto_EVP_AEAD_max_overhead
+webcrypto_EVP_aes_128_cbc
+webcrypto_EVP_aes_128_ctr
+webcrypto_EVP_aes_256_cbc
+webcrypto_EVP_aes_256_ctr
+webcrypto_EVP_CIPHER_CTX_free
+webcrypto_EVP_CIPHER_CTX_new
+webcrypto_EVP_CipherFinal_ex
+webcrypto_EVP_CipherInit_ex
+webcrypto_EVP_CIPHER_iv_length
+webcrypto_EVP_CipherUpdate
+webcrypto_EVP_DigestFinal
+webcrypto_EVP_DigestInit
+webcrypto_EVP_DigestSignFinal
+webcrypto_EVP_DigestSignInit
+webcrypto_EVP_DigestSignUpdate
+webcrypto_EVP_DigestUpdate
+webcrypto_EVP_DigestVerifyFinal
+webcrypto_EVP_DigestVerifyInit
+webcrypto_EVP_DigestVerifyUpdate
+webcrypto_EVP_marshal_private_key
+webcrypto_EVP_marshal_public_key
+webcrypto_EVP_MD_CTX_free
+webcrypto_EVP_MD_CTX_new
+webcrypto_EVP_MD_CTX_size
+webcrypto_EVP_parse_private_key
+webcrypto_EVP_parse_public_key
+webcrypto_EVP_PKEY_CTX_free
+webcrypto_EVP_PKEY_CTX_new
+webcrypto_EVP_PKEY_CTX_set0_rsa_oaep_label
+webcrypto_EVP_PKEY_CTX_set_rsa_mgf1_md
+webcrypto_EVP_PKEY_CTX_set_rsa_oaep_md
+webcrypto_EVP_PKEY_CTX_set_rsa_padding
+webcrypto_EVP_PKEY_CTX_set_rsa_pss_saltlen
+webcrypto_EVP_PKEY_decrypt
+webcrypto_EVP_PKEY_decrypt_init
+webcrypto_EVP_PKEY_encrypt
+webcrypto_EVP_PKEY_encrypt_init
+webcrypto_EVP_PKEY_free
+webcrypto_EVP_PKEY_get1_EC_KEY
+webcrypto_EVP_PKEY_get1_RSA
+webcrypto_EVP_PKEY_id
+webcrypto_EVP_PKEY_new
+webcrypto_EVP_PKEY_set1_EC_KEY
+webcrypto_EVP_PKEY_set1_RSA
+webcrypto_EVP_sha1
+webcrypto_EVP_sha256
+webcrypto_EVP_sha384
+webcrypto_EVP_sha512
+webcrypto_HKDF
+webcrypto_HMAC_CTX_free
+webcrypto_HMAC_CTX_new
+webcrypto_HMAC_Final
+webcrypto_HMAC_Init_ex
+webcrypto_HMAC_size
+webcrypto_HMAC_Update
+webcrypto_OPENSSL_malloc
+webcrypto_PKCS5_PBKDF2_HMAC
+webcrypto_RAND_bytes
+webcrypto_RSA_check_key
+webcrypto_RSA_free
+webcrypto_RSA_generate_key_ex
+webcrypto_RSA_get0_crt_params
+webcrypto_RSA_get0_factors
+webcrypto_RSA_get0_key
+webcrypto_RSA_new
+webcrypto_RSAPublicKey_dup
+webcrypto_RSA_set0_crt_params
+webcrypto_RSA_set0_factors
+webcrypto_RSA_set0_key
+webcrypto_OPENSSL_free
+webcrypto_OPENSSL_memdup
+webcrypto_EVP_MD_size
+webcrypto_EVP_AEAD_nonce_length
+webcrypto_EVP_AEAD_max_tag_len
+webcrypto_EVP_AEAD_key_length
+webcrypto_BN_value_one
+webcrypto_BN_add
+webcrypto_BN_sub
+webcrypto_BN_cmp
+webcrypto_BN_lshift
+webcrypto_EVP_CIPHER_block_size
+webcrypto_EC_GROUP_new_by_curve_name
+webcrypto_EC_GROUP_free
+webcrypto_EVP_PKEY_set_type
+webcrypto_BORINGSSL_self_test
diff --git a/tool/bump-boringssl-revision.sh b/tool/bump-boringssl-revision.sh
index d7b4fc79..88beb051 100755
--- a/tool/bump-boringssl-revision.sh
+++ b/tool/bump-boringssl-revision.sh
@@ -464,9 +464,9 @@ main() {
     cd "$ROOT"
     dart pub get --no-example
 
-    section "Generating symbols table"
-    log_info "Running generate_symbols_table.dart..."
-    dart "$DIR/generate_symbols_table.dart"
+    section "Generating direct bindings"
+    log_info "Running generate_direct_bindings.dart..."
+    dart "$DIR/generate_direct_bindings.dart"
 
     section "Updating FFI bindings"
     log_info "Running update-bindings.sh..."
diff --git a/tool/generate_direct_bindings.dart b/tool/generate_direct_bindings.dart
new file mode 100644
index 00000000..9233737b
--- /dev/null
+++ b/tool/generate_direct_bindings.dart
@@ -0,0 +1,255 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// ignore_for_file: avoid_print
+
+import 'dart:io';
+
+import 'package:yaml/yaml.dart';
+
+const _assetId = 'package:webcrypto/webcrypto.dart';
+const _helperExports = <String>[
+  'webcrypto_get_CBB_size',
+  'webcrypto_get_EVP_PKEY_free_address',
+];
+
+final class _MethodBinding {
+  final String name;
+  final String returnType;
+  final String params;
+  final String args;
+  final String nativeType;
+
+  const _MethodBinding({
+    required this.name,
+    required this.returnType,
+    required this.params,
+    required this.args,
+    required this.nativeType,
+  });
+}
+
+Future<void> main() async {
+  final rootUri = Platform.script.resolve('../');
+  final symbolsYamlUri = rootUri.resolve('src/symbols.yaml');
+  final bindingsUri = rootUri.resolve(
+    'lib/src/third_party/boringssl/generated_bindings.dart',
+  );
+  final outputUri = rootUri.resolve(
+    'lib/src/boringssl/lookup/direct_bindings.generated.dart',
+  );
+  final exportsUri = rootUri.resolve('src/webcrypto_exports.def');
+
+  print('Generating direct bindings from ${symbolsYamlUri.pathSegments.last}:');
+  final symbols = List<String>.from(
+    loadYaml(
+      await File.fromUri(symbolsYamlUri).readAsString(),
+      sourceUrl: symbolsYamlUri,
+    ),
+  );
+  print(' - Loaded ${symbols.length} symbol declarations');
+
+  final thirdPartyBindings = await File.fromUri(bindingsUri).readAsString();
+  final bindings = <_MethodBinding>[];
+
+  for (final symbol in symbols) {
+    final binding = _extractBinding(thirdPartyBindings, symbol);
+    if (binding != null) {
+      bindings.add(binding);
+    } else {
+      print(' - Skipping $symbol: no generated binding found');
+    }
+  }
+
+  print(
+    ' - Writing ${outputUri.pathSegments.last} for ${bindings.length} symbols',
+  );
+  await File.fromUri(outputUri).writeAsString(_render(bindings));
+
+  print(' - Writing ${exportsUri.pathSegments.last}');
+  await File.fromUri(exportsUri).writeAsString(_renderWindowsExports(symbols));
+  print('Done');
+}
+
+_MethodBinding? _extractBinding(String source, String symbol) {
+  final methodPattern = RegExp(
+    '^  (?<returnType>[^\\n]+?) $symbol\\(',
+    multiLine: true,
+  );
+  final match = methodPattern.firstMatch(source);
+  if (match == null) {
+    return null;
+  }
+
+  final signatureStart = match.start;
+  final openParamsIndex = source.indexOf('(', signatureStart);
+  final closeParamsIndex = _findMatchingDelimiter(
+    source,
+    openParamsIndex,
+    openDelimiter: '(',
+    closeDelimiter: ')',
+  );
+  final params = source.substring(openParamsIndex + 1, closeParamsIndex);
+
+  final bodyStart = source.indexOf('{', closeParamsIndex);
+  if (bodyStart == -1) {
+    throw StateError('Unable to find method body for $symbol');
+  }
+  final bodyEnd = source.indexOf('\n  }', bodyStart);
+  if (bodyEnd == -1) {
+    throw StateError('Unable to find end of method body for $symbol');
+  }
+
+  final delegateCall = '_$symbol(';
+  final argsStart = source.indexOf(delegateCall, bodyStart);
+  if (argsStart == -1 || argsStart > bodyEnd) {
+    throw StateError('Unable to find delegated call for $symbol');
+  }
+  final openArgsIndex = argsStart + delegateCall.length - 1;
+  final closeArgsIndex = _findMatchingDelimiter(
+    source,
+    openArgsIndex,
+    openDelimiter: '(',
+    closeDelimiter: ')',
+  );
+  final args = source.substring(openArgsIndex + 1, closeArgsIndex).trim();
+
+  final lookupMarker = 'late final _${symbol}Ptr =';
+  final ptrIndex = source.indexOf(lookupMarker, bodyEnd);
+  if (ptrIndex == -1) {
+    throw StateError('Unable to find native lookup block for $symbol');
+  }
+  final lookupStart = source.indexOf('_lookup<', ptrIndex);
+  if (lookupStart == -1) {
+    throw StateError('Unable to find _lookup<...> block for $symbol');
+  }
+  final typeStart = lookupStart + '_lookup<'.length;
+  final typeEnd = _findMatchingDelimiter(
+    source,
+    typeStart - 1,
+    openDelimiter: '<',
+    closeDelimiter: '>',
+  );
+  final nativeType = _unwrapNativeFunction(
+    source.substring(typeStart, typeEnd).trim(),
+    symbol,
+  );
+
+  return _MethodBinding(
+    name: symbol,
+    returnType: match.namedGroup('returnType')!.trim(),
+    params: params,
+    args: args,
+    nativeType: nativeType,
+  );
+}
+
+String _unwrapNativeFunction(String nativeType, String symbol) {
+  const prefix = 'ffi.NativeFunction<';
+  if (!nativeType.startsWith(prefix) || !nativeType.endsWith('>')) {
+    throw StateError('Unexpected native lookup type for $symbol: $nativeType');
+  }
+  return nativeType.substring(prefix.length, nativeType.length - 1).trim();
+}
+
+int _findMatchingDelimiter(
+  String source,
+  int openIndex, {
+  required String openDelimiter,
+  required String closeDelimiter,
+}) {
+  var depth = 0;
+  for (var i = openIndex; i < source.length; i++) {
+    final char = source[i];
+    if (char == openDelimiter) {
+      depth++;
+    } else if (char == closeDelimiter) {
+      depth--;
+      if (depth == 0) {
+        return i;
+      }
+    }
+  }
+  throw StateError(
+    'Unable to find matching closing delimiter for $openDelimiter at $openIndex',
+  );
+}
+
+String _render(List<_MethodBinding> bindings) {
+  final out = <String>[
+    '// Copyright 2026 Google LLC',
+    '//',
+    '// Licensed under the Apache License, Version 2.0 (the "License");',
+    '// you may not use this file except in compliance with the License.',
+    '// You may obtain a copy of the License at',
+    '//',
+    '//      http://www.apache.org/licenses/LICENSE-2.0',
+    '//',
+    '// Unless required by applicable law or agreed to in writing, software',
+    '// distributed under the License is distributed on an "AS IS" BASIS,',
+    '// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.',
+    '// See the License for the specific language governing permissions and',
+    '// limitations under the License.',
+    '',
+    '// AUTO GENERATED FILE, DO NOT EDIT.',
+    '//',
+    '// Generated by `tool/generate_direct_bindings.dart`.',
+    '// ignore_for_file: constant_identifier_names',
+    '// ignore_for_file: non_constant_identifier_names',
+    '// ignore_for_file: type=lint',
+    '',
+    "import 'dart:ffi' as ffi;",
+    '',
+    "import '../../third_party/boringssl/generated_bindings.dart';",
+    '',
+    "const _assetId = '$_assetId';",
+    '',
+    'class WebcryptoBoringSsl {',
+    '  const WebcryptoBoringSsl();',
+    '',
+  ];
+
+  for (final binding in bindings) {
+    out.addAll([
+      '  ${binding.returnType} ${binding.name}(${binding.params}) {',
+      '    return _native_${binding.name}(${binding.args});',
+      '  }',
+      '',
+      '  @ffi.Native<${binding.nativeType}>(',
+      "    symbol: 'webcrypto_${binding.name}',",
+      '    assetId: _assetId,',
+      '  )',
+      '  external static ${binding.returnType} _native_${binding.name}(',
+      binding.params,
+      '  );',
+      '',
+    ]);
+  }
+
+  out.add('}');
+  out.add('');
+  return out.join('\n');
+}
+
+String _renderWindowsExports(List<String> symbols) {
+  final out = <String>[
+    '; AUTO GENERATED FILE, DO NOT EDIT.',
+    '; Generated by `tool/generate_direct_bindings.dart`.',
+    'EXPORTS',
+    ..._helperExports,
+    ...symbols.map((symbol) => 'webcrypto_$symbol'),
+    '',
+  ];
+  return out.join('\n');
+}
diff --git a/tool/update-bindings.sh b/tool/update-bindings.sh
index 9ff4da9e..3a3977ad 100755
--- a/tool/update-bindings.sh
+++ b/tool/update-bindings.sh
@@ -24,3 +24,4 @@ dart pub get --no-example
 
 dart run ffigen --config=lib/src/boringssl/bindings/ffigen.yaml
 dart run ffigen --config=lib/src/third_party/boringssl/ffigen.yaml
+dart tool/generate_direct_bindings.dart