@capacitor-community/sqlite 4.6.2-1 → 4.6.2-3

package/ios/Plugin/CapacitorSQLite.swift

@@ -606,6 +606,34 @@ enum CapacitorSQLiteError: Error {
         }
     }
 
+    // MARK: - IsDatabaseEncrypted
+
+    @objc public func isDatabaseEncrypted(_ dbName: String) throws -> NSNumber {
+        if isInit {
+            let mDbName = CapacitorSQLite.getDatabaseName(dbName: dbName)
+            let isFileExists: Bool = UtilsFile
+                .isFileExist(databaseLocation: databaseLocation,
+                             fileName: mDbName + "SQLite.db")
+            if isFileExists {
+                let state: State = UtilsSQLCipher
+                    .getDatabaseState(databaseLocation: databaseLocation,
+                                      databaseName: mDbName + "SQLite.db",
+                                      account: account)
+                if state.rawValue == "ENCRYPTEDGLOBALSECRET" || state.rawValue == "ENCRYPTEDSECRET" {
+                    return 1
+                }
+                if state.rawValue == "UNENCRYPTED" {
+                    return 0
+                }
+                throw CapacitorSQLiteError.failed(message: "Database unknown")
+            } else {
+                throw CapacitorSQLiteError.failed(message: "Database does not exist")
+            }
+        } else {
+            throw CapacitorSQLiteError.failed(message: initMessage)
+        }
+    }
+
     // MARK: - IsNCDatabase
 
     @objc public func isNCDatabase(_ databasePath: String) throws -> NSNumber {

package/ios/Plugin/CapacitorSQLitePlugin.m

@@ -46,4 +46,7 @@ CAP_PLUGIN(CapacitorSQLitePlugin, "CapacitorSQLite",
            CAP_PLUGIN_METHOD(clearEncryptionSecret, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(getFromHTTPRequest, CAPPluginReturnPromise);
            CAP_PLUGIN_METHOD(checkEncryptionSecret, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(isInConfigEncryption, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(isInConfigBiometricAuth, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(isDatabaseEncrypted, CAPPluginReturnPromise);
 )

package/ios/Plugin/CapacitorSQLitePlugin.swift

@@ -41,6 +41,56 @@ public class CapacitorSQLitePlugin: CAPPlugin {
         }
     }
 
+    // MARK: - IsInConfigEncryption
+
+    @objc func isInConfigEncryption(_ call: CAPPluginCall) {
+        var bRes: Bool = false
+        if self.config?.iosIsEncryption == 1 {
+            bRes = true
+        }
+
+        retHandler.rResult(call: call, ret: bRes)
+    }
+
+    // MARK: - IsInConfigBiometricAuth
+
+    @objc func isInConfigBiometricAuth(_ call: CAPPluginCall) {
+        var bRes: Bool = false
+        if self.config?.biometricAuth == 1 {
+            bRes = true
+        }
+
+        retHandler.rResult(call: call, ret: bRes)
+    }
+    // MARK: - IsDatabaseEncrypted
+
+    @objc func isDatabaseEncrypted(_ call: CAPPluginCall) {
+        guard let dbName = call.options["database"] as? String else {
+            retHandler.rResult(
+                call: call, ret: false,
+                message: "isDatabaseEncrypted: Must provide a database name")
+            return
+        }
+        do {
+            let res = try implementation?.isDatabaseEncrypted(dbName)
+            var bRes: Bool = false
+            if res == 1 {
+                bRes = true
+            }
+            retHandler.rResult(call: call, ret: bRes)
+        } catch CapacitorSQLiteError.failed(let message) {
+            let msg = "isDatabaseEncrypted: \(message)"
+            retHandler.rResult(call: call, message: msg)
+            return
+        } catch let error {
+            retHandler.rResult(
+                call: call,
+                message: "isDatabaseEncrypted: \(error)")
+            return
+        }
+
+    }
+
     // MARK: - IsSecretStored
 
     @objc func isSecretStored(_ call: CAPPluginCall) {

package/ios/Plugin/Database.swift

@@ -103,6 +103,11 @@ class Database {
     func open () throws {
         var password: String = ""
         if isEncryption && encrypted && (mode == "secret" || mode == "encryption") {
+            let isPassphrase = try UtilsSecret.isPassphrase(account: account)
+            if !isPassphrase {
+                let msg: String = "No Passphrase stored"
+                throw DatabaseError.open(message: msg)
+            }
             password = UtilsSecret.getPassphrase(account: account)
         }
         if mode == "encryption" {
@@ -110,7 +115,8 @@ class Database {
                 do {
                     let ret: Bool = try UtilsEncryption
                         .encryptDatabase(databaseLocation: databaseLocation,
-                                         filePath: path, password: password)
+                                         filePath: path, password: password,
+                                         version: dbVersion)
                     if !ret {
                         let msg: String = "Failed in encryption"
                         throw DatabaseError.open(message: msg)

package/ios/Plugin/Utils/UtilsEncryption.swift

@@ -18,9 +18,10 @@ class UtilsEncryption {
 
     // swiftlint:disable function_body_length
     class func encryptDatabase(databaseLocation: String, filePath: String,
-                               password: String) throws -> Bool {
+                               password: String, version: Int) throws -> Bool {
         var ret: Bool = false
         var oDB: OpaquePointer?
+        var eDB: OpaquePointer?
         do {
             if UtilsFile.isFileExist(filePath: filePath) {
                 do {
@@ -34,7 +35,7 @@ class UtilsEncryption {
                         .openOrCreateDatabase(filename: tempPath,
                                               password: "",
                                               readonly: false)
-                    try _ = UtilsSQLCipher
+                    eDB = try UtilsSQLCipher
                         .openOrCreateDatabase(filename: filePath,
                                               password: password,
                                               readonly: false)
@@ -48,6 +49,13 @@ class UtilsEncryption {
                         try _ = UtilsFile
                             .deleteFile(fileName: "temp.db",
                                         databaseLocation: databaseLocation)
+                        // set the version
+                        let sqltr: String = "PRAGMA user_version = \(version);"
+                        if sqlite3_exec(eDB, sqltr, nil, nil, nil) != SQLITE_OK {
+                            throw UtilsEncryptionError
+                            .encryptionFailed(message: "set version to \(version) failed")
+                        }
+
                         ret = true
                     }
                     // close the db

package/package.json

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

package/src/definitions.ts

@@ -158,6 +158,25 @@ export interface CapacitorSQLitePlugin {
    * @since 3.0.0-beta.5
    */
   isDBOpen(options: capSQLiteOptions): Promise<capSQLiteResult>;
+  /**
+   * Check if a SQLite database is encrypted
+   * @param options: capSQLiteOptions
+   * @returns Promise<capSQLiteResult>
+   * @since 4.6.2-2
+   */
+  isDatabaseEncrypted(options: capSQLiteOptions): Promise<capSQLiteResult>;
+  /**
+   * Check encryption value in capacitor.config
+   * @returns Promise<capSQLiteResult>
+   * @since 4.6.2-2
+   */
+  isInConfigEncryption(): Promise<capSQLiteResult>;
+  /**
+   * Check encryption value in capacitor.config
+   * @returns Promise<capSQLiteResult>
+   * @since 4.6.2-2
+   */
+  isInConfigBiometricAuth(): Promise<capSQLiteResult>;
   /**
    * Check if a SQLite database exists without connection
    * @param options: capSQLiteOptions
@@ -1054,6 +1073,25 @@ export interface ISQLiteConnection {
    * @since 4.1.1
    */
   getFromHTTPRequest(url?: string, overwrite?: boolean): Promise<void>;
+  /**
+   * Check if a SQLite database is encrypted
+   * @param options: capSQLiteOptions
+   * @returns Promise<capSQLiteResult>
+   * @since 4.6.2-2
+   */
+  isDatabaseEncrypted(database: string): Promise<capSQLiteResult>;
+  /**
+   * Check encryption value in capacitor.config
+   * @returns Promise<capSQLiteResult>
+   * @since 4.6.2-2
+   */
+  isInConfigEncryption(): Promise<capSQLiteResult>;
+  /**
+   * Check encryption value in capacitor.config
+   * @returns Promise<capSQLiteResult>
+   * @since 4.6.2-2
+   */
+  isInConfigBiometricAuth(): Promise<capSQLiteResult>;
   /**
    * Check if a database exists
    * @param database
@@ -1418,6 +1456,31 @@ export class SQLiteConnection implements ISQLiteConnection {
       return Promise.reject(err);
     }
   }
+  async isDatabaseEncrypted(database: string): Promise<capSQLiteResult> {
+    if (database.endsWith('.db')) database = database.slice(0, -3);
+    try {
+      const res = await this.sqlite.isDatabaseEncrypted({ database: database });
+      return Promise.resolve(res);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  async isInConfigEncryption(): Promise<capSQLiteResult> {
+    try {
+      const res = await this.sqlite.isInConfigEncryption();
+      return Promise.resolve(res);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  async isInConfigBiometricAuth(): Promise<capSQLiteResult> {
+    try {
+      const res = await this.sqlite.isInConfigBiometricAuth();
+      return Promise.resolve(res);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
   async isDatabase(database: string): Promise<capSQLiteResult> {
     if (database.endsWith('.db')) database = database.slice(0, -3);
     try {

package/src/web.ts

@@ -536,4 +536,19 @@ export class CapacitorSQLiteWeb
     console.log('isNCDatabase', options);
     throw this.unimplemented('Not implemented on web.');
   }
+
+  async isDatabaseEncrypted(
+    options: capSQLiteOptions,
+  ): Promise<capSQLiteResult> {
+    console.log('isDatabaseEncrypted', options);
+    throw this.unimplemented('Not implemented on web.');
+  }
+
+  async isInConfigEncryption(): Promise<capSQLiteResult> {
+    throw this.unimplemented('Not implemented on web.');
+  }
+
+  async isInConfigBiometricAuth(): Promise<capSQLiteResult> {
+    throw this.unimplemented('Not implemented on web.');
+  }
 }