@vanikya/ota-react-native 0.1.0

package/src/utils/storage.ts

@@ -0,0 +1,249 @@
+import { Platform, NativeModules } from 'react-native';
+
+// Types
+export interface StoredUpdate {
+  releaseId: string;
+  version: string;
+  bundlePath: string;
+  bundleHash: string;
+  downloadedAt: number;
+}
+
+export interface StorageAdapter {
+  getDocumentDirectory(): string;
+  writeFile(path: string, data: string | ArrayBuffer): Promise<void>;
+  readFile(path: string): Promise<string>;
+  readFileAsBuffer(path: string): Promise<ArrayBuffer>;
+  deleteFile(path: string): Promise<void>;
+  exists(path: string): Promise<boolean>;
+  makeDirectory(path: string): Promise<void>;
+}
+
+// Try to use Expo FileSystem if available
+let ExpoFileSystem: any = null;
+try {
+  ExpoFileSystem = require('expo-file-system');
+} catch {
+  // Expo not available, will use native module
+}
+
+// Native module for bare React Native
+const OTAUpdateNative = NativeModules.OTAUpdate;
+
+// Expo implementation
+class ExpoStorageAdapter implements StorageAdapter {
+  getDocumentDirectory(): string {
+    return ExpoFileSystem.documentDirectory || '';
+  }
+
+  async writeFile(path: string, data: string | ArrayBuffer): Promise<void> {
+    if (data instanceof ArrayBuffer) {
+      // Convert ArrayBuffer to base64
+      const bytes = new Uint8Array(data);
+      let binary = '';
+      for (let i = 0; i < bytes.length; i++) {
+        binary += String.fromCharCode(bytes[i]);
+      }
+      const base64 = btoa(binary);
+      await ExpoFileSystem.writeAsStringAsync(path, base64, {
+        encoding: ExpoFileSystem.EncodingType.Base64,
+      });
+    } else {
+      await ExpoFileSystem.writeAsStringAsync(path, data);
+    }
+  }
+
+  async readFile(path: string): Promise<string> {
+    return ExpoFileSystem.readAsStringAsync(path);
+  }
+
+  async readFileAsBuffer(path: string): Promise<ArrayBuffer> {
+    const base64 = await ExpoFileSystem.readAsStringAsync(path, {
+      encoding: ExpoFileSystem.EncodingType.Base64,
+    });
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes.buffer;
+  }
+
+  async deleteFile(path: string): Promise<void> {
+    await ExpoFileSystem.deleteAsync(path, { idempotent: true });
+  }
+
+  async exists(path: string): Promise<boolean> {
+    const info = await ExpoFileSystem.getInfoAsync(path);
+    return info.exists;
+  }
+
+  async makeDirectory(path: string): Promise<void> {
+    await ExpoFileSystem.makeDirectoryAsync(path, { intermediates: true });
+  }
+}
+
+// Native implementation for bare React Native
+class NativeStorageAdapter implements StorageAdapter {
+  getDocumentDirectory(): string {
+    if (!OTAUpdateNative) {
+      throw new Error('OTAUpdate native module not found. Did you link the library?');
+    }
+    return OTAUpdateNative.getDocumentDirectory();
+  }
+
+  async writeFile(path: string, data: string | ArrayBuffer): Promise<void> {
+    if (!OTAUpdateNative) {
+      throw new Error('OTAUpdate native module not found');
+    }
+
+    if (data instanceof ArrayBuffer) {
+      const bytes = new Uint8Array(data);
+      let binary = '';
+      for (let i = 0; i < bytes.length; i++) {
+        binary += String.fromCharCode(bytes[i]);
+      }
+      const base64 = btoa(binary);
+      await OTAUpdateNative.writeFileBase64(path, base64);
+    } else {
+      await OTAUpdateNative.writeFile(path, data);
+    }
+  }
+
+  async readFile(path: string): Promise<string> {
+    if (!OTAUpdateNative) {
+      throw new Error('OTAUpdate native module not found');
+    }
+    return OTAUpdateNative.readFile(path);
+  }
+
+  async readFileAsBuffer(path: string): Promise<ArrayBuffer> {
+    if (!OTAUpdateNative) {
+      throw new Error('OTAUpdate native module not found');
+    }
+    const base64: string = await OTAUpdateNative.readFileBase64(path);
+    const binary = atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes.buffer;
+  }
+
+  async deleteFile(path: string): Promise<void> {
+    if (!OTAUpdateNative) {
+      throw new Error('OTAUpdate native module not found');
+    }
+    await OTAUpdateNative.deleteFile(path);
+  }
+
+  async exists(path: string): Promise<boolean> {
+    if (!OTAUpdateNative) {
+      throw new Error('OTAUpdate native module not found');
+    }
+    return OTAUpdateNative.exists(path);
+  }
+
+  async makeDirectory(path: string): Promise<void> {
+    if (!OTAUpdateNative) {
+      throw new Error('OTAUpdate native module not found');
+    }
+    await OTAUpdateNative.makeDirectory(path);
+  }
+}
+
+// Factory function to get the appropriate storage adapter
+export function getStorageAdapter(): StorageAdapter {
+  if (ExpoFileSystem) {
+    return new ExpoStorageAdapter();
+  }
+
+  if (OTAUpdateNative) {
+    return new NativeStorageAdapter();
+  }
+
+  throw new Error(
+    'No storage adapter available. Install expo-file-system or link the OTAUpdate native module.'
+  );
+}
+
+// Update storage manager
+export class UpdateStorage {
+  private storage: StorageAdapter;
+  private baseDir: string;
+
+  constructor() {
+    this.storage = getStorageAdapter();
+    this.baseDir = `${this.storage.getDocumentDirectory()}ota-update/`;
+  }
+
+  private async ensureDirectory(): Promise<void> {
+    const exists = await this.storage.exists(this.baseDir);
+    if (!exists) {
+      await this.storage.makeDirectory(this.baseDir);
+    }
+  }
+
+  async saveBundle(releaseId: string, data: ArrayBuffer): Promise<string> {
+    await this.ensureDirectory();
+
+    const bundlePath = `${this.baseDir}${releaseId}.bundle`;
+    await this.storage.writeFile(bundlePath, data);
+
+    return bundlePath;
+  }
+
+  async getBundlePath(releaseId: string): Promise<string | null> {
+    const bundlePath = `${this.baseDir}${releaseId}.bundle`;
+    const exists = await this.storage.exists(bundlePath);
+    return exists ? bundlePath : null;
+  }
+
+  async readBundle(releaseId: string): Promise<ArrayBuffer | null> {
+    const bundlePath = await this.getBundlePath(releaseId);
+    if (!bundlePath) return null;
+
+    return this.storage.readFileAsBuffer(bundlePath);
+  }
+
+  async deleteBundle(releaseId: string): Promise<void> {
+    const bundlePath = `${this.baseDir}${releaseId}.bundle`;
+    if (await this.storage.exists(bundlePath)) {
+      await this.storage.deleteFile(bundlePath);
+    }
+  }
+
+  async saveMetadata(update: StoredUpdate): Promise<void> {
+    await this.ensureDirectory();
+
+    const metadataPath = `${this.baseDir}current.json`;
+    await this.storage.writeFile(metadataPath, JSON.stringify(update));
+  }
+
+  async getMetadata(): Promise<StoredUpdate | null> {
+    const metadataPath = `${this.baseDir}current.json`;
+
+    try {
+      if (await this.storage.exists(metadataPath)) {
+        const content = await this.storage.readFile(metadataPath);
+        return JSON.parse(content);
+      }
+    } catch {
+      // Corrupted metadata, return null
+    }
+
+    return null;
+  }
+
+  async clearMetadata(): Promise<void> {
+    const metadataPath = `${this.baseDir}current.json`;
+    if (await this.storage.exists(metadataPath)) {
+      await this.storage.deleteFile(metadataPath);
+    }
+  }
+
+  async cleanOldBundles(keepReleaseId: string): Promise<void> {
+    // For now, we just keep one bundle at a time
+    // In a more advanced implementation, we might keep a few for rollback
+  }
+}

package/src/utils/verification.ts

@@ -0,0 +1,167 @@
+import { NativeModules, Platform } from 'react-native';
+
+// Try to use Expo Crypto if available
+let ExpoCrypto: any = null;
+try {
+  ExpoCrypto = require('expo-crypto');
+} catch {
+  // Expo not available
+}
+
+const OTAUpdateNative = NativeModules.OTAUpdate;
+
+// Convert ArrayBuffer to hex string
+function bufferToHex(buffer: ArrayBuffer): string {
+  const bytes = new Uint8Array(buffer);
+  return Array.from(bytes)
+    .map(b => b.toString(16).padStart(2, '0'))
+    .join('');
+}
+
+// Convert hex string to Uint8Array
+function hexToBytes(hex: string): Uint8Array {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
+  }
+  return bytes;
+}
+
+// Calculate SHA-256 hash of data
+export async function calculateHash(data: ArrayBuffer): Promise<string> {
+  if (ExpoCrypto) {
+    // Use Expo Crypto
+    const hash = await ExpoCrypto.digestStringAsync(
+      ExpoCrypto.CryptoDigestAlgorithm.SHA256,
+      bufferToHex(data),
+      { encoding: ExpoCrypto.CryptoEncoding.HEX }
+    );
+    return 'sha256:' + hash;
+  }
+
+  if (OTAUpdateNative?.calculateSHA256) {
+    // Use native module
+    const bytes = new Uint8Array(data);
+    let binary = '';
+    for (let i = 0; i < bytes.length; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    const base64 = btoa(binary);
+    const hash = await OTAUpdateNative.calculateSHA256(base64);
+    return 'sha256:' + hash;
+  }
+
+  // Fallback: Use SubtleCrypto (not available in all RN environments)
+  if (typeof crypto !== 'undefined' && crypto.subtle) {
+    const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+    return 'sha256:' + bufferToHex(hashBuffer);
+  }
+
+  throw new Error('No crypto implementation available');
+}
+
+// Verify bundle hash
+export async function verifyBundleHash(
+  data: ArrayBuffer,
+  expectedHash: string
+): Promise<boolean> {
+  const actualHash = await calculateHash(data);
+  return actualHash === expectedHash;
+}
+
+// Verify Ed25519 signature
+export async function verifySignature(
+  data: ArrayBuffer,
+  signatureHex: string,
+  publicKeyHex: string
+): Promise<boolean> {
+  // Ed25519 verification is complex in JS
+  // We rely on native modules or skip if not available
+
+  if (OTAUpdateNative?.verifySignature) {
+    const bytes = new Uint8Array(data);
+    let binary = '';
+    for (let i = 0; i < bytes.length; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    const base64 = btoa(binary);
+    return OTAUpdateNative.verifySignature(base64, signatureHex, publicKeyHex);
+  }
+
+  // If no native module, we can't verify signature
+  // In production, you might want to require this
+  if (__DEV__) {
+    console.warn(
+      '[OTAUpdate] Signature verification skipped: native module not available'
+    );
+  }
+
+  return true; // Skip verification if not available
+}
+
+// Full bundle verification
+export interface VerificationResult {
+  valid: boolean;
+  hashValid: boolean;
+  signatureValid: boolean;
+  error?: string;
+}
+
+export async function verifyBundle(
+  data: ArrayBuffer,
+  expectedHash: string,
+  signature: string | null,
+  publicKey: string | null
+): Promise<VerificationResult> {
+  // Verify hash
+  let hashValid = false;
+  try {
+    hashValid = await verifyBundleHash(data, expectedHash);
+  } catch (error) {
+    return {
+      valid: false,
+      hashValid: false,
+      signatureValid: false,
+      error: `Hash verification failed: ${error}`,
+    };
+  }
+
+  if (!hashValid) {
+    return {
+      valid: false,
+      hashValid: false,
+      signatureValid: false,
+      error: 'Bundle hash mismatch',
+    };
+  }
+
+  // Verify signature if both signature and public key are provided
+  let signatureValid = true;
+  if (signature && publicKey) {
+    try {
+      signatureValid = await verifySignature(data, signature, publicKey);
+    } catch (error) {
+      return {
+        valid: false,
+        hashValid: true,
+        signatureValid: false,
+        error: `Signature verification failed: ${error}`,
+      };
+    }
+
+    if (!signatureValid) {
+      return {
+        valid: false,
+        hashValid: true,
+        signatureValid: false,
+        error: 'Invalid bundle signature',
+      };
+    }
+  }
+
+  return {
+    valid: true,
+    hashValid: true,
+    signatureValid,
+  };
+}