@hxa-rn/react-native-quick-crypto 1.1.0-beta.1

package/harmony/quick_crypto/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,296 @@
+cmake_minimum_required(VERSION 3.13)
+project(quick_crypto)
+
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(QUICKCRYPTO_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
+# Module root (quick_crypto/) — deps live here to avoid deep paths
+set(QUICKCRYPTO_MODULE_ROOT ${QUICKCRYPTO_SOURCE_DIR}/../../..)
+
+# ============================================================================
+# BLAKE3 sources - aarch64 NEON (HarmonyOS target is arm64-v8a)
+# ============================================================================
+set(BLAKE3_SOURCES
+  ${QUICKCRYPTO_MODULE_ROOT}/deps/blake3/blake3.c
+  ${QUICKCRYPTO_MODULE_ROOT}/deps/blake3/blake3_dispatch.c
+  ${QUICKCRYPTO_MODULE_ROOT}/deps/blake3/blake3_portable.c
+  ${QUICKCRYPTO_MODULE_ROOT}/deps/blake3/blake3_neon.c
+)
+
+# ============================================================================
+# Main library sources
+# ============================================================================
+add_library(quick_crypto SHARED
+  ${QUICKCRYPTO_SOURCE_DIR}/QuickCryptoOnLoad.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/argon2/HybridArgon2.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/blake3/HybridBlake3.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/certificate/HybridCertificate.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/cipher/CCMCipher.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/cipher/ChaCha20Cipher.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/cipher/ChaCha20Poly1305Cipher.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/cipher/GCMCipher.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/cipher/HybridCipher.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/cipher/HybridRsaCipher.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/cipher/OCBCipher.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/cipher/XChaCha20Poly1305Cipher.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/cipher/XSalsa20Cipher.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/cipher/XSalsa20Poly1305Cipher.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/dh/HybridDhKeyPair.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/dh/HybridDiffieHellman.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/dsa/HybridDsaKeyPair.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/ec/HybridEcKeyPair.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/ecdh/HybridECDH.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/ed25519/HybridEdKeyPair.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/hash/HybridHash.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/hkdf/HybridHkdf.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/hmac/HybridHmac.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/keys/HybridKeyObjectHandle.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/keys/KeyObjectData.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/kmac/HybridKmac.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/mldsa/HybridMlDsaKeyPair.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/mlkem/HybridMlKemKeyPair.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/pbkdf2/HybridPbkdf2.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/prime/HybridPrime.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/random/HybridRandom.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/rsa/HybridRsaKeyPair.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/scrypt/HybridScrypt.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/sign/HybridSignHandle.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/sign/HybridVerifyHandle.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/utils/HybridUtils.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/utils/QuickCryptoUtils.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/x509/HybridX509Certificate.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridArgon2Spec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridBlake3Spec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridCertificateSpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridCipherFactorySpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridCipherSpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridDhKeyPairSpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridDiffieHellmanSpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridDsaKeyPairSpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridECDHSpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridEcKeyPairSpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridEdKeyPairSpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridHashSpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridHkdfSpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridHmacSpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridKeyObjectHandleSpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridKmacSpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridMlDsaKeyPairSpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridMlKemKeyPairSpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridPbkdf2Spec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridPrimeSpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridRandomSpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridRsaCipherSpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridRsaKeyPairSpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridScryptSpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridSignHandleSpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridUtilsSpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridVerifyHandleSpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared/HybridX509CertificateHandleSpec.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitro/NitroModulesTurboModule.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitro/platform/ThreadUtils.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitro/shared/AnyMap.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitro/shared/ArrayBuffer.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitro/shared/BoxedHybridObject.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitro/shared/Dispatcher.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitro/shared/HybridNitroModulesProxy.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitro/shared/HybridObject.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitro/shared/HybridObjectPrototype.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitro/shared/HybridObjectRegistry.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitro/shared/InstallNitro.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitro/shared/JSICache.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitro/shared/NitroTypeInfo.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitro/shared/ObjectUtils.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitro/shared/Promise.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/nitro/shared/ThreadPool.cpp
+  ${QUICKCRYPTO_MODULE_ROOT}/deps/fastpbkdf2/fastpbkdf2.c
+  ${QUICKCRYPTO_MODULE_ROOT}/deps/ncrypto/src/aead.cpp
+  ${QUICKCRYPTO_MODULE_ROOT}/deps/ncrypto/src/engine.cpp
+  ${QUICKCRYPTO_MODULE_ROOT}/deps/ncrypto/src/ncrypto.cpp
+  ${QUICKCRYPTO_MODULE_ROOT}/deps/simdutf/src/simdutf.cpp
+  ${BLAKE3_SOURCES}
+  ${QUICKCRYPTO_SOURCE_DIR}/generated/RNOH/generated/turbo_modules/QuickCrypto.cpp
+  ${QUICKCRYPTO_SOURCE_DIR}/generated/RNOH/generated/dummy.cpp
+)
+
+# ============================================================================
+# Include directories
+# ============================================================================
+target_include_directories(quick_crypto PUBLIC
+  ${QUICKCRYPTO_SOURCE_DIR}
+  ${QUICKCRYPTO_SOURCE_DIR}/generated
+  ${QUICKCRYPTO_SOURCE_DIR}/generated/RNOH/generated
+  ${QUICKCRYPTO_SOURCE_DIR}/nitrogen/shared
+  ${QUICKCRYPTO_SOURCE_DIR}/nitro
+  ${QUICKCRYPTO_SOURCE_DIR}/nitro/shared
+  ${QUICKCRYPTO_SOURCE_DIR}/nitro/NitroModules
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/argon2
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/blake3
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/certificate
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/cipher
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/dh
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/dsa
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/ec
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/ecdh
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/ed25519
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/hash
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/hkdf
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/hmac
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/keys
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/kmac
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/mldsa
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/mlkem
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/pbkdf2
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/prime
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/random
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/rsa
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/scrypt
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/sign
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/utils
+  ${QUICKCRYPTO_SOURCE_DIR}/cpp/x509
+  ${QUICKCRYPTO_MODULE_ROOT}/deps/blake3
+  ${QUICKCRYPTO_MODULE_ROOT}/deps/fastpbkdf2
+  ${QUICKCRYPTO_MODULE_ROOT}/deps/ncrypto/include
+  ${QUICKCRYPTO_MODULE_ROOT}/deps/simdutf/include
+  ${QUICKCRYPTO_MODULE_ROOT}/deps/simdutf/src
+  ${QUICKCRYPTO_SOURCE_DIR}/third_party/openssl/include
+)
+
+# ============================================================================
+# RNOH include dirs (multi-candidate glob - works in har_wrapper & example)
+# ============================================================================
+set(OH_MODULE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../../../../oh_modules")
+file(GLOB _rnoh_pkg_dirs
+    "${OH_MODULE_DIR}/.ohpm/*/oh_modules/@rnoh/react-native-openharmony"
+    "${CMAKE_CURRENT_SOURCE_DIR}/../../../../../@rnoh/react-native-openharmony"
+)
+list(SORT _rnoh_pkg_dirs)
+list(LENGTH _rnoh_pkg_dirs _rnoh_pkg_count)
+if(_rnoh_pkg_count GREATER 0)
+    list(GET _rnoh_pkg_dirs 0 _rnoh_pkg_dir)
+else()
+    set(_rnoh_pkg_dir "${CMAKE_CURRENT_SOURCE_DIR}/../../../../../../example/harmony/oh_modules/@rnoh/react-native-openharmony")
+endif()
+set(RNOH_CPP_DIR "${_rnoh_pkg_dir}/src/main/include")
+# RNOH 0.77 起头文件位于顶层 include/（release HAR 布局），兼容两种布局
+if(NOT EXISTS "${RNOH_CPP_DIR}/third-party")
+    set(RNOH_CPP_DIR "${_rnoh_pkg_dir}/include")
+endif()
+message(STATUS "quick_crypto RNOH_CPP_DIR=${RNOH_CPP_DIR}")
+
+set(REACT_COMMON_PATCH_DIR "${RNOH_CPP_DIR}/patches/react_native_core")
+
+# RNOH/folly needs generated folly-config.h
+configure_file(
+  ${RNOH_CPP_DIR}/third-party/folly/CMake/folly-config.h.cmake
+  ${RNOH_CPP_DIR}/third-party/folly/folly/folly-config.h
+)
+
+target_include_directories(quick_crypto PUBLIC
+  ${RNOH_CPP_DIR}
+  ${REACT_COMMON_PATCH_DIR}
+  ${RNOH_CPP_DIR}/third-party/folly
+  ${RNOH_CPP_DIR}/third-party/rn/ReactCommon
+  ${RNOH_CPP_DIR}/third-party/rn/ReactCommon/react/nativemodule/core
+  ${RNOH_CPP_DIR}/third-party/rn/ReactCommon/jsi
+  ${RNOH_CPP_DIR}/third-party/rn/ReactCommon/callinvoker
+  ${RNOH_CPP_DIR}/third-party/boost/libs/utility/include
+  ${RNOH_CPP_DIR}/third-party/boost/libs/stacktrace/include
+  ${RNOH_CPP_DIR}/third-party/boost/libs/predef/include
+  ${RNOH_CPP_DIR}/third-party/boost/libs/array/include
+  ${RNOH_CPP_DIR}/third-party/boost/libs/throw_exception/include
+  ${RNOH_CPP_DIR}/third-party/boost/libs/config/include
+  ${RNOH_CPP_DIR}/third-party/boost/libs/core/include
+  ${RNOH_CPP_DIR}/third-party/boost/libs/preprocessor/include
+  ${RNOH_CPP_DIR}/third-party/boost/libs/mpl/include
+  ${RNOH_CPP_DIR}/third-party/boost/libs/type_traits/include
+  ${RNOH_CPP_DIR}/third-party/boost/libs/intrusive/include
+  ${RNOH_CPP_DIR}/third-party/boost/libs/assert/include
+  ${RNOH_CPP_DIR}/third-party/boost/libs/move/include
+  ${RNOH_CPP_DIR}/third-party/boost/libs/static_assert/include
+  ${RNOH_CPP_DIR}/third-party/boost/libs/container_hash/include
+  ${RNOH_CPP_DIR}/third-party/boost/libs/describe/include
+  ${RNOH_CPP_DIR}/third-party/boost/libs/mp11/include
+  ${RNOH_CPP_DIR}/third-party/boost/libs/iterator/include
+  ${RNOH_CPP_DIR}/third-party/boost/libs/detail/include
+  ${RNOH_CPP_DIR}/third-party/boost/libs/regex/include
+  ${RNOH_CPP_DIR}/third-party/double-conversion
+  ${RNOH_CPP_DIR}/third-party/rn/ReactCommon/react/renderer/graphics/platform/cxx
+  ${RNOH_CPP_DIR}/third-party/rn/ReactCommon/react/renderer/components/view/platform/cxx
+  ${RNOH_CPP_DIR}/third-party/rn/ReactCommon/runtimeexecutor
+  ${RNOH_CPP_DIR}/third-party/glog/src
+  ${RNOH_CPP_DIR}/third-party/fmt/include
+  ${RNOH_CPP_DIR}/third-party/rn/ReactCommon/yoga
+  ${RNOH_CPP_DIR}/patches/react_native_core/react/renderer/textlayoutmanager/platform/harmony
+)
+
+# ============================================================================
+# ABI alignment with the RNOH host
+# ----------------------------------------------------------------------------
+# folly/RNOH headers change layout and behaviour based on these macros — e.g.
+# FOLLY_MOBILE selects the F14 implementation backing folly::dynamic's object
+# storage, which crosses the TurboModule boundary. RNOH's prebuilt .so and the
+# host rnoh_app are compiled with them, so this module must match.
+# Set as plain definitions instead of linking the `rnoh` INTERFACE target,
+# whose -std=c++20 would also be applied to this module's .c sources.
+# ============================================================================
+target_compile_definitions(quick_crypto PRIVATE
+  FOLLY_NO_CONFIG=1
+  FOLLY_MOBILE=1
+  FOLLY_USE_LIBCPP=1
+  FOLLY_HAVE_RECVMMSG=1
+  FOLLY_HAVE_PTHREAD=1
+  REACT_NATIVE__RENDER__GRAPHICS__FLOAT=double
+  RAW_PROPS_ENABLED
+  UNSET_FORMS_STACKING_CONTEXT
+)
+
+# Follow the host's JS engine choice; react-native-harmony.cmake defaults it ON.
+if(DEFINED USE_HERMES AND NOT USE_HERMES)
+  target_compile_definitions(quick_crypto PRIVATE USE_HERMES=0)
+else()
+  target_compile_definitions(quick_crypto PRIVATE USE_HERMES=1)
+endif()
+
+# ============================================================================
+# Compiler definitions - force portable BLAKE3 (no x86 SIMD assembly)
+# ============================================================================
+target_compile_definitions(quick_crypto PRIVATE
+  BLAKE3_NO_SSE2
+  BLAKE3_NO_SSE41
+  BLAKE3_NO_AVX2
+  BLAKE3_NO_AVX512
+)
+
+# ============================================================================
+# Link libraries
+# ============================================================================
+# RNOH prebuilt libs (HAR build: link RNOH's prebuilt .so to resolve symbols)
+set(RNOH_LIB_DIR "${_rnoh_pkg_dir}/libs/arm64-v8a")
+target_link_directories(quick_crypto PUBLIC "${RNOH_LIB_DIR}")
+
+# RNOH 0.77 为 unified librnoh_core.so；RNOH 0.72 为拆分 .so（rnoh_semi/react_nativemodule_core），按实际布局选择
+if(EXISTS "${RNOH_LIB_DIR}/librnoh_core.so")
+  set(_rnoh_core_libs rnoh_core)
+else()
+  set(_rnoh_core_libs rnoh_semi react_nativemodule_core)
+endif()
+
+target_link_libraries(quick_crypto PUBLIC
+  ${_rnoh_core_libs}
+  jsi
+  libhilog_ndk.z.so
+  libace_napi.z.so
+  libc++_shared.so
+  ${QUICKCRYPTO_SOURCE_DIR}/third_party/openssl/lib/libcrypto.a
+  ${QUICKCRYPTO_SOURCE_DIR}/third_party/openssl/lib/libssl.a
+)
+
+target_compile_options(quick_crypto PRIVATE
+  -fexceptions
+  -frtti
+  -fPIC
+)

package/harmony/quick_crypto/src/main/cpp/QuickCryptoOnLoad.cpp

@@ -0,0 +1,211 @@
+#include "QuickCryptoOnLoad.hpp"
+
+#include <NitroModules/HybridObjectRegistry.hpp>
+
+#include "HybridArgon2.hpp"
+#include "HybridBlake3.hpp"
+#include "HybridCertificate.hpp"
+#include "HybridCipher.hpp"
+#include "HybridCipherFactory.hpp"
+#include "HybridDhKeyPair.hpp"
+#include "HybridDiffieHellman.hpp"
+#include "HybridDsaKeyPair.hpp"
+#include "HybridECDH.hpp"
+#include "HybridEcKeyPair.hpp"
+#include "HybridEdKeyPair.hpp"
+#include "HybridHash.hpp"
+#include "HybridHkdf.hpp"
+#include "HybridHmac.hpp"
+#include "HybridKmac.hpp"
+#include "HybridKeyObjectHandle.hpp"
+#include "HybridMlDsaKeyPair.hpp"
+#include "HybridMlKemKeyPair.hpp"
+#include "HybridPbkdf2.hpp"
+#include "HybridPrime.hpp"
+#include "HybridRandom.hpp"
+#include "HybridRsaCipher.hpp"
+#include "HybridRsaKeyPair.hpp"
+#include "HybridScrypt.hpp"
+#include "HybridSignHandle.hpp"
+#include "HybridUtils.hpp"
+#include "HybridVerifyHandle.hpp"
+#include "HybridX509Certificate.hpp"
+
+namespace margelo::nitro::crypto {
+
+void initialize() {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::crypto;
+
+  // Register Nitro Hybrid Objects
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Argon2",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridArgon2>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Blake3",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridBlake3>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Certificate",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridCertificate>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Cipher",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridCipher>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "CipherFactory",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridCipherFactory>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "DhKeyPair",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridDhKeyPair>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "DiffieHellman",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridDiffieHellman>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "DsaKeyPair",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridDsaKeyPair>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "ECDH",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridECDH>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "EcKeyPair",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridEcKeyPair>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "EdKeyPair",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridEdKeyPair>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Hash",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridHash>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Hkdf",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridHkdf>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Hmac",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridHmac>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Kmac",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridKmac>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "KeyObjectHandle",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridKeyObjectHandle>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "MlDsaKeyPair",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridMlDsaKeyPair>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "MlKemKeyPair",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridMlKemKeyPair>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Pbkdf2",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridPbkdf2>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Prime",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridPrime>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Random",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridRandom>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "RsaCipher",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridRsaCipher>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "RsaKeyPair",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridRsaKeyPair>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Scrypt",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridScrypt>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "SignHandle",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridSignHandle>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Utils",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridUtils>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "VerifyHandle",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridVerifyHandle>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "X509CertificateHandle",
+    []() -> std::shared_ptr<HybridObject> {
+      return std::make_shared<HybridX509Certificate>();
+    }
+  );
+}
+
+} // namespace margelo::nitro::crypto

package/harmony/quick_crypto/src/main/cpp/QuickCryptoOnLoad.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+namespace margelo::nitro::crypto {
+
+/**
+ * Registers all 28 Hybrid Objects of QuickCrypto into the Nitro
+ * HybridObjectRegistry.
+ *
+ * This is the OHOS (HarmonyOS) entry point — a JNI-free equivalent of the
+ * generated Android `QuickCryptoOnLoad.cpp`. It is invoked once from the
+ * `QuickCryptoPackage` (rnoh::Package) constructor, which runs before any
+ * JS `createHybridObject(...)` call.
+ */
+void initialize();
+
+} // namespace margelo::nitro::crypto

package/harmony/quick_crypto/src/main/cpp/QuickCryptoPackage.h

@@ -0,0 +1,50 @@
+#ifndef QUICKCRYPTOPACKAGE_H
+#define QUICKCRYPTOPACKAGE_H
+
+#include "generated/RNOH/generated/BaseQuickCryptoPackage.h"
+#include "generated/RNOH/generated/turbo_modules/QuickCrypto.h"
+#include "nitro/NitroModulesTurboModule.h"
+#include "QuickCryptoOnLoad.hpp"
+#pragma once
+
+namespace rnoh {
+
+/**
+ * Combined TurboModule factory delegate: registers both the NitroModules
+ * TurboModule (needed to install `global.NitroModulesProxy`) and the QuickCrypto
+ * bridge TurboModule.
+ *
+ * The Nitro runtime is vendored into this module (see `nitro/`), so this
+ * package is self-contained — no external `@react-native-ohos/react-native-nitro-modules`
+ * ohpm dependency is required.
+ */
+class QuickCryptoTurboModuleFactoryDelegate : public TurboModuleFactoryDelegate {
+public:
+  SharedTurboModule createTurboModule(Context ctx, const std::string &name) const override {
+    if (name == "NitroModules") {
+      return std::make_shared<NitroModulesTurboModule>(ctx, name);
+    }
+    if (name == "QuickCrypto") {
+      return std::make_shared<QuickCrypto>(ctx, name);
+    }
+    return nullptr;
+  }
+};
+
+class QuickCryptoPackage : public BaseQuickCryptoPackage {
+    using Super = BaseQuickCryptoPackage;
+public:
+    using Super::Super;
+
+    explicit QuickCryptoPackage(Package::Context ctx) : Super(ctx) {
+        // Register the 28 QuickCrypto Hybrid Objects into the Nitro runtime.
+        // Runs before any JS `NitroModules.createHybridObject(...)` call.
+        margelo::nitro::crypto::initialize();
+    }
+
+    std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate() override {
+        return std::make_unique<QuickCryptoTurboModuleFactoryDelegate>();
+    }
+};
+} // namespace rnoh
+#endif //QUICKCRYPTOPACKAGE_H

package/harmony/quick_crypto/src/main/cpp/cpp/argon2/HybridArgon2.cpp

@@ -0,0 +1,103 @@
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include <ncrypto.h>
+#include <openssl/err.h>
+#include <openssl/opensslv.h>
+#include <string>
+
+#include "HybridArgon2.hpp"
+#include "QuickCryptoUtils.hpp"
+
+namespace margelo::nitro::crypto {
+
+#if OPENSSL_VERSION_NUMBER >= 0x30200000L
+#ifndef OPENSSL_NO_ARGON2
+
+static ncrypto::Argon2Type parseAlgorithm(const std::string& algo) {
+  if (algo == "argon2d")
+    return ncrypto::Argon2Type::ARGON2D;
+  if (algo == "argon2i")
+    return ncrypto::Argon2Type::ARGON2I;
+  if (algo == "argon2id")
+    return ncrypto::Argon2Type::ARGON2ID;
+  throw std::runtime_error("Unknown argon2 algorithm: " + algo);
+}
+
+static std::shared_ptr<ArrayBuffer> hashImpl(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& message,
+                                             const std::shared_ptr<ArrayBuffer>& nonce, double parallelism, double tagLength, double memory,
+                                             double passes, double version, const std::optional<std::shared_ptr<ArrayBuffer>>& secret,
+                                             const std::optional<std::shared_ptr<ArrayBuffer>>& associatedData) {
+
+  auto type = parseAlgorithm(algorithm);
+
+  ncrypto::Buffer<const char> passBuf{message->size() > 0 ? reinterpret_cast<const char*>(message->data()) : "", message->size()};
+
+  ncrypto::Buffer<const unsigned char> saltBuf{nonce->size() > 0 ? reinterpret_cast<const unsigned char*>(nonce->data())
+                                                                 : reinterpret_cast<const unsigned char*>(""),
+                                               nonce->size()};
+
+  ncrypto::Buffer<const unsigned char> secretBuf{nullptr, 0};
+  if (secret.has_value() && secret.value()->size() > 0) {
+    secretBuf = {reinterpret_cast<const unsigned char*>(secret.value()->data()), secret.value()->size()};
+  }
+
+  ncrypto::Buffer<const unsigned char> adBuf{nullptr, 0};
+  if (associatedData.has_value() && associatedData.value()->size() > 0) {
+    adBuf = {reinterpret_cast<const unsigned char*>(associatedData.value()->data()), associatedData.value()->size()};
+  }
+
+  auto result =
+      ncrypto::argon2(passBuf, saltBuf, static_cast<uint32_t>(parallelism), static_cast<size_t>(tagLength), static_cast<uint32_t>(memory),
+                      static_cast<uint32_t>(passes), static_cast<uint32_t>(version), secretBuf, adBuf, type);
+
+  if (!result) {
+    unsigned long err = ERR_peek_last_error();
+    const char* reason = err ? ERR_reason_error_string(err) : nullptr;
+    throw std::runtime_error(reason ? std::string("Argon2 operation failed: ") + reason : "Argon2 operation failed");
+  }
+
+  return ToNativeArrayBuffer(reinterpret_cast<const uint8_t*>(result.get()), result.size());
+}
+
+#endif // OPENSSL_NO_ARGON2
+#endif // OPENSSL_VERSION_NUMBER
+
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
+HybridArgon2::hash(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& message, const std::shared_ptr<ArrayBuffer>& nonce,
+                   double parallelism, double tagLength, double memory, double passes, double version,
+                   const std::optional<std::shared_ptr<ArrayBuffer>>& secret,
+                   const std::optional<std::shared_ptr<ArrayBuffer>>& associatedData) {
+#if OPENSSL_VERSION_NUMBER >= 0x30200000L && !defined(OPENSSL_NO_ARGON2)
+  auto nativeMessage = ToNativeArrayBuffer(message);
+  auto nativeNonce = ToNativeArrayBuffer(nonce);
+  std::optional<std::shared_ptr<ArrayBuffer>> nativeSecret;
+  if (secret.has_value()) {
+    nativeSecret = ToNativeArrayBuffer(secret.value());
+  }
+  std::optional<std::shared_ptr<ArrayBuffer>> nativeAd;
+  if (associatedData.has_value()) {
+    nativeAd = ToNativeArrayBuffer(associatedData.value());
+  }
+
+  return Promise<std::shared_ptr<ArrayBuffer>>::async([algorithm, nativeMessage, nativeNonce, parallelism, tagLength, memory, passes,
+                                                       version, nativeSecret = std::move(nativeSecret), nativeAd = std::move(nativeAd)]() {
+    return hashImpl(algorithm, nativeMessage, nativeNonce, parallelism, tagLength, memory, passes, version, nativeSecret, nativeAd);
+  });
+#else
+  throw std::runtime_error("Argon2 is not supported (requires OpenSSL 3.2+)");
+#endif
+}
+
+std::shared_ptr<ArrayBuffer> HybridArgon2::hashSync(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& message,
+                                                    const std::shared_ptr<ArrayBuffer>& nonce, double parallelism, double tagLength,
+                                                    double memory, double passes, double version,
+                                                    const std::optional<std::shared_ptr<ArrayBuffer>>& secret,
+                                                    const std::optional<std::shared_ptr<ArrayBuffer>>& associatedData) {
+#if OPENSSL_VERSION_NUMBER >= 0x30200000L && !defined(OPENSSL_NO_ARGON2)
+  return hashImpl(algorithm, message, nonce, parallelism, tagLength, memory, passes, version, secret, associatedData);
+#else
+  throw std::runtime_error("Argon2 is not supported (requires OpenSSL 3.2+)");
+#endif
+}
+
+} // namespace margelo::nitro::crypto