@capacitor-community/sqlite 5.0.5 → 5.0.6

package/ios/Plugin/ImportExportJson/JsonSQLite.swift

@@ -7,6 +7,13 @@
 //
 
 import Foundation
+
+public struct EncryptJson: Codable {
+    let expData: String
+    public func show() {
+        print("expData: \(expData) ")
+    }
+}
 public struct JsonSQLite: Codable {
     let database: String
     let version: Int

package/ios/Plugin/Utils/UtilsJson.swift

@@ -6,6 +6,8 @@
 //
 
 import Foundation
+import CryptoKit
+import CommonCrypto
 
 enum UtilsJsonError: Error {
     case tableNotExists(message: String)
@@ -20,7 +22,12 @@ enum UtilsJsonError: Error {
     case isLastModified(message: String)
     case isSqlDeleted(message: String)
     case checkUpdate(message: String)
-    case checkValues(message: String)}
+    case checkValues(message: String)
+    case encryptDictionaryToBase64(message: String)
+    case decryptBase64ToDictionary(message: String)
+}
+
+var mSalt = "jeep_capacitor_sqlite"
 
 // swiftlint:disable file_length
 // swiftlint:disable type_body_length
@@ -466,6 +473,121 @@ class UtilsJson {
         return isViews
     }
 
+    // MARK: encryptDictionaryToBase64
+
+    class func encryptDictionaryToBase64(_ dictionary: [String: Any], forAccount account: String) throws -> String {
+        // Encryption using Swift Crypto and Keychain-stored passphrase
+
+        let jsonData = try JSONSerialization.data(withJSONObject: dictionary)
+
+        let isPassPhrase = try UtilsSecret.isPassphrase(account: account)
+        if !isPassPhrase {
+            throw UtilsJsonError.encryptDictionaryToBase64(
+                message: "No passphrase stored")
+        }
+        let passphrase = UtilsSecret.getPassphrase(account: account)
+        // Generate a constant salt
+        let salt = Data(mSalt.utf8)
+
+        // Derive the encryption key using the passphrase and salt
+        guard let key = deriveSymmetricKeyFromPassphrase(passphrase, salt: salt) else {
+            throw UtilsJsonError.encryptDictionaryToBase64(
+                message: "No Encryption key returned")
+        }
+        let symKey = SymmetricKey(data: key)
+
+        // Use Swift Crypto to perform AES encryption with GCM mode
+        let sealedBox = try AES.GCM.seal(jsonData, using: symKey, nonce: AES.GCM.Nonce())
+
+        if let combined = sealedBox.combined {
+            // combined the salt and the encrypted data
+            var saltAndEncryptedData = salt
+            saltAndEncryptedData.append(combined)
+            // Convert to base64 string
+
+            let base64String = saltAndEncryptedData.base64EncodedString()
+            return base64String
+        } else {
+            throw UtilsJsonError.encryptDictionaryToBase64(
+                message: "Conversion to base64String failed")
+
+        }
+
+    }
+
+    // MARK: decrypt DictionaryToBase64
+
+    class func decryptBase64ToDictionary(_ base64String: String,
+                                         forAccount account: String)
+    throws -> [String: Any] {
+        guard let data = Data(base64Encoded: base64String) else {
+            throw UtilsJsonError.decryptBase64ToDictionary(
+                message: "Conversion from Base64 to Dictionary failed")
+
+        }
+        let isPassPhrase = try UtilsSecret.isPassphrase(account: account)
+        if !isPassPhrase {
+            throw UtilsJsonError.decryptBase64ToDictionary(
+                message: "No passphrase stored")
+        }
+        let passphrase = UtilsSecret.getPassphrase(account: account)
+        // Generate a constant salt
+        let salt = Data(mSalt.utf8)
+
+        // Derive the encryption key using the passphrase and salt
+        guard let key = deriveSymmetricKeyFromPassphrase(passphrase,
+                                                         salt: salt) else {
+            throw UtilsJsonError.encryptDictionaryToBase64(
+                message: "No Encryption key returned")
+        }
+        let symKey = SymmetricKey(data: key)
+
+        // Extract the encrypted data from the remaining bytes
+        let encryptedData = data.suffix(from: salt.count)
+
+        // Convert the base64 string to a sealed box
+        let sealedBox = try AES.GCM.SealedBox(combined: encryptedData)
+
+        // Decrypt the ciphertext using AES GCM open
+        let decryptedData = try AES.GCM.open(sealedBox, using: symKey)
+
+        // Convert decrypted data to dictionary
+        let dictionary = try JSONSerialization.jsonObject(
+            with: decryptedData) as? [String: Any] ?? [:]
+
+        return dictionary
+    }
+
+    // MARK: deriveSymmetricKeyFromPassphrase
+
+    class func deriveSymmetricKeyFromPassphrase(_ passphrase: String,
+                                                salt: Data)
+    -> Data? {
+
+        let passphraseData = Data(passphrase.utf8)
+        let keyLength = kCCKeySizeAES256
+        let iterations: UInt32 = 10000
+        var derivedKeyData = Data(count: keyLength)
+        let derivedCount = derivedKeyData.count
+        let derivationStatus = derivedKeyData.withUnsafeMutableBytes { derivedKeyUnsafeMutableRawBufferPointer in
+            passphraseData.withUnsafeBytes { passphraseUnsafeRawBufferPointer in
+                salt.withUnsafeBytes { saltUnsafeRawBufferPointer in
+                    CCKeyDerivationPBKDF(
+                        CCPBKDFAlgorithm(kCCPBKDF2),
+                        passphraseUnsafeRawBufferPointer.baseAddress,
+                        passphraseData.count,
+                        saltUnsafeRawBufferPointer.baseAddress,
+                        salt.count,
+                        CCPseudoRandomAlgorithm(kCCPRFHmacAlgSHA256),
+                        iterations,
+                        derivedKeyUnsafeMutableRawBufferPointer.baseAddress,
+                        derivedCount
+                    )
+                }
+            }
+        }
+        return derivationStatus == kCCSuccess ? derivedKeyData : nil
+    }
 }
 // swiftlint:enable type_body_length
 // swiftlint:enable file_length

package/ios/Plugin/Utils/UtilsSQLCipher.swift

@@ -1301,7 +1301,6 @@ class UtilsSQLCipher {
                     return true // Keep dictionaries without any keys
                 }
                 return !keysInArray1.contains(dict2Key)
-
             }
         }
         retResponse.append(contentsOf: mRespSet)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capacitor-community/sqlite",
-  "version": "5.0.5",
+  "version": "5.0.6",
   "description": "Community plugin for native & electron SQLite databases",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",

package/src/definitions.ts

@@ -120,6 +120,20 @@ export interface CapacitorSQLitePlugin {
    * @since 0.0.1
    */
   close(options: capSQLiteOptions): Promise<void>;
+  /**
+   * Load a SQlite extension
+   * @param options :capSQLiteExtensionPath
+   * @returns Promise<void>
+   * @since 5.0.6
+   */
+  //  loadExtension(options: capSQLiteExtensionPath): Promise<void>;
+  /**
+   * Enable Or Disable Extension Loading
+   * @param options
+   * @returns Promise<void>
+   * @since 5.0.6
+   */
+  //  enableLoadExtension(options: capSQLiteExtensionEnable): Promise<void>;
   /**
    * GetUrl get the database Url
    * @param options: capSQLiteOptions
@@ -391,6 +405,38 @@ export interface capEchoOptions {
    */
   value?: string;
 }
+export interface capSQLiteExtensionPath {
+  /**
+   * The database name
+   */
+  database?: string;
+  /**
+   * The extension path
+   */
+  path?: string;
+  /**
+   * ReadOnly / ReadWrite
+   * default ReadWrite (false)
+   * @since 4.1.0-7
+   */
+  readonly?: boolean;
+}
+export interface capSQLiteExtensionEnable {
+  /**
+   * The database name
+   */
+  database?: string;
+  /**
+   * The enabling toggle (1: ON, 0: OFF)
+   */
+  toggle?: boolean;
+  /**
+   * ReadOnly / ReadWrite
+   * default ReadWrite (false)
+   * @since 4.1.0-7
+   */
+  readonly?: boolean;
+}
 export interface capConnectionOptions {
   /**
    * The database name
@@ -436,6 +482,7 @@ export interface capSQLiteOptions {
    */
   readonly?: boolean;
 }
+
 export interface capNCDatabasePathOptions {
   /**
    * the database path
@@ -769,6 +816,12 @@ export interface capSQLiteSyncDate {
 }
 
 /* JSON Types */
+export interface EncryptJson {
+  /**
+   * The encrypted JsonSQLite base64 string
+   */
+  expData: string;
+}
 export interface JsonSQLite {
   /**
    * The database name
@@ -1699,6 +1752,20 @@ export interface ISQLiteDBConnection {
    * @since 3.2.0
    */
   getVersion(): Promise<capVersionResult>;
+  /**
+   * Load a SQlite extension
+   * @param path :SQlite extension path
+   * @returns Promise<void>
+   * @since 5.0.6
+   */
+  loadExtension(path: string): Promise<void>;
+  /**
+   * Enable Or Disable Extension Loading
+   * @param toggle true:on false:off
+   * @returns Promise<void>
+   * @since 5.0.6
+   */
+  enableLoadExtension(toggle: boolean): Promise<void>;
   /**
    * Execute SQLite DB Connection Statements
    * @param statements
@@ -1849,6 +1916,43 @@ export class SQLiteDBConnection implements ISQLiteDBConnection {
       return Promise.reject(err);
     }
   }
+
+  async loadExtension(path: string): Promise<void> {
+    try {
+      console.log(`database: ${this.dbName}`);
+      console.log(`readonly: ${this.readonly}}`);
+      console.log(`path: ${path}}`);
+      await this.sqlite.loadExtension({
+        database: this.dbName,
+        path: path,
+        readonly: this.readonly,
+      });
+      console.log(`loadExtension successful`);
+      return Promise.resolve();
+    } catch (err) {
+      console.log(`loadExtension failed `);
+      return Promise.reject(err);
+    }
+  }
+  async enableLoadExtension(toggle: boolean): Promise<void> {
+    try {
+      console.log(`database: ${this.dbName}`);
+      console.log(`readonly: ${this.readonly}`);
+      console.log(`toggle: ${toggle}`);
+      await this.sqlite.enableLoadExtension({
+        database: this.dbName,
+        toggle: toggle,
+        readonly: this.readonly,
+      });
+      console.log(`enableLoadExtension successful`);
+      return Promise.resolve();
+    } catch (err) {
+      console.log(err);
+      console.log(`enableLoadExtension failed `);
+      return Promise.reject(err);
+    }
+  }
+
   async getUrl(): Promise<capSQLiteUrl> {
     try {
       const res: capSQLiteUrl = await this.sqlite.getUrl({

package/src/web.ts

@@ -32,6 +32,8 @@ import type {
   capSQLiteUrl,
   capSQLiteValues,
   capVersionResult,
+  capSQLiteExtensionPath,
+  capSQLiteExtensionEnable,
 } from './definitions';
 
 export class CapacitorSQLiteWeb
@@ -591,4 +593,12 @@ export class CapacitorSQLiteWeb
   async isInConfigBiometricAuth(): Promise<capSQLiteResult> {
     throw this.unimplemented('Not implemented on web.');
   }
+  async loadExtension(options: capSQLiteExtensionPath): Promise<void> {
+    console.log('loadExtension', options);
+    throw this.unimplemented('Not implemented on web.');
+  }
+  async enableLoadExtension(options: capSQLiteExtensionEnable): Promise<void> {
+    console.log('enableLoadExtension', options);
+    throw this.unimplemented('Not implemented on web.');
+  }
 }