react-native-quick-crypto 1.0.0-beta.13 → 1.0.0-beta.14

package/nitrogen/generated/shared/c++/HybridCipherSpec.cpp

@@ -0,0 +1,28 @@
+///
+/// HybridCipherSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridCipherSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+  void HybridCipherSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("update", &HybridCipherSpec::update);
+      prototype.registerHybridMethod("final", &HybridCipherSpec::final);
+      prototype.registerHybridMethod("setArgs", &HybridCipherSpec::setArgs);
+      prototype.registerHybridMethod("setAAD", &HybridCipherSpec::setAAD);
+      prototype.registerHybridMethod("setAutoPadding", &HybridCipherSpec::setAutoPadding);
+      prototype.registerHybridMethod("setAuthTag", &HybridCipherSpec::setAuthTag);
+      prototype.registerHybridMethod("getAuthTag", &HybridCipherSpec::getAuthTag);
+      prototype.registerHybridMethod("getSupportedCiphers", &HybridCipherSpec::getSupportedCiphers);
+    });
+  }
+
+} // namespace margelo::nitro::crypto

package/nitrogen/generated/shared/c++/HybridCipherSpec.hpp

@@ -0,0 +1,76 @@
+///
+/// HybridCipherSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `ArrayBuffer` to properly resolve imports.
+namespace NitroModules { class ArrayBuffer; }
+// Forward declaration of `CipherArgs` to properly resolve imports.
+namespace margelo::nitro::crypto { struct CipherArgs; }
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include "CipherArgs.hpp"
+#include <optional>
+#include <vector>
+#include <string>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Cipher`
+   * Inherit this class to create instances of `HybridCipherSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCipher: public HybridCipherSpec {
+   * public:
+   *   HybridCipher(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCipherSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCipherSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCipherSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<ArrayBuffer> update(const std::shared_ptr<ArrayBuffer>& data) = 0;
+      virtual std::shared_ptr<ArrayBuffer> final() = 0;
+      virtual void setArgs(const CipherArgs& args) = 0;
+      virtual bool setAAD(const std::shared_ptr<ArrayBuffer>& data, std::optional<double> plaintextLength) = 0;
+      virtual bool setAutoPadding(bool autoPad) = 0;
+      virtual bool setAuthTag(const std::shared_ptr<ArrayBuffer>& tag) = 0;
+      virtual std::shared_ptr<ArrayBuffer> getAuthTag() = 0;
+      virtual std::vector<std::string> getSupportedCiphers() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Cipher";
+  };
+
+} // namespace margelo::nitro::crypto

package/nitrogen/generated/shared/c++/HybridEdKeyPairSpec.hpp

@@ -44,7 +44,7 @@ namespace margelo::nitro::crypto {
       explicit HybridEdKeyPairSpec(): HybridObject(TAG) { }
 
       // Destructor
-      virtual ~HybridEdKeyPairSpec() { }
+      ~HybridEdKeyPairSpec() override = default;
 
     public:
       // Properties

package/nitrogen/generated/shared/c++/HybridHashSpec.hpp

@@ -48,7 +48,7 @@ namespace margelo::nitro::crypto {
       explicit HybridHashSpec(): HybridObject(TAG) { }
 
       // Destructor
-      virtual ~HybridHashSpec() { }
+      ~HybridHashSpec() override = default;
 
     public:
       // Properties

package/nitrogen/generated/shared/c++/HybridHmacSpec.hpp

@@ -42,7 +42,7 @@ namespace margelo::nitro::crypto {
       explicit HybridHmacSpec(): HybridObject(TAG) { }
 
       // Destructor
-      virtual ~HybridHmacSpec() { }
+      ~HybridHmacSpec() override = default;
 
     public:
       // Properties

package/nitrogen/generated/shared/c++/HybridKeyObjectHandleSpec.hpp

@@ -65,7 +65,7 @@ namespace margelo::nitro::crypto {
       explicit HybridKeyObjectHandleSpec(): HybridObject(TAG) { }
 
       // Destructor
-      virtual ~HybridKeyObjectHandleSpec() { }
+      ~HybridKeyObjectHandleSpec() override = default;
 
     public:
       // Properties

package/nitrogen/generated/shared/c++/HybridPbkdf2Spec.hpp

@@ -43,7 +43,7 @@ namespace margelo::nitro::crypto {
       explicit HybridPbkdf2Spec(): HybridObject(TAG) { }
 
       // Destructor
-      virtual ~HybridPbkdf2Spec() { }
+      ~HybridPbkdf2Spec() override = default;
 
     public:
       // Properties

package/nitrogen/generated/shared/c++/HybridRandomSpec.hpp

@@ -42,7 +42,7 @@ namespace margelo::nitro::crypto {
       explicit HybridRandomSpec(): HybridObject(TAG) { }
 
       // Destructor
-      virtual ~HybridRandomSpec() { }
+      ~HybridRandomSpec() override = default;
 
     public:
       // Properties

package/nitrogen/generated/shared/c++/JWK.hpp

@@ -63,6 +63,7 @@ namespace margelo::nitro::crypto {
     std::optional<bool> ext     SWIFT_PRIVATE;
 
   public:
+    JWK() = default;
     explicit JWK(std::optional<JWKkty> kty, std::optional<JWKuse> use, std::optional<std::vector<KeyUsage>> key_ops, std::optional<std::string> alg, std::optional<std::string> crv, std::optional<std::string> kid, std::optional<std::string> x5u, std::optional<std::vector<std::string>> x5c, std::optional<std::string> x5t, std::optional<std::string> x5t_256, std::optional<std::string> n, std::optional<std::string> e, std::optional<std::string> d, std::optional<std::string> p, std::optional<std::string> q, std::optional<std::string> x, std::optional<std::string> y, std::optional<std::string> k, std::optional<std::string> dp, std::optional<std::string> dq, std::optional<std::string> qi, std::optional<bool> ext): kty(kty), use(use), key_ops(key_ops), alg(alg), crv(crv), kid(kid), x5u(x5u), x5c(x5c), x5t(x5t), x5t_256(x5t_256), n(n), e(e), d(d), p(p), q(q), x(x), y(y), k(k), dp(dp), dq(dq), qi(qi), ext(ext) {}
   };
 
@@ -74,7 +75,7 @@ namespace margelo::nitro {
 
   // C++ JWK <> JS JWK (object)
   template <>
-  struct JSIConverter<JWK> {
+  struct JSIConverter<JWK> final {
     static inline JWK fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
       return JWK(

package/nitrogen/generated/shared/c++/JWKkty.hpp

@@ -43,7 +43,7 @@ namespace margelo::nitro {
 
   // C++ JWKkty <> JS JWKkty (union)
   template <>
-  struct JSIConverter<JWKkty> {
+  struct JSIConverter<JWKkty> final {
     static inline JWKkty fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
       switch (hashString(unionValue.c_str(), unionValue.size())) {

package/nitrogen/generated/shared/c++/JWKuse.hpp

@@ -41,7 +41,7 @@ namespace margelo::nitro {
 
   // C++ JWKuse <> JS JWKuse (union)
   template <>
-  struct JSIConverter<JWKuse> {
+  struct JSIConverter<JWKuse> final {
     static inline JWKuse fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
       switch (hashString(unionValue.c_str(), unionValue.size())) {

package/nitrogen/generated/shared/c++/KFormatType.hpp

@@ -38,7 +38,7 @@ namespace margelo::nitro {
 
   // C++ KFormatType <> JS KFormatType (enum)
   template <>
-  struct JSIConverter<KFormatType> {
+  struct JSIConverter<KFormatType> final {
     static inline KFormatType fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       int enumValue = JSIConverter<int>::fromJSI(runtime, arg);
       return static_cast<KFormatType>(enumValue);

package/nitrogen/generated/shared/c++/KeyDetail.hpp

@@ -39,6 +39,7 @@ namespace margelo::nitro::crypto {
     std::optional<std::string> namedCurve     SWIFT_PRIVATE;
 
   public:
+    KeyDetail() = default;
     explicit KeyDetail(std::optional<double> length, std::optional<double> publicExponent, std::optional<double> modulusLength, std::optional<std::string> hashAlgorithm, std::optional<std::string> mgf1HashAlgorithm, std::optional<double> saltLength, std::optional<std::string> namedCurve): length(length), publicExponent(publicExponent), modulusLength(modulusLength), hashAlgorithm(hashAlgorithm), mgf1HashAlgorithm(mgf1HashAlgorithm), saltLength(saltLength), namedCurve(namedCurve) {}
   };
 
@@ -50,7 +51,7 @@ namespace margelo::nitro {
 
   // C++ KeyDetail <> JS KeyDetail (object)
   template <>
-  struct JSIConverter<KeyDetail> {
+  struct JSIConverter<KeyDetail> final {
     static inline KeyDetail fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
       return KeyDetail(

package/nitrogen/generated/shared/c++/KeyEncoding.hpp

@@ -39,7 +39,7 @@ namespace margelo::nitro {
 
   // C++ KeyEncoding <> JS KeyEncoding (enum)
   template <>
-  struct JSIConverter<KeyEncoding> {
+  struct JSIConverter<KeyEncoding> final {
     static inline KeyEncoding fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       int enumValue = JSIConverter<int>::fromJSI(runtime, arg);
       return static_cast<KeyEncoding>(enumValue);

package/nitrogen/generated/shared/c++/KeyType.hpp

@@ -38,7 +38,7 @@ namespace margelo::nitro {
 
   // C++ KeyType <> JS KeyType (enum)
   template <>
-  struct JSIConverter<KeyType> {
+  struct JSIConverter<KeyType> final {
     static inline KeyType fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       int enumValue = JSIConverter<int>::fromJSI(runtime, arg);
       return static_cast<KeyType>(enumValue);

package/nitrogen/generated/shared/c++/KeyUsage.hpp

@@ -47,7 +47,7 @@ namespace margelo::nitro {
 
   // C++ KeyUsage <> JS KeyUsage (union)
   template <>
-  struct JSIConverter<KeyUsage> {
+  struct JSIConverter<KeyUsage> final {
     static inline KeyUsage fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
       switch (hashString(unionValue.c_str(), unionValue.size())) {

package/nitrogen/generated/shared/c++/NamedCurve.hpp

@@ -42,7 +42,7 @@ namespace margelo::nitro {
 
   // C++ NamedCurve <> JS NamedCurve (union)
   template <>
-  struct JSIConverter<NamedCurve> {
+  struct JSIConverter<NamedCurve> final {
     static inline NamedCurve fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
       switch (hashString(unionValue.c_str(), unionValue.size())) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-quick-crypto",
-  "version": "1.0.0-beta.13",
+  "version": "1.0.0-beta.14",
   "description": "A fast implementation of Node's `crypto` module written in C/C++ JSI",
   "type": "module",
   "main": "lib/commonjs/index",
@@ -72,28 +72,18 @@
     "events": "3.3.0",
     "react-native-quick-base64": "2.1.2",
     "readable-stream": "4.5.2",
-    "string_decoder": "1.3.0",
     "util": "0.12.5"
   },
   "devDependencies": {
-    "@eslint/compat": "^1.1.1",
-    "@eslint/js": "9.18.0",
-    "@release-it/bumper": "7.0.1",
     "@types/jest": "29.5.11",
     "@types/node": "22.0.0",
     "@types/react": "18.3.3",
     "@types/readable-stream": "4.0.18",
     "del-cli": "6.0.0",
-    "eslint": "9.9.0",
-    "eslint-plugin-react-native": "5.0.0",
     "jest": "29.7.0",
-    "nitro-codegen": "0.21.0",
-    "prettier": "3.3.3",
+    "nitro-codegen": "0.25.2",
     "react-native-builder-bob": "0.35.2",
-    "react-native-nitro-modules": "0.21.0",
-    "release-it": "18.1.1",
-    "typescript": "5.1.6",
-    "typescript-eslint": "^8.1.0"
+    "react-native-nitro-modules": "0.25.2"
   },
   "peerDependencies": {
     "react": "*",

package/src/cipher.ts

@@ -0,0 +1,303 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import Stream, { type TransformOptions } from 'readable-stream';
+import { Buffer } from '@craftzdog/react-native-buffer';
+import type { BinaryLike, BinaryLikeNode, Encoding } from './utils';
+import type {
+  CipherCCMOptions,
+  CipherCCMTypes,
+  CipherGCMTypes,
+  CipherGCMOptions,
+  CipherOCBOptions,
+  CipherOCBTypes,
+} from 'crypto'; // @types/node
+import type {
+  Cipher as NativeCipher,
+  CipherFactory,
+} from './specs/cipher.nitro';
+import { ab2str, binaryLikeToArrayBuffer } from './utils';
+import {
+  getDefaultEncoding,
+  getUIntOption,
+  normalizeEncoding,
+  validateEncoding,
+} from './utils/cipher';
+
+export type CipherOptions =
+  | CipherCCMOptions
+  | CipherOCBOptions
+  | CipherGCMOptions
+  | TransformOptions;
+
+class CipherUtils {
+  private static native =
+    NitroModules.createHybridObject<NativeCipher>('Cipher');
+  public static getSupportedCiphers(): string[] {
+    return this.native.getSupportedCiphers();
+  }
+}
+
+export function getCiphers(): string[] {
+  return CipherUtils.getSupportedCiphers();
+}
+
+interface CipherArgs {
+  isCipher: boolean;
+  cipherType: string;
+  cipherKey: BinaryLikeNode;
+  iv: BinaryLike;
+  options?: CipherOptions;
+}
+
+class CipherCommon extends Stream.Transform {
+  private native: NativeCipher;
+
+  constructor({ isCipher, cipherType, cipherKey, iv, options }: CipherArgs) {
+    // Explicitly create TransformOptions for super()
+    const streamOptions: TransformOptions = {};
+    if (options) {
+      // List known TransformOptions keys (adjust if needed)
+      const transformKeys: Array<keyof TransformOptions> = [
+        'readableHighWaterMark',
+        'writableHighWaterMark',
+        'decodeStrings',
+        'defaultEncoding',
+        'objectMode',
+        'destroy',
+        'read',
+        'write',
+        'writev',
+        'final',
+        'transform',
+        'flush',
+        // Add any other relevant keys from readable-stream's TransformOptions
+      ];
+      for (const key of transformKeys) {
+        if (key in options) {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          (streamOptions as any)[key] = (options as any)[key];
+        }
+      }
+    }
+    super(streamOptions); // Pass filtered options
+
+    const authTagLen: number =
+      getUIntOption(options ?? {}, 'authTagLength') !== -1
+        ? getUIntOption(options ?? {}, 'authTagLength')
+        : 16; // defaults to 16 bytes
+
+    const factory =
+      NitroModules.createHybridObject<CipherFactory>('CipherFactory');
+    this.native = factory.createCipher({
+      isCipher,
+      cipherType,
+      cipherKey: binaryLikeToArrayBuffer(cipherKey),
+      iv: binaryLikeToArrayBuffer(iv),
+      authTagLen,
+    });
+  }
+
+  update(
+    data: BinaryLike,
+    inputEncoding?: Encoding,
+    outputEncoding?: Encoding,
+  ): Buffer | string {
+    const defaultEncoding = getDefaultEncoding();
+    inputEncoding = inputEncoding ?? defaultEncoding;
+    outputEncoding = outputEncoding ?? defaultEncoding;
+
+    if (typeof data === 'string') {
+      validateEncoding(data, inputEncoding);
+    } else if (!ArrayBuffer.isView(data)) {
+      throw new Error('Invalid data argument');
+    }
+
+    const ret = this.native.update(
+      binaryLikeToArrayBuffer(data, inputEncoding),
+    );
+
+    if (outputEncoding && outputEncoding !== 'buffer') {
+      return ab2str(ret, outputEncoding);
+    }
+
+    return Buffer.from(ret);
+  }
+
+  final(): Buffer;
+  final(outputEncoding: BufferEncoding | 'buffer'): string;
+  final(outputEncoding?: BufferEncoding | 'buffer'): Buffer | string {
+    const ret = this.native.final();
+
+    if (outputEncoding && outputEncoding !== 'buffer') {
+      return ab2str(ret, outputEncoding);
+    }
+
+    return Buffer.from(ret);
+  }
+
+  _transform(
+    chunk: BinaryLike,
+    encoding: BufferEncoding,
+    callback: () => void,
+  ) {
+    this.push(this.update(chunk, normalizeEncoding(encoding)));
+    callback();
+  }
+
+  _flush(callback: () => void) {
+    this.push(this.final());
+    callback();
+  }
+
+  public setAutoPadding(autoPadding?: boolean): this {
+    const res = this.native.setAutoPadding(!!autoPadding);
+    if (!res) {
+      throw new Error('setAutoPadding failed');
+    }
+    return this;
+  }
+
+  public setAAD(
+    buffer: Buffer,
+    options?: {
+      plaintextLength: number;
+    },
+  ): this {
+    // Check if native parts are initialized
+    if (!this.native || typeof this.native.setAAD !== 'function') {
+      throw new Error('Cipher native object or setAAD method not initialized.');
+    }
+    const res = this.native.setAAD(buffer.buffer, options?.plaintextLength);
+    if (!res) {
+      throw new Error('setAAD failed (native call returned false)');
+    }
+    return this;
+  }
+
+  public getAuthTag(): Buffer {
+    return Buffer.from(this.native.getAuthTag());
+  }
+
+  public setAuthTag(tag: Buffer): this {
+    const res = this.native.setAuthTag(binaryLikeToArrayBuffer(tag));
+    if (!res) {
+      throw new Error('setAuthTag failed');
+    }
+    return this;
+  }
+
+  public getSupportedCiphers(): string[] {
+    return this.native.getSupportedCiphers();
+  }
+}
+
+class Cipheriv extends CipherCommon {
+  constructor(
+    cipherType: string,
+    cipherKey: BinaryLikeNode,
+    iv: BinaryLike,
+    options?: CipherOptions,
+  ) {
+    super({
+      isCipher: true,
+      cipherType,
+      cipherKey: binaryLikeToArrayBuffer(cipherKey),
+      iv: binaryLikeToArrayBuffer(iv),
+      options,
+    });
+  }
+}
+
+type Cipher = Cipheriv;
+
+class Decipheriv extends CipherCommon {
+  constructor(
+    cipherType: string,
+    cipherKey: BinaryLikeNode,
+    iv: BinaryLike,
+    options?: CipherOptions,
+  ) {
+    super({
+      isCipher: false,
+      cipherType,
+      cipherKey: binaryLikeToArrayBuffer(cipherKey),
+      iv: binaryLikeToArrayBuffer(iv),
+      options,
+    });
+  }
+}
+
+type Decipher = Decipheriv;
+
+export function createDecipheriv(
+  algorithm: CipherCCMTypes,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options: CipherCCMOptions,
+): Decipher;
+export function createDecipheriv(
+  algorithm: CipherOCBTypes,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options: CipherOCBOptions,
+): Decipher;
+export function createDecipheriv(
+  algorithm: CipherGCMTypes,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options?: CipherGCMOptions,
+): Decipher;
+export function createDecipheriv(
+  algorithm: string,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options?: TransformOptions,
+): Decipher;
+export function createDecipheriv(
+  algorithm: string,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options?: CipherOptions,
+): Decipher {
+  return new Decipheriv(algorithm, key, iv, options);
+}
+
+export function createCipheriv(
+  algorithm: CipherCCMTypes,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options: CipherCCMOptions,
+): Cipher;
+export function createCipheriv(
+  algorithm: CipherOCBTypes,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options: CipherOCBOptions,
+): Cipher;
+export function createCipheriv(
+  algorithm: CipherGCMTypes,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options?: CipherGCMOptions,
+): Cipher;
+export function createCipheriv(
+  algorithm: string,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options?: TransformOptions,
+): Cipher;
+export function createCipheriv(
+  algorithm: string,
+  key: BinaryLikeNode,
+  iv: BinaryLike,
+  options?: CipherOptions,
+): Cipher {
+  return new Cipheriv(algorithm, key, iv, options);
+}
+
+export const cipherExports = {
+  createCipheriv,
+  createDecipheriv,
+  getCiphers,
+};
+
+export type { Cipher, Decipher };

package/src/index.ts

@@ -3,9 +3,10 @@ import { Buffer } from '@craftzdog/react-native-buffer';
 
 // API imports
 import * as keys from './keys';
+import { cipherExports as cipher } from './cipher';
+import * as ed from './ed';
 import { hashExports as hash } from './hash';
 import { hmacExports as hmac } from './hmac';
-import * as ed from './ed';
 import * as pbkdf2 from './pbkdf2';
 import * as random from './random';
 
@@ -17,32 +18,13 @@ import * as utils from './utils';
  * See `docs/implementation-coverage.md` for status.
  */
 const QuickCrypto = {
-  // createHmac,
-  // Hmac: createHmac,
-  // Hash: createHash,
-  // createHash,
-  // createCipher,
-  // createCipheriv,
-  // createDecipher,
-  // createDecipheriv,
-  // publicEncrypt,
-  // publicDecrypt,
-  // privateDecrypt,
-  // generateKey,
-  // generateKeySync,
-  // createSign,
-  // createVerify,
-  // subtle,
-  // constants,
   ...keys,
+  ...cipher,
+  ...ed,
   ...hash,
   ...hmac,
-  ...ed,
   ...pbkdf2,
   ...random,
-  // getCiphers,
-  // getHashes,
-  // webcrypto,
   ...utils,
 };
 
@@ -63,9 +45,10 @@ global.process.nextTick = setImmediate;
 
 // exports
 export default QuickCrypto;
+export * from './cipher';
+export * from './ed';
 export * from './hash';
 export * from './hmac';
-export * from './ed';
 export * from './pbkdf2';
 export * from './random';
 export * from './utils';

package/src/pbkdf2.ts

@@ -80,7 +80,7 @@ export function pbkdf2Sync(
   iterations: number,
   keylen: number,
   digest?: HashAlgorithm,
-): ArrayBuffer {
+): Buffer {
   const sanitizedPassword = sanitizeInput(password, WRONG_PASS);
   const sanitizedSalt = sanitizeInput(salt, WRONG_SALT);