@k9o/react-native-matrix-crypto 1.0.0

package/android/RNMatrixCryptoModule.kt

@@ -0,0 +1,20 @@
+package com.matrix.crypto
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+/**
+ * React Native package for Matrix crypto (Android)
+ * This is the entry point for the React Native module on Android
+ */
+class RNMatrixCryptoPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(RNMatrixCrypto(reactContext))
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}

package/android/build.gradle

@@ -0,0 +1,62 @@
+buildscript {
+    ext.safeExtGet = {prop, fallback ->
+        rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath("com.android.tools.build:gradle:${safeExtGet("androidBuildToolsVersion", "7.3.1")}")
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${safeExtGet("kotlinVersion", "1.9.20")}")
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+android {
+    compileSdk safeExtGet("compileSdkVersion", 34)
+
+    defaultConfig {
+        minSdk safeExtGet("minSdkVersion", 21)
+        targetSdk safeExtGet("targetSdkVersion", 34)
+        versionCode 1
+        versionName "0.1.0"
+
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_11
+        targetCompatibility JavaVersion.VERSION_11
+    }
+
+    kotlinOptions {
+        jvmTarget = '11'
+    }
+
+    namespace 'com.matrix.crypto'
+}
+
+repositories {
+    mavenCentral()
+    google()
+}
+
+dependencies {
+    implementation "com.facebook.react:react-native:${safeExtGet("reactNativeVersion", "0.73.0")}"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:${safeExtGet("kotlinVersion", "1.9.20")}"
+    implementation 'androidx.core:core:1.12.0'
+
+    testImplementation 'junit:junit:4.13.2'
+    androidTestImplementation 'androidx.test.ext:junit:1.1.5'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'
+}

package/android/proguard-rules.pro

@@ -0,0 +1,16 @@
+# Matrix Crypto Bridge
+-keep class com.matrix.crypto.** { *; }
+-keepclassmembers class com.matrix.crypto.** { *; }
+
+# React Native
+-keep class com.facebook.react.** { *; }
+-keepclassmembers class com.facebook.react.** { *; }
+
+# Kotlin
+-keep class kotlin.** { *; }
+-keepclassmembers class kotlin.** { *; }
+
+# Native methods
+-keepclasseswithmembernames class * {
+    native <methods>;
+}

package/ios/RNMatrixCryptoModule.swift

@@ -0,0 +1,20 @@
+import Foundation
+import React
+
+/**
+ * React Native module for Matrix crypto (iOS)
+ * This is the entry point for the React Native module on iOS
+ */
+@objc(RNMatrixCryptoModule)
+class RNMatrixCryptoModule: NSObject {
+  
+  @objc
+  static func moduleName() -> String! {
+    return "RNMatrixCrypto"
+  }
+
+  @objc
+  static func requiresMainQueueSetup() -> Bool {
+    return false
+  }
+}

package/lib/CryptoAPI.d.ts

@@ -0,0 +1,83 @@
+import { DeviceInfo, EmojiSASPair, VerificationState, RoomEncryptionState } from './index';
+/**
+ * High-level API for Matrix crypto operations
+ * Provides a clean, easy-to-use interface for encryption, device verification, and key management
+ */
+export declare class CryptoAPI {
+    private initialized;
+    private userId;
+    private deviceId;
+    /**
+     * Initialize the crypto API
+     */
+    initialize(userId: string, deviceId: string, pickleKey: string): Promise<void>;
+    /**
+     * Check if crypto is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Get device information
+     */
+    getDeviceInfo(): Promise<{
+        fingerprint: string;
+        userId: string;
+        deviceId: string;
+    }>;
+    /**
+     * Get all devices for a user
+     */
+    getUserDevices(userId: string): Promise<DeviceInfo[]>;
+    /**
+     * Add a device to the device store
+     */
+    addDevice(device: DeviceInfo): Promise<void>;
+    /**
+     * Start device verification with another device
+     */
+    startVerification(otherUserId: string, otherDeviceId: string): Promise<VerificationState>;
+    /**
+     * Get SAS emoji pairs for verification
+     */
+    getSASEmojis(verificationId: string): Promise<EmojiSASPair[]>;
+    /**
+     * Confirm SAS verification
+     */
+    confirmSAS(verificationId: string): Promise<void>;
+    /**
+     * Complete device verification
+     */
+    completeVerification(verificationId: string): Promise<void>;
+    /**
+     * Cancel device verification
+     */
+    cancelVerification(verificationId: string): Promise<void>;
+    /**
+     * Get the current state of a verification
+     */
+    getVerificationState(verificationId: string): Promise<VerificationState>;
+    /**
+     * Enable encryption for a room
+     */
+    enableRoomEncryption(roomId: string, algorithm?: string): Promise<void>;
+    /**
+     * Get encryption state for a room
+     */
+    getRoomEncryptionState(roomId: string): Promise<RoomEncryptionState>;
+    /**
+     * Encrypt an event
+     */
+    encryptEvent(roomId: string, eventType: string, content: string): Promise<string>;
+    /**
+     * Decrypt an event
+     */
+    decryptEvent(roomId: string, encryptedContent: string): Promise<string>;
+    /**
+     * Cleanup and destroy the crypto instance
+     */
+    destroy(): Promise<void>;
+    /**
+     * Helper method to ensure crypto is initialized
+     */
+    private assertInitialized;
+}
+export default CryptoAPI;

package/lib/CryptoAPI.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoAPI = void 0;
+const NativeMatrixCrypto_1 = require("./NativeMatrixCrypto");
+/**
+ * High-level API for Matrix crypto operations
+ * Provides a clean, easy-to-use interface for encryption, device verification, and key management
+ */
+class CryptoAPI {
+    constructor() {
+        this.initialized = false;
+        this.userId = '';
+        this.deviceId = '';
+    }
+    /**
+     * Initialize the crypto API
+     */
+    async initialize(userId, deviceId, pickleKey) {
+        try {
+            await NativeMatrixCrypto_1.NativeMatrixCrypto.initialize(userId, deviceId, pickleKey);
+            this.initialized = true;
+            this.userId = userId;
+            this.deviceId = deviceId;
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize crypto: ${error}`);
+        }
+    }
+    /**
+     * Check if crypto is initialized
+     */
+    isInitialized() {
+        return this.initialized;
+    }
+    /**
+     * Get device information
+     */
+    async getDeviceInfo() {
+        this.assertInitialized();
+        try {
+            const [fingerprint, userId, deviceId] = await Promise.all([
+                NativeMatrixCrypto_1.NativeMatrixCrypto.getDeviceFingerprint(),
+                NativeMatrixCrypto_1.NativeMatrixCrypto.getUserId(),
+                NativeMatrixCrypto_1.NativeMatrixCrypto.getDeviceId(),
+            ]);
+            return { fingerprint, userId, deviceId };
+        }
+        catch (error) {
+            throw new Error(`Failed to get device info: ${error}`);
+        }
+    }
+    /**
+     * Get all devices for a user
+     */
+    async getUserDevices(userId) {
+        this.assertInitialized();
+        try {
+            return await NativeMatrixCrypto_1.NativeMatrixCrypto.getUserDevices(userId);
+        }
+        catch (error) {
+            throw new Error(`Failed to get user devices: ${error}`);
+        }
+    }
+    /**
+     * Add a device to the device store
+     */
+    async addDevice(device) {
+        this.assertInitialized();
+        try {
+            await NativeMatrixCrypto_1.NativeMatrixCrypto.addDevice(device);
+        }
+        catch (error) {
+            throw new Error(`Failed to add device: ${error}`);
+        }
+    }
+    /**
+     * Start device verification with another device
+     */
+    async startVerification(otherUserId, otherDeviceId) {
+        this.assertInitialized();
+        try {
+            const result = await NativeMatrixCrypto_1.NativeMatrixCrypto.startVerification(otherUserId, otherDeviceId);
+            return result;
+        }
+        catch (error) {
+            throw new Error(`Failed to start verification: ${error}`);
+        }
+    }
+    /**
+     * Get SAS emoji pairs for verification
+     */
+    async getSASEmojis(verificationId) {
+        this.assertInitialized();
+        try {
+            return await NativeMatrixCrypto_1.NativeMatrixCrypto.getSASEmojis(verificationId);
+        }
+        catch (error) {
+            throw new Error(`Failed to get SAS emojis: ${error}`);
+        }
+    }
+    /**
+     * Confirm SAS verification
+     */
+    async confirmSAS(verificationId) {
+        this.assertInitialized();
+        try {
+            await NativeMatrixCrypto_1.NativeMatrixCrypto.confirmSAS(verificationId);
+        }
+        catch (error) {
+            throw new Error(`Failed to confirm SAS: ${error}`);
+        }
+    }
+    /**
+     * Complete device verification
+     */
+    async completeVerification(verificationId) {
+        this.assertInitialized();
+        try {
+            await NativeMatrixCrypto_1.NativeMatrixCrypto.completeVerification(verificationId);
+        }
+        catch (error) {
+            throw new Error(`Failed to complete verification: ${error}`);
+        }
+    }
+    /**
+     * Cancel device verification
+     */
+    async cancelVerification(verificationId) {
+        this.assertInitialized();
+        try {
+            await NativeMatrixCrypto_1.NativeMatrixCrypto.cancelVerification(verificationId);
+        }
+        catch (error) {
+            throw new Error(`Failed to cancel verification: ${error}`);
+        }
+    }
+    /**
+     * Get the current state of a verification
+     */
+    async getVerificationState(verificationId) {
+        this.assertInitialized();
+        try {
+            const result = await NativeMatrixCrypto_1.NativeMatrixCrypto.getVerificationState(verificationId);
+            return result;
+        }
+        catch (error) {
+            throw new Error(`Failed to get verification state: ${error}`);
+        }
+    }
+    /**
+     * Enable encryption for a room
+     */
+    async enableRoomEncryption(roomId, algorithm = 'm.megolm.v1.aes-sha2') {
+        this.assertInitialized();
+        try {
+            await NativeMatrixCrypto_1.NativeMatrixCrypto.enableRoomEncryption(roomId, algorithm);
+        }
+        catch (error) {
+            throw new Error(`Failed to enable room encryption: ${error}`);
+        }
+    }
+    /**
+     * Get encryption state for a room
+     */
+    async getRoomEncryptionState(roomId) {
+        this.assertInitialized();
+        try {
+            return await NativeMatrixCrypto_1.NativeMatrixCrypto.getRoomEncryptionState(roomId);
+        }
+        catch (error) {
+            throw new Error(`Failed to get room encryption state: ${error}`);
+        }
+    }
+    /**
+     * Encrypt an event
+     */
+    async encryptEvent(roomId, eventType, content) {
+        this.assertInitialized();
+        try {
+            return await NativeMatrixCrypto_1.NativeMatrixCrypto.encryptEvent(roomId, eventType, content);
+        }
+        catch (error) {
+            throw new Error(`Failed to encrypt event: ${error}`);
+        }
+    }
+    /**
+     * Decrypt an event
+     */
+    async decryptEvent(roomId, encryptedContent) {
+        this.assertInitialized();
+        try {
+            return await NativeMatrixCrypto_1.NativeMatrixCrypto.decryptEvent(roomId, encryptedContent);
+        }
+        catch (error) {
+            throw new Error(`Failed to decrypt event: ${error}`);
+        }
+    }
+    /**
+     * Cleanup and destroy the crypto instance
+     */
+    async destroy() {
+        try {
+            await NativeMatrixCrypto_1.NativeMatrixCrypto.destroy();
+            this.initialized = false;
+        }
+        catch (error) {
+            throw new Error(`Failed to destroy crypto: ${error}`);
+        }
+    }
+    /**
+     * Helper method to ensure crypto is initialized
+     */
+    assertInitialized() {
+        if (!this.initialized) {
+            throw new Error('Crypto not initialized. Call initialize() first.');
+        }
+    }
+}
+exports.CryptoAPI = CryptoAPI;
+exports.default = CryptoAPI;

package/lib/NativeMatrixCrypto.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Native module interface for Matrix crypto
+ * This is the low-level binding to the native iOS/Android modules
+ */
+export interface NativeMatrixCryptoInterface {
+    initialize(userId: string, deviceId: string, pickleKey: string): Promise<{
+        success: boolean;
+    }>;
+    getDeviceFingerprint(): Promise<string>;
+    getUserId(): Promise<string>;
+    getDeviceId(): Promise<string>;
+    getUserDevices(userId: string): Promise<Array<{
+        deviceId: string;
+        userId: string;
+        displayName?: string;
+        fingerprint: string;
+        isVerified: boolean;
+        isBlocked: boolean;
+        algorithm: string;
+    }>>;
+    addDevice(device: {
+        deviceId: string;
+        userId: string;
+        displayName?: string;
+        fingerprint: string;
+        isVerified: boolean;
+        isBlocked: boolean;
+        algorithm: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    startVerification(otherUserId: string, otherDeviceId: string): Promise<{
+        verificationId: string;
+        state: string;
+        otherUserId: string;
+        otherDeviceId: string;
+        emojis: Array<{
+            emoji: string;
+            name: string;
+        }>;
+        decimals: number[];
+    }>;
+    getSASEmojis(verificationId: string): Promise<Array<{
+        emoji: string;
+        name: string;
+    }>>;
+    confirmSAS(verificationId: string): Promise<{
+        success: boolean;
+    }>;
+    completeVerification(verificationId: string): Promise<{
+        success: boolean;
+    }>;
+    cancelVerification(verificationId: string): Promise<{
+        success: boolean;
+    }>;
+    getVerificationState(verificationId: string): Promise<{
+        verificationId: string;
+        state: string;
+        otherUserId: string;
+        otherDeviceId: string;
+        emojis: Array<{
+            emoji: string;
+            name: string;
+        }>;
+        decimals: number[];
+    }>;
+    enableRoomEncryption(roomId: string, algorithm: string): Promise<{
+        success: boolean;
+    }>;
+    getRoomEncryptionState(roomId: string): Promise<{
+        roomId: string;
+        isEncrypted: boolean;
+        algorithm?: string;
+        trustedDevices: string[];
+        untrustedDevices: string[];
+    }>;
+    encryptEvent(roomId: string, eventType: string, content: string): Promise<string>;
+    decryptEvent(roomId: string, encryptedContent: string): Promise<string>;
+    destroy(): Promise<{
+        success: boolean;
+    }>;
+}
+/**
+ * Native module proxy that delegates to the platform-specific implementation
+ */
+export declare const NativeMatrixCrypto: NativeMatrixCryptoInterface;
+export default NativeMatrixCrypto;

package/lib/NativeMatrixCrypto.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeMatrixCrypto = void 0;
+const react_native_1 = require("react-native");
+const LINKING_ERROR = `The package 'react-native-matrix-crypto' doesn't seem to be linked. Make sure: \n\n` +
+    react_native_1.Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+    '- You rebuilt the app after installing the package\n' +
+    '- You are not using Expo Go\n';
+const NativeMatrixCryptoModule = react_native_1.NativeModules.RNMatrixCrypto
+    ? react_native_1.NativeModules.RNMatrixCrypto
+    : new Proxy({}, {
+        get() {
+            throw new Error(LINKING_ERROR);
+        },
+    });
+/**
+ * Native module proxy that delegates to the platform-specific implementation
+ */
+exports.NativeMatrixCrypto = {
+    initialize: (userId, deviceId, pickleKey) => NativeMatrixCryptoModule.initialize(userId, deviceId, pickleKey),
+    getDeviceFingerprint: () => NativeMatrixCryptoModule.getDeviceFingerprint(),
+    getUserId: () => NativeMatrixCryptoModule.getUserId(),
+    getDeviceId: () => NativeMatrixCryptoModule.getDeviceId(),
+    getUserDevices: (userId) => NativeMatrixCryptoModule.getUserDevices(userId),
+    addDevice: (device) => NativeMatrixCryptoModule.addDevice(device),
+    startVerification: (otherUserId, otherDeviceId) => NativeMatrixCryptoModule.startVerification(otherUserId, otherDeviceId),
+    getSASEmojis: (verificationId) => NativeMatrixCryptoModule.getSASEmojis(verificationId),
+    confirmSAS: (verificationId) => NativeMatrixCryptoModule.confirmSAS(verificationId),
+    completeVerification: (verificationId) => NativeMatrixCryptoModule.completeVerification(verificationId),
+    cancelVerification: (verificationId) => NativeMatrixCryptoModule.cancelVerification(verificationId),
+    getVerificationState: (verificationId) => NativeMatrixCryptoModule.getVerificationState(verificationId),
+    enableRoomEncryption: (roomId, algorithm) => NativeMatrixCryptoModule.enableRoomEncryption(roomId, algorithm),
+    getRoomEncryptionState: (roomId) => NativeMatrixCryptoModule.getRoomEncryptionState(roomId),
+    encryptEvent: (roomId, eventType, content) => NativeMatrixCryptoModule.encryptEvent(roomId, eventType, content),
+    decryptEvent: (roomId, encryptedContent) => NativeMatrixCryptoModule.decryptEvent(roomId, encryptedContent),
+    destroy: () => NativeMatrixCryptoModule.destroy(),
+};
+exports.default = exports.NativeMatrixCrypto;

package/lib/index.d.ts

@@ -0,0 +1,116 @@
+export interface DeviceInfo {
+    deviceId: string;
+    userId: string;
+    displayName?: string;
+    fingerprint: string;
+    isVerified: boolean;
+    isBlocked: boolean;
+    algorithm: string;
+}
+export interface EmojiSASPair {
+    emoji: string;
+    name: string;
+}
+export interface VerificationState {
+    verificationId: string;
+    state: 'pending' | 'sas_ready' | 'confirmed' | 'completed' | 'cancelled';
+    otherUserId: string;
+    otherDeviceId: string;
+    emojis: EmojiSASPair[];
+    decimals: number[];
+}
+export interface RoomEncryptionState {
+    roomId: string;
+    isEncrypted: boolean;
+    algorithm?: string;
+    trustedDevices: string[];
+    untrustedDevices: string[];
+}
+export interface EncryptionAlgorithm {
+    algorithm: string;
+    rotationPeriodMs: number;
+    rotationPeriodMsgs: number;
+}
+export interface UserDevices {
+    userId: string;
+    devices: DeviceInfo[];
+}
+export declare class MatrixCrypto {
+    private static instance;
+    private handle;
+    private constructor();
+    /**
+     * Get or create singleton instance
+     */
+    static getInstance(): MatrixCrypto;
+    /**
+     * Initialize the crypto machine
+     */
+    initialize(userId: string, deviceId: string, pickleKey: string): Promise<void>;
+    /**
+     * Get the device fingerprint
+     */
+    getDeviceFingerprint(): Promise<string>;
+    /**
+     * Get the user ID
+     */
+    getUserId(): Promise<string>;
+    /**
+     * Get the device ID
+     */
+    getDeviceId(): Promise<string>;
+    /**
+     * Get devices for a user
+     */
+    getUserDevices(userId: string): Promise<DeviceInfo[]>;
+    /**
+     * Add a device
+     */
+    addDevice(device: DeviceInfo): Promise<void>;
+    /**
+     * Start device verification
+     */
+    startVerification(otherUserId: string, otherDeviceId: string): Promise<VerificationState>;
+    /**
+     * Get SAS emojis
+     */
+    getSASEmojis(verificationId: string): Promise<EmojiSASPair[]>;
+    /**
+     * Confirm SAS
+     */
+    confirmSAS(verificationId: string): Promise<void>;
+    /**
+     * Complete verification
+     */
+    completeVerification(verificationId: string): Promise<void>;
+    /**
+     * Cancel verification
+     */
+    cancelVerification(verificationId: string): Promise<void>;
+    /**
+     * Get verification state
+     */
+    getVerificationState(verificationId: string): Promise<VerificationState>;
+    /**
+     * Enable room encryption
+     */
+    enableRoomEncryption(roomId: string, algorithm: string): Promise<void>;
+    /**
+     * Get room encryption state
+     */
+    getRoomEncryptionState(roomId: string): Promise<RoomEncryptionState>;
+    /**
+     * Encrypt event
+     */
+    encryptEvent(roomId: string, eventType: string, content: string): Promise<string>;
+    /**
+     * Decrypt event
+     */
+    decryptEvent(roomId: string, encryptedContent: string): Promise<string>;
+    /**
+     * Cleanup
+     */
+    destroy(): Promise<void>;
+}
+declare const _default: MatrixCrypto;
+export default _default;