react-native-quick-crypto 1.0.0-beta.2 → 1.0.0-beta.20

package/QuickCrypto.podspec

@@ -2,7 +2,7 @@ require "json"
 
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
 
-Pod::UI.puts "[QuickCrypto] crypto just got quicker 💨"
+Pod::UI.puts "[QuickCrypto]  💨 crypto just got quicker"
 
 Pod::Spec.new do |s|
   s.name         = "QuickCrypto"
@@ -12,23 +12,96 @@ Pod::Spec.new do |s|
   s.license      = package["license"]
   s.authors      = package["authors"]
 
-  s.platforms    = { :ios => min_ios_version_supported }
-  s.source       = { :git => "https://github.com/margelo/react-native-quick-crypto.git", :tag => "#{s.version}" }
+  s.ios.deployment_target = min_ios_version_supported
+  s.visionos.deployment_target = 1.0
+  s.macos.deployment_target = 10.13
+  s.tvos.deployment_target = 13.4
 
-  s.source_files = [
+  s.source = { :git => "https://github.com/margelo/react-native-quick-crypto.git", :tag => "#{s.version}" }
+
+  sodium_enabled = ENV['SODIUM_ENABLED'] == '1'
+  Pod::UI.puts("[QuickCrypto]  🧂 has libsodium #{sodium_enabled ? "enabled" : "disabled"}!")
+
+  if sodium_enabled
+    # cocoapod for Sodium has not been updated for a while, so we need to build it ourselves
+    # https://github.com/jedisct1/swift-sodium/issues/264#issuecomment-2864963850
+    s.prepare_command = <<-CMD
+      # Create ios directory if it doesn't exist
+      mkdir -p ios
+
+      # Download libsodium
+      curl -L -s -o ios/libsodium.tar.gz https://download.libsodium.org/libsodium/releases/libsodium-1.0.20-stable.tar.gz
+
+      # Clean previous extraction
+      rm -rf ios/libsodium-stable
+
+      # Extract the full tarball
+      tar -xzf ios/libsodium.tar.gz -C ios
+
+      # Run configure and make to generate all headers including private ones
+      cd ios/libsodium-stable && \
+      ./configure --disable-shared --enable-static && \
+      make -j$(sysctl -n hw.ncpu)
+
+      # Cleanup
+      cd ../../
+      rm -f ios/libsodium.tar.gz
+    CMD
+  else
+    s.prepare_command = <<-CMD
+      # Clean up libsodium files if they exist
+      rm -rf ios/libsodium-stable
+      rm -f ios/libsodium.tar.gz
+    CMD
+  end
+
+  base_source_files = [
     # implementation (Swift)
     "ios/**/*.{swift}",
     # ios (Objective-C++)
     "ios/**/*.{h,m,mm}",
     # implementation (C++)
     "cpp/**/*.{hpp,cpp}",
+    # dependencies (C++)
+    "deps/**/*.{hpp,cpp}",
+    # dependencies (C)
+    "deps/**/*.{h,c}",
   ]
 
+  if sodium_enabled
+    base_source_files += ["ios/libsodium-stable/src/libsodium/**/*.{h,c}"]
+  end
+
+  s.source_files = base_source_files
+
+  xcconfig = {
+    # C++ compiler flags, mainly for folly.
+    "GCC_PREPROCESSOR_DEFINITIONS" => "$(inherited) FOLLY_NO_CONFIG FOLLY_CFG_NO_COROUTINES",
+    # Set C++ standard to C++20
+    "CLANG_CXX_LANGUAGE_STANDARD" => "c++20",
+    "CLANG_ALLOW_NON_MODULAR_INCLUDES_IN_FRAMEWORK_MODULES" => "YES"
+  }
+
+  if sodium_enabled
+    sodium_headers = [
+      "\"$(PODS_TARGET_SRCROOT)/ios/libsodium-stable/src/libsodium/include\"",
+      "\"$(PODS_TARGET_SRCROOT)/ios/libsodium-stable/src/libsodium/include/sodium\"",
+      "\"$(PODS_TARGET_SRCROOT)/ios/libsodium-stable\"",
+      "\"$(PODS_ROOT)/../../packages/react-native-quick-crypto/ios/libsodium-stable/src/libsodium/include\"",
+      "\"$(PODS_ROOT)/../../packages/react-native-quick-crypto/ios/libsodium-stable/src/libsodium/include/sodium\""
+    ]
+    xcconfig["HEADER_SEARCH_PATHS"] = sodium_headers.join(' ')
+    xcconfig["GCC_PREPROCESSOR_DEFINITIONS"] = "$(inherited) BLSALLOC_SODIUM=1"
+  end
+
+  s.pod_target_xcconfig = xcconfig
+
   # Add all files generated by Nitrogen
-  load 'nitrogen/generated/ios/QuickCrypto+autolinking.rb'
+  load "nitrogen/generated/ios/QuickCrypto+autolinking.rb"
   add_nitrogen_files(s)
 
-  install_modules_dependencies(s)
+  s.dependency "React-jsi"
+  s.dependency "React-callinvoker"
   s.dependency "OpenSSL-Universal"
-
+  install_modules_dependencies(s)
 end

package/README.md

@@ -1,12 +1,18 @@
-<a href="https://margelo.io">
-  <img src="./docs/img/banner.svg" width="100%" />
+<a href="https://margelo.com">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="./docs/img/banner-dark.png" />
+    <source media="(prefers-color-scheme: light)" srcset="./docs/img/banner-light.png" />
+    <img alt="react-native-quick-crypto" src="./docs/img/banner-light.png" />
+  </picture>
 </a>
 
 # ⚡️ react-native-quick-crypto
 
 A fast implementation of Node's `crypto` module.
 
-> Note: This version `1.x` is undergoing a major refactor, porting to New Architecture, Bridgeless, and [`Nitro Modules`](https://github.com/mrousavy/react-native-nitro) and is incomplete compared to the `0.x` version.  Status, as always, will be represented in [implementation-coverage.md](../blob/main/docs/implementation-coverage.md).
+> Note: This version `1.x` is undergoing a major refactor, porting to New Architecture, Bridgeless, and [`Nitro Modules`](https://github.com/mrousavy/react-native-nitro) and is incomplete compared to the `0.x` version.  Status, as always, will be represented in [implementation-coverage.md](../main/docs/implementation-coverage.md).
+
+> Note: Minimum supported version of React Native is `0.75`.  If you need to use earlier versions, please use `0.x` versions of this library.
 
 ## Features
 
@@ -24,8 +30,8 @@ QuickCrypto can be used as a drop-in replacement for your Web3/Crypto apps to sp
 
 | Version | RN Architecture | Modules |
 | ------- | ------ | ------- |
-| `1.x`     | new [->](https://github.com/reactwg/react-native-new-architecture/blob/main/docs/enable-apps.md)  | Nitro Modules [->](https://github.com/margelo/react-native-nitro) |
-| `0.x`     | old  | Bridge & JSI |
+| `1.x`     | new [->](https://github.com/reactwg/react-native-new-architecture/blob/main/docs/enable-apps.md)  | Nitro Modules [->](https://github.com/mrousavy/nitro) |
+| `0.x`     | old, new 🤞  | Bridge & JSI |
 
 ## Benchmarks
 
@@ -59,7 +65,7 @@ Creating a Wallet took 289 ms
 </h3>
 
 ```sh
-yarn add react-native-quick-crypto
+bun add react-native-quick-crypto react-native-nitro-modules
 cd ios && pod install
 ```
 

package/android/CMakeLists.txt

@@ -1,8 +1,7 @@
+project(QuickCrypto)
 cmake_minimum_required(VERSION 3.9.0)
 
-project(QuickCrypto)
 set(PACKAGE_NAME QuickCrypto)
-
 set(CMAKE_VERBOSE_MAKEFILE ON)
 set(CMAKE_CXX_STANDARD 20)
 
@@ -10,35 +9,67 @@ set(CMAKE_CXX_STANDARD 20)
 add_library(
   ${PACKAGE_NAME} SHARED
   src/main/cpp/cpp-adapter.cpp
+  ../cpp/cipher/CCMCipher.cpp
+  ../cpp/cipher/HybridCipher.cpp
+  ../cpp/cipher/OCBCipher.cpp
+  ../cpp/cipher/XSalsa20Cipher.cpp
+  ../cpp/cipher/ChaCha20Cipher.cpp
+  ../cpp/cipher/ChaCha20Poly1305Cipher.cpp
+  ../cpp/ed25519/HybridEdKeyPair.cpp
+  ../cpp/hash/HybridHash.cpp
+  ../cpp/hmac/HybridHmac.cpp
+  ../cpp/pbkdf2/HybridPbkdf2.cpp
   ../cpp/random/HybridRandom.cpp
+  ../deps/fastpbkdf2/fastpbkdf2.c
 )
 
-include_directories(../cpp)
+# add Nitrogen specs
 include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/QuickCrypto+autolinking.cmake)
 
+# local includes
+include_directories(
+  "src/main/cpp"
+  "../cpp/cipher"
+  "../cpp/ed25519"
+  "../cpp/hash"
+  "../cpp/hmac"
+  "../cpp/pbkdf2"
+  "../cpp/random"
+  "../cpp/utils"
+  "../deps/fastpbkdf2"
+)
+
 # Third party libraries (Prefabs)
 find_library(LOG_LIB log)
 
-find_package(ReactAndroid REQUIRED CONFIG)
-find_package(fbjni REQUIRED CONFIG)
 find_package(openssl REQUIRED CONFIG)
 
 # Link all libraries together
 target_link_libraries(
   ${PACKAGE_NAME}
-  ${LOG_LIB}                             # <-- Logcat logger
-  android                                # <-- Android core
-  fbjni::fbjni                           # <-- Facebook C++ JNI helpers
-  openssl::crypto                        # <-- OpenSSL (Crypto)
-  ReactAndroid::jsi
-  ReactAndroid::turbomodulejsijni
-  ReactAndroid::react_nativemodule_core
-  ReactAndroid::react_render_core
-  ReactAndroid::runtimeexecutor
-  ReactAndroid::fabricjni
-  ReactAndroid::react_debug
-  ReactAndroid::react_render_core
-  ReactAndroid::react_render_componentregistry
-  ReactAndroid::rrc_view
-  ReactAndroid::folly_runtime
+  ${LOG_LIB}                               # <-- Logcat logger
+  android                                  # <-- Android core
+  openssl::crypto                          # <-- OpenSSL   (Crypto)
+)
+
+if(SODIUM_ENABLED)
+  add_definitions(-DBLSALLOC_SODIUM)
+  find_package(sodium REQUIRED CONFIG)
+  target_link_libraries(
+    ${PACKAGE_NAME}
+    sodium::sodium
+  )
+endif()
+
+if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
+  target_link_libraries(
+    ${PACKAGE_NAME}
+    ReactAndroid::reactnative              # <-- RN: Native Modules umbrella prefab
+  )
+else()
+  target_link_libraries(
+    ${PACKAGE_NAME}
+    ReactAndroid::react_nativemodule_core  # <-- RN: TurboModules Core
+    ReactAndroid::turbomodulejsijni        # <-- RN: TurboModules utils (e.g. CallInvokerHolder)
   )
+endif()

package/android/build.gradle

@@ -7,7 +7,7 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:8.2.2"
+    classpath "com.android.tools.build:gradle:8.7.3"
     classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}"
   }
 }
@@ -37,6 +37,9 @@ def getExtOrIntegerDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["QuickCrypto_" + name]).toInteger()
 }
 
+def sodiumEnabled = hasProperty('sodiumEnabled') ? project.property('sodiumEnabled').toBoolean() : false // Default to false
+logger.warn("[QuickCrypto] Has libsodium ${sodiumEnabled ? "enabled" : "disabled"}!")
+
 android {
   namespace "com.margelo.nitro.quickcrypto"
   ndkVersion getExtOrDefault("ndkVersion")
@@ -49,9 +52,20 @@ android {
 
     externalNativeBuild {
       cmake {
-        cppFlags "-O2 -frtti -fexceptions -Wall -fstack-protector-all"
-        arguments "-DANDROID_STL=c++_shared"
+        cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared",
+                  "-DSODIUM_ENABLED=${sodiumEnabled}",
+                  "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
         abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
       }
     }
   }
@@ -67,6 +81,27 @@ android {
     prefab true
   }
 
+packagingOptions {
+    excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libfolly_json.so",
+            "**/libfolly_runtime.so",
+            "**/libglog.so",
+            "**/libhermes.so",
+            "**/libhermes-executor-debug.so",
+            "**/libhermes_executor.so",
+            "**/libreactnative.so",
+            "**/libreactnativejni.so",
+            "**/libturbomodulejsijni.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libjscexecutor.so"
+    ]
+  }
+
   buildTypes {
     release {
       minifyEnabled false
@@ -104,8 +139,16 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
 
+  // Add a dependency on NitroModules
   implementation project(":react-native-nitro-modules")
-  implementation "com.android.ndk.thirdparty:openssl:1.1.1q-beta-1"
+
+  // Add a dependency on OpenSSL
+  implementation 'io.github.ronickg:openssl:3.3.2-1'
+
+  if (sodiumEnabled) {
+    // Add a dependency on libsodium
+    implementation 'io.github.ronickg:sodium:1.0.20-1'
+  }
 }
 
 if (isNewArchitectureEnabled()) {

package/android/src/main/cpp/cpp-adapter.cpp

@@ -1,15 +1,8 @@
+#include <fbjni/fbjni.h>
 #include <jni.h>
 
-#include "random/HybridRandom.hpp"
-#include <NitroModules/HybridObjectRegistry.hpp>
-
-using namespace margelo::nitro::crypto;
-using namespace margelo::crypto;
+#include "QuickCryptoOnLoad.hpp"
 
 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
-  HybridObjectRegistry::registerHybridObjectConstructor(
-    "Random", []() -> std::shared_ptr<HybridObject> { return std::make_shared<HybridRandom>();
-  });
-
-  return JNI_VERSION_1_2;
+  return facebook::jni::initialize(vm, [=] { margelo::nitro::crypto::initialize(vm); });
 }

package/android/src/main/java/com/margelo/nitro/quickcrypto/QuickCryptoPackage.java

@@ -1,6 +1,7 @@
 package com.margelo.nitro.quickcrypto;
 
 import android.util.Log;
+
 import androidx.annotation.Nullable;
 
 import com.facebook.react.bridge.NativeModule;
@@ -9,19 +10,10 @@ import com.facebook.react.module.model.ReactModuleInfoProvider;
 import com.facebook.react.TurboReactPackage;
 
 import java.util.HashMap;
+import java.util.function.Supplier;
 
 public class QuickCryptoPackage extends TurboReactPackage {
   private static final String TAG = "QuickCrypto";
-  static {
-    try {
-      Log.i(TAG, "Loading C++ library...");
-      System.loadLibrary(TAG);
-      Log.i(TAG, "Successfully loaded C++ library!");
-    } catch (Throwable e) {
-      Log.e(TAG, "Failed to load C++ library! Is it properly installed and linked?", e);
-      throw e;
-    }
-  }
 
   @Nullable
   @Override
@@ -35,4 +27,15 @@ public class QuickCryptoPackage extends TurboReactPackage {
       return new HashMap<>();
     };
   }
+
+  static {
+    try {
+      Log.i(TAG, "Loading C++ library...");
+      System.loadLibrary(TAG);
+      Log.i(TAG, "Successfully loaded C++ library!");
+    } catch (Throwable e) {
+      Log.e(TAG, "Failed to load C++ library! Is it properly installed and linked?", e);
+      throw e;
+    }
+  }
 }

package/app.plugin.js

@@ -0,0 +1,3 @@
+const { createRNQCPlugin } = require('./lib/commonjs/expo-plugin/withRNQC');
+const pkg = require('./package.json');
+module.exports = createRNQCPlugin(pkg.name, pkg.version);

package/cpp/cipher/CCMCipher.cpp

@@ -0,0 +1,199 @@
+#include "CCMCipher.hpp"
+#include "Utils.hpp"
+#include <openssl/err.h>
+#include <openssl/evp.h>
+#include <stdexcept>
+
+namespace margelo::nitro::crypto {
+
+void CCMCipher::init(const std::shared_ptr<ArrayBuffer> cipher_key, const std::shared_ptr<ArrayBuffer> iv) {
+  // 1. Call the base class initializer first
+  try {
+    HybridCipher::init(cipher_key, iv);
+  } catch (const std::exception& e) {
+    throw; // Re-throw after logging
+  }
+
+  // Ensure context is valid after base init
+  checkCtx();
+
+  // 2. Perform CCM-specific initialization
+  auto native_iv = ToNativeArrayBuffer(iv);
+  size_t iv_len = native_iv->size();
+
+  // Set the IV length using CCM-specific control
+  if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_CCM_SET_IVLEN, iv_len, nullptr) != 1) {
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("CCMCipher: Failed to set IV length: " + std::string(err_buf));
+  }
+
+  // Set the expected/output tag length using CCM-specific control.
+  // auth_tag_len should have been defaulted or set via setArgs in the base init.
+  if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_CCM_SET_TAG, auth_tag_len, nullptr) != 1) {
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("CCMCipher: Failed to set tag length: " + std::string(err_buf));
+  }
+
+  // Finally, initialize the key and IV using the parameters passed to this function.
+  auto native_key = ToNativeArrayBuffer(cipher_key); // Use 'cipher_key' parameter
+  const unsigned char* key_ptr = reinterpret_cast<const unsigned char*>(native_key->data());
+  const unsigned char* iv_ptr = reinterpret_cast<const unsigned char*>(native_iv->data());
+
+  // The last argument (is_cipher) should be consistent with the initial setup call.
+  if (EVP_CipherInit_ex(ctx, nullptr, nullptr, key_ptr, iv_ptr, is_cipher) != 1) {
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("CCMCipher: Failed to set key/IV: " + std::string(err_buf));
+  }
+}
+
+std::shared_ptr<ArrayBuffer> CCMCipher::update(const std::shared_ptr<ArrayBuffer>& data) {
+  checkCtx();
+  auto native_data = ToNativeArrayBuffer(data);
+  size_t in_len = native_data->size();
+  if (in_len < 0 || in_len > INT_MAX) {
+    throw std::runtime_error("Invalid message length");
+  }
+  int out_len = 0;
+
+  if (!is_cipher) {
+    maybePassAuthTagToOpenSSL();
+  }
+
+  int block_size = EVP_CIPHER_CTX_block_size(ctx);
+  if (block_size <= 0) {
+    throw std::runtime_error("Invalid block size in update");
+  }
+  out_len = in_len + block_size - 1;
+  if (out_len < 0 || out_len < in_len) {
+    throw std::runtime_error("Calculated output buffer size invalid in update");
+  }
+
+  auto out_buf = std::make_unique<unsigned char[]>(out_len);
+  const uint8_t* in = reinterpret_cast<const uint8_t*>(native_data->data());
+
+  int actual_out_len = 0;
+  int ret = EVP_CipherUpdate(ctx, out_buf.get(), &actual_out_len, in, in_len);
+
+  if (!is_cipher) {
+    // Decryption: Check for tag verification failure
+    if (ret <= 0) {
+      // Tag verification failed (or other decryption error)
+      throw std::runtime_error("CCM Decryption: Tag verification failed");
+    }
+  } else {
+    // Encryption: Check for standard errors
+    if (ret != 1) {
+      pending_auth_failed = true; // Should this be set for encryption failure?
+      unsigned long err = ERR_get_error();
+      char err_buf[256];
+      ERR_error_string_n(err, err_buf, sizeof(err_buf));
+      throw std::runtime_error("Error in update() performing encryption operation: " + std::string(err_buf));
+    }
+  }
+  // If we reached here, the operation (encryption or decryption) succeeded
+
+  unsigned char* final_output = out_buf.release();
+  return std::make_shared<NativeArrayBuffer>(final_output, actual_out_len, [=]() { delete[] final_output; });
+}
+
+std::shared_ptr<ArrayBuffer> CCMCipher::final() {
+  checkCtx();
+
+  // CCM decryption does not use final. Verification happens in the last update call.
+  if (!is_cipher) {
+    // Return an empty buffer, matching Node.js behavior
+    unsigned char* empty_output = new unsigned char[0];
+    return std::make_shared<NativeArrayBuffer>(empty_output, 0, [=]() { delete[] empty_output; });
+  }
+
+  // Proceed only for encryption
+  int block_size = EVP_CIPHER_CTX_block_size(ctx);
+  if (block_size <= 0) {
+    throw std::runtime_error("Invalid block size");
+  }
+  auto out_buf = std::make_unique<unsigned char[]>(block_size);
+  int out_len = 0;
+
+  if (!EVP_CipherFinal_ex(ctx, out_buf.get(), &out_len)) {
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("Encryption finalization failed: " + std::string(err_buf));
+  }
+
+  if (auth_tag_len == 0) {
+    auth_tag_len = sizeof(auth_tag);
+  }
+
+  if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_CCM_GET_TAG, auth_tag_len, auth_tag) != 1) {
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("Failed to get auth tag after finalization: " + std::string(err_buf));
+  }
+  auth_tag_state = kAuthTagKnown;
+
+  unsigned char* final_output = out_buf.release();
+  return std::make_shared<NativeArrayBuffer>(final_output, out_len, [=]() { delete[] final_output; });
+}
+
+bool CCMCipher::setAAD(const std::shared_ptr<ArrayBuffer>& data, std::optional<double> plaintextLength) {
+  checkCtx();
+  if (!plaintextLength.has_value()) {
+    throw std::runtime_error("CCM mode requires plaintextLength to be set");
+  }
+
+  // IMPORTANT: For CCM decryption (!is_cipher), OpenSSL requires this initial update
+  // call to specify the TOTAL LENGTH OF THE CIPHERTEXT, not the plaintext.
+  // The caller (JS) must ensure `plaintextLength` holds the ciphertext length when decrypting.
+  int data_len = static_cast<int>(plaintextLength.value());
+  if (data_len > kMaxMessageSize) {
+    throw std::runtime_error("Provided data length exceeds maximum allowed size");
+  }
+
+  if (!is_cipher) {
+    if (!maybePassAuthTagToOpenSSL()) {
+      unsigned long err = ERR_get_error();
+      char err_buf[256];
+      ERR_error_string_n(err, err_buf, sizeof(err_buf));
+      throw std::runtime_error("setAAD: Failed to set auth tag parameters: " + std::string(err_buf));
+    }
+  }
+
+  int out_len = 0;
+
+  // Get AAD data and length *before* deciding whether to set total length
+  auto native_aad = ToNativeArrayBuffer(data);
+  size_t aad_len = native_aad->size();
+
+  // 1. Set the total *ciphertext* length. This seems necessary based on examples,
+  //    BUT the wiki says "(only needed if AAD is passed)". Let's skip if decrypting and AAD length is 0.
+  bool should_set_total_length = is_cipher || aad_len > 0;
+  if (should_set_total_length) {
+    if (EVP_CipherUpdate(ctx, nullptr, &out_len, nullptr, data_len) != 1) {
+      unsigned long err = ERR_get_error();
+      char err_buf[256];
+      ERR_error_string_n(err, err_buf, sizeof(err_buf));
+      throw std::runtime_error("CCMCipher: Failed to set expected length: " + std::string(err_buf));
+    }
+  }
+
+  // 2. Process AAD Data
+  // Per OpenSSL CCM decryption examples, this MUST be called even if aad_len is 0.
+  // Pass nullptr as the output buffer, the AAD data pointer, and its length.
+  if (EVP_CipherUpdate(ctx, nullptr, &out_len, native_aad->data(), aad_len) != 1) {
+    unsigned long err = ERR_get_error();
+    char err_buf[256];
+    ERR_error_string_n(err, err_buf, sizeof(err_buf));
+    throw std::runtime_error("CCMCipher: Failed to update AAD: " + std::string(err_buf));
+  }
+  return true;
+}
+
+} // namespace margelo::nitro::crypto

package/cpp/cipher/CCMCipher.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "HybridCipher.hpp"
+
+namespace margelo::nitro::crypto {
+
+class CCMCipher : public HybridCipher {
+ public:
+  CCMCipher() : HybridObject(TAG) {}
+  ~CCMCipher() {
+    // Let parent destructor free the context
+    ctx = nullptr;
+  }
+
+  void init(const std::shared_ptr<ArrayBuffer> cipher_key, const std::shared_ptr<ArrayBuffer> iv) override;
+  std::shared_ptr<ArrayBuffer> update(const std::shared_ptr<ArrayBuffer>& data) override;
+  std::shared_ptr<ArrayBuffer> final() override;
+  bool setAAD(const std::shared_ptr<ArrayBuffer>& data, std::optional<double> plaintextLength) override;
+
+ private:
+  // CCM mode supports messages up to 2^(8L) - 1 bytes where L is the length of nonce
+  // With a 12-byte nonce (L=3), max size is 2^24 - 1 bytes
+  static constexpr int kMaxMessageSize = (1 << 24) - 1;
+};
+
+} // namespace margelo::nitro::crypto