react-native-privyx-crypto 0.1.0

package/android/src/main/java/com/privyx/PrivyxCryptoModule.kt

@@ -0,0 +1,133 @@
+// android/app/src/main/java/com/privyx/PrivyxCryptoPackage.kt
+package com.privyx
+
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.WritableNativeMap
+
+class PrivyxCryptoModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName() = "PrivyxCrypto"
+
+    companion object {
+        init {
+            System.loadLibrary("privyx_crypto")
+        }
+
+        // JNI declarations
+        @JvmStatic
+        private external fun jniGenerateX25519KeyPair(): Array<String>
+        @JvmStatic
+        private external fun jniX25519DeriveSecret(privKey: String, pubKey: String): String
+        @JvmStatic
+        private external fun jniGenerateMlKemKeyPair(): Array<String>
+        @JvmStatic
+        private external fun jniMlKemEncapsulate(pubKey: String): Array<String>
+        @JvmStatic
+        private external fun jniMlKemDecapsulate(privKey: String, ct: String): String
+        @JvmStatic
+        private external fun jniDeriveHybridSecret(x25519: String, mlkem: String): String
+        @JvmStatic
+        private external fun jniEncrypt(pt: String, ss: String, iv: String): String
+        @JvmStatic
+        private external fun jniDecrypt(ct: String, iv: String, ss: String): String
+        @JvmStatic
+        private external fun jniGenerateIV(): String
+    }
+
+    @ReactMethod
+    fun generateX25519KeyPair(promise: Promise) {
+        try {
+            val keys = jniGenerateX25519KeyPair()
+            val result = WritableNativeMap()
+            result.putString("publicKey", keys[0])
+            result.putString("privateKey", keys[1])
+            promise.resolve(result)
+        } catch (e: Exception) {
+            promise.reject("CRYPTO_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun generateMlKemKeyPair(promise: Promise) {
+        try {
+            val keys = jniGenerateMlKemKeyPair()
+            val result = WritableNativeMap()
+            result.putString("publicKey", keys[0])
+            result.putString("privateKey", keys[1])
+            promise.resolve(result)
+        } catch (e: Exception) {
+            promise.reject("CRYPTO_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun x25519DeriveSecret(privateKey: String, publicKey: String, promise: Promise) {
+        try {
+            promise.resolve(jniX25519DeriveSecret(privateKey, publicKey))
+        } catch (e: Exception) {
+            promise.reject("CRYPTO_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun mlKemEncapsulate(publicKey: String, promise: Promise) {
+        try {
+            val result = jniMlKemEncapsulate(publicKey)
+            val map = WritableNativeMap()
+            map.putString("sharedSecret", result[0])
+            map.putString("ciphertext", result[1])
+            promise.resolve(map)
+        } catch (e: Exception) {
+            promise.reject("CRYPTO_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun mlKemDecapsulate(privateKey: String, ciphertext: String, promise: Promise) {
+        try {
+            promise.resolve(jniMlKemDecapsulate(privateKey, ciphertext))
+        } catch (e: Exception) {
+            promise.reject("CRYPTO_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun deriveHybridSecret(x25519Secret: String, mlkemSecret: String, promise: Promise) {
+        try {
+            promise.resolve(jniDeriveHybridSecret(x25519Secret, mlkemSecret))
+        } catch (e: Exception) {
+            promise.reject("CRYPTO_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun encrypt(plaintext: String, sharedSecret: String, iv: String, promise: Promise) {
+        try {
+            promise.resolve(jniEncrypt(plaintext, sharedSecret, iv))
+        } catch (e: Exception) {
+            promise.reject("CRYPTO_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun decrypt(ciphertext: String, iv: String, sharedSecret: String, promise: Promise) {
+        try {
+            promise.resolve(jniDecrypt(ciphertext, iv, sharedSecret))
+        } catch (e: Exception) {
+            promise.reject("CRYPTO_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun generateIV(promise: Promise) {
+        try {
+            promise.resolve(jniGenerateIV())
+        } catch (e: Exception) {
+            promise.reject("CRYPTO_ERROR", e.message, e)
+        }
+    }
+}

package/android/src/main/java/com/privyx/PrivyxCryptoPackage.kt

@@ -0,0 +1,17 @@
+// android/app/src/main/java/com/privyx/PrivyxCryptoPackage.kt
+package com.privyx
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class PrivyxCryptoPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(PrivyxCryptoModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

package/android/src/main/jni/jni.c

@@ -0,0 +1,134 @@
+// native/privyx-crypto/src/jni.c
+#include <jni.h>
+#include <stdlib.h>
+#include <string.h>
+
+// Declarations from Rust FFI
+extern void privyx_generate_x25519_keypair(char **out_pub, char **out_priv);
+extern char *privyx_x25519_derive_secret(const char *private_key, const char *public_key);
+extern void privyx_generate_mlkem_keypair(char **out_pub, char **out_priv);
+extern void privyx_mlkem_encapsulate(const char *public_key, char **out_shared, char **out_ct);
+extern char *privyx_mlkem_decapsulate(const char *private_key, const char *ciphertext);
+extern char *privyx_derive_hybrid_secret(const char *x25519_secret, const char *mlkem_secret);
+extern char *privyx_encrypt(const char *plaintext, const char *shared_secret, const char *iv);
+extern char *privyx_decrypt(const char *ciphertext, const char *iv, const char *shared_secret);
+extern char *privyx_generate_iv(void);
+extern void privyx_free_string(char *s);
+
+// Helper: convert Java string to malloc'd C string
+static char *jstring_to_c(JNIEnv *env, jstring js) {
+    const char *utf = (*env)->GetStringUTFChars(env, js, NULL);
+    char *c = strdup(utf);
+    (*env)->ReleaseStringUTFChars(env, js, utf);
+    return c;
+}
+
+// Helper: convert C string to Java string, then free the C string
+static jstring c_to_jstring_free(JNIEnv *env, char *cs) {
+    jstring js = (*env)->NewStringUTF(env, cs);
+    privyx_free_string(cs);
+    return js;
+}
+
+JNIEXPORT jobjectArray JNICALL
+Java_com_privyx_PrivyxCryptoModule_jniGenerateX25519KeyPair(JNIEnv *env, jclass clazz) {
+    char *pub = NULL, *priv = NULL;
+    privyx_generate_x25519_keypair(&pub, &priv);
+
+    jclass strClass = (*env)->FindClass(env, "java/lang/String");
+    jobjectArray arr = (*env)->NewObjectArray(env, 2, strClass, NULL);
+    (*env)->SetObjectArrayElement(env, arr, 0, (*env)->NewStringUTF(env, pub));
+    (*env)->SetObjectArrayElement(env, arr, 1, (*env)->NewStringUTF(env, priv));
+    privyx_free_string(pub);
+    privyx_free_string(priv);
+    return arr;
+}
+
+JNIEXPORT jstring JNICALL
+Java_com_privyx_PrivyxCryptoModule_jniX25519DeriveSecret(JNIEnv *env, jclass clazz, jstring priv, jstring pub) {
+    char *cpriv = jstring_to_c(env, priv);
+    char *cpub = jstring_to_c(env, pub);
+    char *result = privyx_x25519_derive_secret(cpriv, cpub);
+    free(cpriv);
+    free(cpub);
+    return c_to_jstring_free(env, result);
+}
+
+JNIEXPORT jobjectArray JNICALL
+Java_com_privyx_PrivyxCryptoModule_jniGenerateMlKemKeyPair(JNIEnv *env, jclass clazz) {
+    char *pub = NULL, *priv = NULL;
+    privyx_generate_mlkem_keypair(&pub, &priv);
+
+    jclass strClass = (*env)->FindClass(env, "java/lang/String");
+    jobjectArray arr = (*env)->NewObjectArray(env, 2, strClass, NULL);
+    (*env)->SetObjectArrayElement(env, arr, 0, (*env)->NewStringUTF(env, pub));
+    (*env)->SetObjectArrayElement(env, arr, 1, (*env)->NewStringUTF(env, priv));
+    privyx_free_string(pub);
+    privyx_free_string(priv);
+    return arr;
+}
+
+JNIEXPORT jobjectArray JNICALL
+Java_com_privyx_PrivyxCryptoModule_jniMlKemEncapsulate(JNIEnv *env, jclass clazz, jstring pub) {
+    char *cpub = jstring_to_c(env, pub);
+    char *shared = NULL, *ct = NULL;
+    privyx_mlkem_encapsulate(cpub, &shared, &ct);
+    free(cpub);
+
+    jclass strClass = (*env)->FindClass(env, "java/lang/String");
+    jobjectArray arr = (*env)->NewObjectArray(env, 2, strClass, NULL);
+    (*env)->SetObjectArrayElement(env, arr, 0, (*env)->NewStringUTF(env, shared));
+    (*env)->SetObjectArrayElement(env, arr, 1, (*env)->NewStringUTF(env, ct));
+    privyx_free_string(shared);
+    privyx_free_string(ct);
+    return arr;
+}
+
+JNIEXPORT jstring JNICALL
+Java_com_privyx_PrivyxCryptoModule_jniMlKemDecapsulate(JNIEnv *env, jclass clazz, jstring priv, jstring ct) {
+    char *cpriv = jstring_to_c(env, priv);
+    char *cct = jstring_to_c(env, ct);
+    char *result = privyx_mlkem_decapsulate(cpriv, cct);
+    free(cpriv);
+    free(cct);
+    return c_to_jstring_free(env, result);
+}
+
+JNIEXPORT jstring JNICALL
+Java_com_privyx_PrivyxCryptoModule_jniDeriveHybridSecret(JNIEnv *env, jclass clazz, jstring x, jstring m) {
+    char *cx = jstring_to_c(env, x);
+    char *cm = jstring_to_c(env, m);
+    char *result = privyx_derive_hybrid_secret(cx, cm);
+    free(cx);
+    free(cm);
+    return c_to_jstring_free(env, result);
+}
+
+JNIEXPORT jstring JNICALL
+Java_com_privyx_PrivyxCryptoModule_jniEncrypt(JNIEnv *env, jclass clazz, jstring pt, jstring ss, jstring iv) {
+    char *cpt = jstring_to_c(env, pt);
+    char *css = jstring_to_c(env, ss);
+    char *civ = jstring_to_c(env, iv);
+    char *result = privyx_encrypt(cpt, css, civ);
+    free(cpt);
+    free(css);
+    free(civ);
+    return c_to_jstring_free(env, result);
+}
+
+JNIEXPORT jstring JNICALL
+Java_com_privyx_PrivyxCryptoModule_jniDecrypt(JNIEnv *env, jclass clazz, jstring ct, jstring iv, jstring ss) {
+    char *cct = jstring_to_c(env, ct);
+    char *civ = jstring_to_c(env, iv);
+    char *css = jstring_to_c(env, ss);
+    char *result = privyx_decrypt(cct, civ, css);
+    free(cct);
+    free(civ);
+    free(css);
+    return c_to_jstring_free(env, result);
+}
+
+JNIEXPORT jstring JNICALL
+Java_com_privyx_PrivyxCryptoModule_jniGenerateIV(JNIEnv *env, jclass clazz) {
+    return c_to_jstring_free(env, privyx_generate_iv());
+}

package/include/libprivyx_crypto.h

@@ -0,0 +1,18 @@
+#ifndef libprivyx_crypto_h
+#define libprivyx_crypto_h
+
+#include <stddef.h>
+
+void privyx_free_string(char *s);
+
+void privyx_generate_x25519_keypair(char **out_pub, char **out_priv);
+char *privyx_x25519_derive_secret(const char *private_key, const char *public_key);
+void privyx_generate_mlkem_keypair(char **out_pub, char **out_priv);
+void privyx_mlkem_encapsulate(const char *public_key, char **out_shared, char **out_ct);
+char *privyx_mlkem_decapsulate(const char *private_key, const char *ciphertext);
+char *privyx_derive_hybrid_secret(const char *x25519_secret, const char *mlkem_secret);
+char *privyx_encrypt(const char *plaintext, const char *shared_secret, const char *iv);
+char *privyx_decrypt(const char *ciphertext, const char *iv, const char *shared_secret);
+char *privyx_generate_iv(void);
+
+#endif

package/include/module.modulemap

@@ -0,0 +1,4 @@
+module PrivyxCryptoFFI {
+    header "libprivyx_crypto.h"
+    export *
+}

package/ios/PrivyxCrypto.mm

@@ -0,0 +1,128 @@
+#import <React/RCTBridgeModule.h>
+
+extern "C" {
+#include "../include/libprivyx_crypto.h"
+}
+
+@interface PrivyxCrypto : NSObject <RCTBridgeModule>
+@end
+
+@implementation PrivyxCrypto
+
+RCT_EXPORT_MODULE()
+
++ (BOOL)requiresMainQueueSetup { return NO; }
+
+RCT_EXPORT_METHOD(generateX25519KeyPair:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+    char *pubKey = NULL;
+    char *privKey = NULL;
+    privyx_generate_x25519_keypair(&pubKey, &privKey);
+
+    NSString *pubStr = [NSString stringWithUTF8String:pubKey];
+    NSString *privStr = [NSString stringWithUTF8String:privKey];
+    privyx_free_string(pubKey);
+    privyx_free_string(privKey);
+
+    resolve(@{ @"publicKey": pubStr, @"privateKey": privStr });
+}
+
+RCT_EXPORT_METHOD(generateMlKemKeyPair:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+    char *pubKey = NULL;
+    char *privKey = NULL;
+    privyx_generate_mlkem_keypair(&pubKey, &privKey);
+
+    NSString *pubStr = [NSString stringWithUTF8String:pubKey];
+    NSString *privStr = [NSString stringWithUTF8String:privKey];
+    privyx_free_string(pubKey);
+    privyx_free_string(privKey);
+
+    resolve(@{ @"publicKey": pubStr, @"privateKey": privStr });
+}
+
+RCT_EXPORT_METHOD(x25519DeriveSecret:(NSString *)privateKey
+                  publicKey:(NSString *)publicKey
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+    char *result = privyx_x25519_derive_secret(privateKey.UTF8String, publicKey.UTF8String);
+    NSString *str = [NSString stringWithUTF8String:result];
+    privyx_free_string(result);
+    resolve(str);
+}
+
+RCT_EXPORT_METHOD(mlKemEncapsulate:(NSString *)publicKey
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+    char *shared = NULL;
+    char *ct = NULL;
+    privyx_mlkem_encapsulate(publicKey.UTF8String, &shared, &ct);
+
+    NSString *sharedStr = [NSString stringWithUTF8String:shared];
+    NSString *ctStr = [NSString stringWithUTF8String:ct];
+    privyx_free_string(shared);
+    privyx_free_string(ct);
+
+    resolve(@{ @"sharedSecret": sharedStr, @"ciphertext": ctStr });
+}
+
+RCT_EXPORT_METHOD(mlKemDecapsulate:(NSString *)privateKey
+                  ciphertext:(NSString *)ciphertext
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+    char *result = privyx_mlkem_decapsulate(privateKey.UTF8String, ciphertext.UTF8String);
+    NSString *str = [NSString stringWithUTF8String:result];
+    privyx_free_string(result);
+    resolve(str);
+}
+
+RCT_EXPORT_METHOD(deriveHybridSecret:(NSString *)x25519Secret
+                  mlkemSecret:(NSString *)mlkemSecret
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+    char *result = privyx_derive_hybrid_secret(x25519Secret.UTF8String, mlkemSecret.UTF8String);
+    NSString *str = [NSString stringWithUTF8String:result];
+    privyx_free_string(result);
+    resolve(str);
+}
+
+RCT_EXPORT_METHOD(encrypt:(NSString *)plaintext
+                  sharedSecret:(NSString *)sharedSecret
+                  iv:(NSString *)iv
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+    char *result = privyx_encrypt(plaintext.UTF8String, sharedSecret.UTF8String, iv.UTF8String);
+    NSString *str = [NSString stringWithUTF8String:result];
+    privyx_free_string(result);
+    resolve(str);
+}
+
+RCT_EXPORT_METHOD(decrypt:(NSString *)ciphertext
+                  iv:(NSString *)iv
+                  sharedSecret:(NSString *)sharedSecret
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+    char *result = privyx_decrypt(ciphertext.UTF8String, iv.UTF8String, sharedSecret.UTF8String);
+    NSString *str = [NSString stringWithUTF8String:result];
+    privyx_free_string(result);
+    resolve(str);
+}
+
+RCT_EXPORT_METHOD(generateIV:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+{
+    char *result = privyx_generate_iv();
+    NSString *str = [NSString stringWithUTF8String:result];
+    privyx_free_string(result);
+    resolve(str);
+}
+
+@end

package/ios/react-native-privyx-crypto.podspec

@@ -0,0 +1,25 @@
+Pod::Spec.new do |s|
+  s.name             = 'react-native-privyx-crypto'
+  s.version          = '0.1.0'
+  s.summary          = 'Post-quantum crypto native module for React Native'
+  s.authors          = { 'Privyx' => 'dev@privyx.network' }
+  s.homepage         = 'https://privyx.network'
+  s.source           = { :path => '..' }
+  s.license          = { :type => 'MIT' }
+  s.source_files     = 'PrivyxCrypto.mm'
+
+  s.vendored_libraries = '../libs/ios/PrivyxCryptoFFI.xcframework/ios-arm64_x86_64-simulator/libprivyx-sim.a', '../libs/ios/PrivyxCryptoFFI.xcframework/ios-arm64/libprivyx.a'
+
+  s.pod_target_xcconfig = {
+    'HEADER_SEARCH_PATHS' => '"${PODS_ROOT}/../../sdk_privyx/libs/ios/PrivyxCryptoFFI.xcframework/ios-arm64_x86_64-simulator/Headers"',
+    'LIBRARY_SEARCH_PATHS' => '"${PODS_ROOT}/../../sdk_privyx/libs/ios/PrivyxCryptoFFI.xcframework/ios-arm64_x86_64-simulator"',
+    'OTHER_LDFLAGS' => '-lprivyx-sim'
+  }
+
+  s.user_target_xcconfig = {
+    'LIBRARY_SEARCH_PATHS' => '"${PODS_ROOT}/../../sdk_privyx/libs/ios/PrivyxCryptoFFI.xcframework/ios-arm64_x86_64-simulator"',
+    'OTHER_LDFLAGS' => '-lprivyx-sim'
+  }
+
+  s.dependency 'React-Core'
+end

package/libs/ios/PrivyxCryptoFFI.xcframework/Info.plist

@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>AvailableLibraries</key>
+	<array>
+		<dict>
+			<key>BinaryPath</key>
+			<string>libprivyx.a</string>
+			<key>HeadersPath</key>
+			<string>Headers</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64</string>
+			<key>LibraryPath</key>
+			<string>libprivyx.a</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+		</dict>
+		<dict>
+			<key>BinaryPath</key>
+			<string>libprivyx-sim.a</string>
+			<key>HeadersPath</key>
+			<string>Headers</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64_x86_64-simulator</string>
+			<key>LibraryPath</key>
+			<string>libprivyx-sim.a</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+				<string>x86_64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
+		</dict>
+	</array>
+	<key>CFBundlePackageType</key>
+	<string>XFWK</string>
+	<key>XCFrameworkFormatVersion</key>
+	<string>1.0</string>
+</dict>
+</plist>

package/libs/ios/PrivyxCryptoFFI.xcframework/ios-arm64/Headers/libprivyx_crypto.h

@@ -0,0 +1,18 @@
+#ifndef libprivyx_crypto_h
+#define libprivyx_crypto_h
+
+#include <stddef.h>
+
+void privyx_free_string(char *s);
+
+void privyx_generate_x25519_keypair(char **out_pub, char **out_priv);
+char *privyx_x25519_derive_secret(const char *private_key, const char *public_key);
+void privyx_generate_mlkem_keypair(char **out_pub, char **out_priv);
+void privyx_mlkem_encapsulate(const char *public_key, char **out_shared, char **out_ct);
+char *privyx_mlkem_decapsulate(const char *private_key, const char *ciphertext);
+char *privyx_derive_hybrid_secret(const char *x25519_secret, const char *mlkem_secret);
+char *privyx_encrypt(const char *plaintext, const char *shared_secret, const char *iv);
+char *privyx_decrypt(const char *ciphertext, const char *iv, const char *shared_secret);
+char *privyx_generate_iv(void);
+
+#endif

package/libs/ios/PrivyxCryptoFFI.xcframework/ios-arm64/Headers/module.modulemap

@@ -0,0 +1,4 @@
+module PrivyxCryptoFFI {
+    header "libprivyx_crypto.h"
+    export *
+}

package/libs/ios/PrivyxCryptoFFI.xcframework/ios-arm64_x86_64-simulator/Headers/libprivyx_crypto.h

@@ -0,0 +1,18 @@
+#ifndef libprivyx_crypto_h
+#define libprivyx_crypto_h
+
+#include <stddef.h>
+
+void privyx_free_string(char *s);
+
+void privyx_generate_x25519_keypair(char **out_pub, char **out_priv);
+char *privyx_x25519_derive_secret(const char *private_key, const char *public_key);
+void privyx_generate_mlkem_keypair(char **out_pub, char **out_priv);
+void privyx_mlkem_encapsulate(const char *public_key, char **out_shared, char **out_ct);
+char *privyx_mlkem_decapsulate(const char *private_key, const char *ciphertext);
+char *privyx_derive_hybrid_secret(const char *x25519_secret, const char *mlkem_secret);
+char *privyx_encrypt(const char *plaintext, const char *shared_secret, const char *iv);
+char *privyx_decrypt(const char *ciphertext, const char *iv, const char *shared_secret);
+char *privyx_generate_iv(void);
+
+#endif

package/libs/ios/PrivyxCryptoFFI.xcframework/ios-arm64_x86_64-simulator/Headers/module.modulemap

@@ -0,0 +1,4 @@
+module PrivyxCryptoFFI {
+    header "libprivyx_crypto.h"
+    export *
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "react-native-privyx-crypto",
+  "version": "0.1.0",
+  "description": "Post-quantum hybrid cryptography for React Native (X25519 + ML-KEM-768 + AES-256-GCM)",
+  "main": "src/index.tsx",
+  "scripts": {
+    "test": "jest"
+  },
+  "keywords": ["react-native", "cryptography", "post-quantum", "ml-kem", "x25519", "aes-gcm"],
+  "license": "MIT",
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*"
+  },
+  "codegenConfig": {
+    "name": "PrivyxCryptoSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "com.privyx"
+    }
+  }
+}

package/react-native.config.js

@@ -0,0 +1,10 @@
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        sourceDir: './android',
+      },
+      ios: {},
+    },
+  },
+};

package/src/NativePrivyxCrypto.ts

@@ -0,0 +1,16 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface Spec extends TurboModule {
+  generateX25519KeyPair(): Promise<{ publicKey: string; privateKey: string }>;
+  generateMlKemKeyPair(): Promise<{ publicKey: string; privateKey: string }>;
+  x25519DeriveSecret(privateKey: string, publicKey: string): Promise<string>;
+  mlKemEncapsulate(publicKey: string): Promise<{ sharedSecret: string; ciphertext: string }>;
+  mlKemDecapsulate(privateKey: string, ciphertext: string): Promise<string>;
+  deriveHybridSecret(x25519Secret: string, mlkemSecret: string): Promise<string>;
+  encrypt(plaintext: string, sharedSecret: string, iv: string): Promise<string>;
+  decrypt(ciphertext: string, iv: string, sharedSecret: string): Promise<string>;
+  generateIV(): Promise<string>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('PrivyxCrypto');

package/src/index.tsx

@@ -0,0 +1,16 @@
+import NativePrivyxCrypto from './NativePrivyxCrypto';
+
+export const generateX25519KeyPair = () => NativePrivyxCrypto.generateX25519KeyPair();
+export const generateMlKemKeyPair = () => NativePrivyxCrypto.generateMlKemKeyPair();
+export const x25519DeriveSecret = (privateKey: string, publicKey: string) =>
+  NativePrivyxCrypto.x25519DeriveSecret(privateKey, publicKey);
+export const mlKemEncapsulate = (publicKey: string) => NativePrivyxCrypto.mlKemEncapsulate(publicKey);
+export const mlKemDecapsulate = (privateKey: string, ciphertext: string) =>
+  NativePrivyxCrypto.mlKemDecapsulate(privateKey, ciphertext);
+export const deriveHybridSecret = (x25519Secret: string, mlkemSecret: string) =>
+  NativePrivyxCrypto.deriveHybridSecret(x25519Secret, mlkemSecret);
+export const encrypt = (plaintext: string, sharedSecret: string, iv: string) =>
+  NativePrivyxCrypto.encrypt(plaintext, sharedSecret, iv);
+export const decrypt = (ciphertext: string, iv: string, sharedSecret: string) =>
+  NativePrivyxCrypto.decrypt(ciphertext, iv, sharedSecret);
+export const generateIV = () => NativePrivyxCrypto.generateIV();

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "jsx": "react-jsx",
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "outDir": "lib"
+  },
+  "include": ["src"]
+}