70 |
71 | #### Using SQLCipher for Android With Room
72 |
73 | SQLCipher for Android has a `SupportFactory` class in the `net.sqlcipher.database` package
74 | that can be used to configure Room to use SQLCipher for Android.
75 |
76 | There are three `SupportFactory` constructors:
77 |
78 | - `SupportFactory(byte[] passphrase)`
79 | - `SupportFactory(byte[] passphrase, SQLiteDatabaseHook hook)`
80 | - `SupportFactory(byte[] passphrase, SQLiteDatabaseHook hook, boolean clearPassphrase)`
81 |
82 | All three take a `byte[]` to use as the passphrase (if you have a `char[]`, use
83 | `SQLiteDatabase.getBytes()` to get a suitable `byte[]` to use).
84 |
85 | Two offer a `SQLiteDatabaseHook` parameter that you can use
86 | for executing SQL statements before or after the passphrase is used to key
87 | the database.
88 |
89 | The three-parameter constructor also offers `clearPassphrase`, which defaults
90 | to `true` in the other two constructors. If `clearPassphrase` is set to `true`,
91 | this will zero out the bytes of the `byte[]` after we open the database. This
92 | is safest from a security standpoint, but it does mean that the `SupportFactory`
93 | instance is a single-use object. Attempting to reuse the `SupportFactory`
94 | instance later will result in being unable to open the database, because the
95 | passphrase will be wrong. If you think that you might need to reuse the
96 | `SupportFactory` instance, pass `false` for `clearPassphrase`.
97 |
98 | Then, pass your `SupportFactory` to `openHelperFactory()` on your `RoomDatabase.Builder`:
99 |
100 | ```java
101 | final byte[] passphrase = SQLiteDatabase.getBytes(userEnteredPassphrase);
102 | final SupportFactory factory = new SupportFactory(passphrase);
103 | final SomeDatabase room = Room.databaseBuilder(activity, SomeDatabase.class, DB_NAME)
104 | .openHelperFactory(factory)
105 | .build();
106 | ```
107 |
108 | Now, Room will make all of its database requests using SQLCipher for Android instead
109 | of the framework copy of SQLCipher.
110 |
111 | Note that `SupportFactory` should work with other consumers of the `androidx.sqlite` API;
112 | Room is merely a prominent example.
113 |
114 | #### Using SQLCipher for Android's Native API
115 |
116 | If you have existing SQLite code using classes like `SQLiteDatabase` and `SQLiteOpenHelper`,
117 | converting your code to use SQLCipher for Android mostly is a three-step process:
118 |
119 | 1. Replace all `android.database.sqlite.*` `import` statements with ones that
120 | use `net.sqlcipher.database.*` (e.g., convert `android.database.sqlite.SQLiteDatabase`
121 | to `net.sqlcipher.database.SQLiteDatabase`)
122 |
123 | 2. Before attempting to open a database, call `SQLiteDatabase.loadLibs()`, passing
124 | in a `Context` (e.g., add this to `onCreate()` of your `Application` subclass, using
125 | the `Application` itself as the `Context`)
126 |
127 | 3. When opening a database (e.g., `SQLiteDatabase.openOrCreateDatabase()`), pass
128 | in the passphrase as a `char[]` or `byte[]`
129 |
130 | The rest of your code may not need any changes.
131 |
132 | An article covering both integration of SQLCipher into an Android application as well as building the source can be found [here](https://www.zetetic.net/sqlcipher/sqlcipher-for-android/).
133 |
134 | ### ProGuard
135 |
136 | For applications which utilize ProGuard, a few additional rules must be included when using SQLCipher for Android. These rules instruct ProGuard to omit the renaming of the internal SQLCipher classes which are used via lookup from the JNI layer. It is worth noting that since SQLCipher or Android is based on open source code there is little value in obfuscating the library anyway. The more important use of ProGuard is to protect your application code and business logic.
137 |
138 | ```
139 | -keep,includedescriptorclasses class net.sqlcipher.** { *; }
140 | -keep,includedescriptorclasses interface net.sqlcipher.** { *; }
141 | ```
142 |
143 | ### Building
144 |
145 | In order to build `android-database-sqlcipher` from source you will need both the Android SDK, Gradle, Android NDK, SQLCipher core source directory, and an OpenSSL source directory. We currently recommend using Android NDK LTS version `23.0.7599858`.
146 |
147 | To complete the `make` command, the `ANDROID_NDK_HOME` environment variable must be defined which should point to your NDK root. Once you have cloned the repo, change directory into the root of the repository and run the following commands:
148 |
149 | ```
150 | SQLCIPHER_ROOT=/some/path/to/sqlcipher-folder \
151 | OPENSSL_ROOT=/some/path/to/openssl-folder \
152 | SQLCIPHER_CFLAGS="-DSQLITE_HAS_CODEC -DSQLITE_TEMP_STORE=2" \
153 | SQLCIPHER_ANDROID_VERSION="4.5.3" \
154 | make build-release
155 | ```
156 |
157 | You may specify other build flags/features within `SQLCIPHER_CFLAGS`, however, specifying `-DSQLITE_HAS_CODEC` and `-DSQLITE_TEMP_STORE` is necessary in the list of flags.
158 |
159 | ### License
160 |
161 | The Android support libraries are licensed under Apache 2.0, in line with the Android OS code on which they are based. The SQLCipher code itself is licensed under a BSD-style license from Zetetic LLC. Finally, the original SQLite code itself is in the public domain.
162 |
--------------------------------------------------------------------------------
/SQLCIPHER_LICENSE:
--------------------------------------------------------------------------------
1 | http://sqlcipher.net
2 |
3 | Copyright (c) 2010 Zetetic LLC
4 | All rights reserved.
5 |
6 | Redistribution and use in source and binary forms, with or without
7 | modification, are permitted provided that the following conditions are met:
8 | * Redistributions of source code must retain the above copyright
9 | notice, this list of conditions and the following disclaimer.
10 | * Redistributions in binary form must reproduce the above copyright
11 | notice, this list of conditions and the following disclaimer in the
12 | documentation and/or other materials provided with the distribution.
13 | * Neither the name of the ZETETIC LLC nor the
14 | names of its contributors may be used to endorse or promote products
15 | derived from this software without specific prior written permission.
16 |
17 | THIS SOFTWARE IS PROVIDED BY ZETETIC LLC ''AS IS'' AND ANY
18 | EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19 | WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20 | DISCLAIMED. IN NO EVENT SHALL ZETETIC LLC BE LIABLE FOR ANY
21 | DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22 | (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23 | LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24 | ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
26 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 |
--------------------------------------------------------------------------------
/android-database-sqlcipher/build-openssl-libraries.sh:
--------------------------------------------------------------------------------
1 | #! /usr/bin/env bash
2 |
3 | MINIMUM_ANDROID_SDK_VERSION=$1
4 | MINIMUM_ANDROID_64_BIT_SDK_VERSION=$2
5 | OPENSSL_DIR=$3
6 | ANDROID_LIB_ROOT=$4
7 |
8 | (cd ${OPENSSL_DIR};
9 |
10 | if [[ ! ${MINIMUM_ANDROID_SDK_VERSION} ]]; then
11 | echo "MINIMUM_ANDROID_SDK_VERSION was not provided, include and rerun"
12 | exit 1
13 | fi
14 |
15 | if [[ ! ${MINIMUM_ANDROID_64_BIT_SDK_VERSION} ]]; then
16 | echo "MINIMUM_ANDROID_64_BIT_SDK_VERSION was not provided, include and rerun"
17 | exit 1
18 | fi
19 |
20 | if [[ ! ${ANDROID_NDK_HOME} ]]; then
21 | echo "ANDROID_NDK_HOME environment variable not set, set and rerun"
22 | exit 1
23 | fi
24 |
25 | HOST_INFO=`uname -a`
26 | case ${HOST_INFO} in
27 | Darwin*)
28 | TOOLCHAIN_SYSTEM=darwin-x86_64
29 | ;;
30 | Linux*)
31 | if [[ "${HOST_INFO}" == *i686* ]]
32 | then
33 | TOOLCHAIN_SYSTEM=linux-x86
34 | else
35 | TOOLCHAIN_SYSTEM=linux-x86_64
36 | fi
37 | ;;
38 | *)
39 | echo "Toolchain unknown for host system"
40 | exit 1
41 | ;;
42 | esac
43 |
44 | NDK_TOOLCHAIN_VERSION=4.9
45 | OPENSSL_CONFIGURE_OPTIONS="-fPIC -fstack-protector-all no-idea no-camellia \
46 | no-seed no-bf no-cast no-rc2 no-rc4 no-rc5 no-md2 \
47 | no-md4 no-ecdh no-sock no-ssl3 \
48 | no-dsa no-dh no-ec no-ecdsa no-tls1 \
49 | no-rfc3779 no-whirlpool no-srp \
50 | no-mdc2 no-ecdh no-engine \
51 | no-srtp"
52 |
53 | rm -rf ${ANDROID_LIB_ROOT}
54 |
55 | for SQLCIPHER_TARGET_PLATFORM in armeabi-v7a x86 x86_64 arm64-v8a
56 | do
57 | echo "Building libcrypto.a for ${SQLCIPHER_TARGET_PLATFORM}"
58 | case "${SQLCIPHER_TARGET_PLATFORM}" in
59 | armeabi-v7a)
60 | CONFIGURE_ARCH="android-arm -march=armv7-a"
61 | ANDROID_API_VERSION=${MINIMUM_ANDROID_SDK_VERSION}
62 | OFFSET_BITS=32
63 | ;;
64 | x86)
65 | CONFIGURE_ARCH=android-x86
66 | ANDROID_API_VERSION=${MINIMUM_ANDROID_SDK_VERSION}
67 | OFFSET_BITS=32
68 | ;;
69 | x86_64)
70 | CONFIGURE_ARCH=android64-x86_64
71 | ANDROID_API_VERSION=${MINIMUM_ANDROID_64_BIT_SDK_VERSION}
72 | OFFSET_BITS=64
73 | ;;
74 | arm64-v8a)
75 | CONFIGURE_ARCH=android-arm64
76 | ANDROID_API_VERSION=${MINIMUM_ANDROID_64_BIT_SDK_VERSION}
77 | OFFSET_BITS=64
78 | ;;
79 | *)
80 | echo "Unsupported build platform:${SQLCIPHER_TARGET_PLATFORM}"
81 | exit 1
82 | esac
83 | TOOLCHAIN_BIN_PATH=${ANDROID_NDK_HOME}/toolchains/llvm/prebuilt/${TOOLCHAIN_SYSTEM}/bin
84 | PATH=${TOOLCHAIN_BIN_PATH}:${PATH} \
85 | ./Configure ${CONFIGURE_ARCH} \
86 | -D__ANDROID_API__=${ANDROID_API_VERSION} \
87 | -D_FILE_OFFSET_BITS=${OFFSET_BITS} \
88 | ${OPENSSL_CONFIGURE_OPTIONS}
89 |
90 | if [[ $? -ne 0 ]]; then
91 | echo "Error executing:./Configure ${CONFIGURE_ARCH} ${OPENSSL_CONFIGURE_OPTIONS}"
92 | exit 1
93 | fi
94 |
95 | make clean
96 | PATH=${TOOLCHAIN_BIN_PATH}:${PATH} \
97 | make build_libs
98 |
99 | if [[ $? -ne 0 ]]; then
100 | echo "Error executing make for platform:${SQLCIPHER_TARGET_PLATFORM}"
101 | exit 1
102 | fi
103 | mkdir -p ${ANDROID_LIB_ROOT}/${SQLCIPHER_TARGET_PLATFORM}
104 | mv libcrypto.a ${ANDROID_LIB_ROOT}/${SQLCIPHER_TARGET_PLATFORM}
105 | done
106 | )
107 |
--------------------------------------------------------------------------------
/android-database-sqlcipher/build.gradle:
--------------------------------------------------------------------------------
1 | apply plugin: "com.android.library"
2 | apply plugin: "org.ec4j.editorconfig"
3 | apply from: "native.gradle"
4 | apply from: "maven.gradle"
5 |
6 | android {
7 |
8 | compileSdkVersion "${compileAndroidSdkVersion}" as Integer
9 |
10 | defaultConfig {
11 | versionName "${clientVersionNumber}"
12 | minSdkVersion "${minimumAndroidSdkVersion}"
13 | targetSdkVersion "${targetAndroidSdkVersion}"
14 | versionCode 1
15 | versionName "${clientVersionNumber}"
16 | archivesBaseName = "${archivesBaseName}-${versionName}"
17 | }
18 |
19 | editorconfig {
20 | includes = ["src/**", "*.gradle"]
21 | excludes = ["src/main/external/sqlcipher/**", "src/main/external/openssl-*/**"]
22 | }
23 |
24 | buildTypes {
25 | debug {
26 | debuggable true
27 | buildConfigField("String", "VERSION_NAME", "\"${clientVersionNumber}\"")
28 | }
29 | release {
30 | debuggable false
31 | minifyEnabled false
32 | buildConfigField("String", "VERSION_NAME", "\"${clientVersionNumber}\"")
33 | }
34 | }
35 |
36 | sourceSets {
37 | main {
38 | jniLibs.srcDirs "${rootProject.ext.nativeRootOutputDir}/libs"
39 | }
40 | }
41 |
42 | dependencies {
43 | implementation "androidx.sqlite:sqlite:2.2.0"
44 | }
45 |
46 | editorconfig {
47 | excludes = ['src/main/cpp/sqlite3.*',
48 | 'src/main/external/sqlcipher/**',
49 | 'src/main/external/openssl-*/**']
50 | }
51 |
52 | clean.dependsOn cleanNative
53 | check.dependsOn editorconfigCheck
54 | buildNative.mustRunAfter buildAmalgamation
55 | buildAmalgamation.mustRunAfter buildOpenSSL
56 | preBuild.dependsOn([buildOpenSSL, buildAmalgamation, copyAmalgamation, buildNative])
57 | buildNative.mustRunAfter(copyAmalgamation)
58 | }
59 |
--------------------------------------------------------------------------------
/android-database-sqlcipher/maven.gradle:
--------------------------------------------------------------------------------
1 | apply plugin: "maven-publish"
2 | apply plugin: "signing"
3 | import org.gradle.plugins.signing.Sign
4 |
5 | def isReleaseBuild() {
6 | return mavenVersionName.contains("SNAPSHOT") == false
7 | }
8 |
9 | def getReleaseRepositoryUrl() {
10 | return hasProperty('mavenReleaseRepositoryUrl') ? mavenReleaseRepositoryUrl
11 | : "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
12 | }
13 |
14 | def getSnapshotRepositoryUrl() {
15 | if(hasProperty('mavenLocalRepositoryPrefix')) {
16 | return "${mavenLocalRepositoryPrefix}${buildDir}/${mavenSnapshotRepositoryUrl}"
17 | } else {
18 | return hasProperty('mavenSnapshotRepositoryUrl') ? mavenSnapshotRepositoryUrl
19 | : "https://oss.sonatype.org/content/repositories/snapshots/"
20 | }
21 | }
22 |
23 | def getRepositoryUsername() {
24 | return hasProperty('nexusUsername') ? nexusUsername : ""
25 | }
26 |
27 | def getRepositoryPassword() {
28 | return hasProperty('nexusPassword') ? nexusPassword : ""
29 | }
30 |
31 | gradle.taskGraph.whenReady { taskGraph ->
32 | if (taskGraph.allTasks.any { it instanceof Sign }) {
33 | allprojects { ext."signing.keyId" = "${signingKeyId}" }
34 | allprojects { ext."signing.secretKeyRingFile" = "${signingKeyRingFile}" }
35 | allprojects { ext."signing.password" = "${signingKeyPassword}" }
36 | }
37 | }
38 |
39 |
40 |
41 | afterEvaluate { project ->
42 | publishing {
43 | publications {
44 | mavenJava(MavenPublication) {
45 | from components.release
46 | groupId = mavenGroup
47 | artifactId = mavenArtifactId
48 | version = mavenVersionName
49 | pom {
50 | name = mavenArtifactId
51 | description = mavenPomDescription
52 | url = mavenPomUrl
53 | licenses {
54 | license {
55 | url = mavenLicenseUrl
56 | }
57 | }
58 | developers {
59 | developer {
60 | name = mavenDeveloperName
61 | email = mavenDeveloperEmail
62 | }
63 | }
64 | scm {
65 | connection = mavenScmConnection
66 | developerConnection = mavenScmDeveloperConnection
67 | url = mavenScmUrl
68 | }
69 | }
70 | }
71 | }
72 | repositories {
73 | maven {
74 | def repoUrl = isReleaseBuild()
75 | ? getReleaseRepositoryUrl()
76 | : getSnapshotRepositoryUrl()
77 | url = repoUrl
78 | credentials {
79 | username = getRepositoryUsername()
80 | password = getRepositoryPassword()
81 | }
82 | }
83 | }
84 | }
85 |
86 | signing {
87 | required { isReleaseBuild() && gradle.taskGraph.hasTask("publish") }
88 | sign publishing.publications.mavenJava
89 | }
90 |
91 | task androidSourcesJar(type: Jar) {
92 | classifier = "sources"
93 | from android.sourceSets.main.java.sourceFiles
94 | }
95 |
96 | artifacts {
97 | archives androidSourcesJar
98 | }
99 | }
100 |
--------------------------------------------------------------------------------
/android-database-sqlcipher/native.gradle:
--------------------------------------------------------------------------------
1 | import org.gradle.internal.logging.text.StyledTextOutputFactory
2 | import static org.gradle.internal.logging.text.StyledTextOutput.Style
3 |
4 | task buildOpenSSL() {
5 | onlyIf {
6 | def armNativeFile = new File("${androidNativeRootDir}/armeabi-v7a/libcrypto.a")
7 | if (armNativeFile.exists()) {
8 | def out = services.get(StyledTextOutputFactory).create("")
9 | out.style(Style.Normal).text("${androidNativeRootDir}/armeabi-v7a/libcrypto.a exists").style(Style.Info).println(' SKIPPED')
10 | }
11 | return !armNativeFile.exists()
12 | }
13 | doLast {
14 | def nativeRootDirectory = new File("${androidNativeRootDir}")
15 | if(!nativeRootDirectory.exists()){
16 | nativeRootDirectory.mkdirs()
17 | }
18 | exec {
19 | workingDir "${projectDir}"
20 | commandLine "./build-openssl-libraries.sh",
21 | "${minimumAndroidSdkVersion}",
22 | "${minimumAndroid64BitSdkVersion}",
23 | "${opensslDir}",
24 | "${androidNativeRootDir}"
25 | }
26 | }
27 | }
28 |
29 | task buildAmalgamation() {
30 | onlyIf {
31 | def amalgamation = new File("${sqlcipherDir}/sqlite3.c")
32 | return !amalgamation.exists()
33 | }
34 | doLast {
35 | exec {
36 | workingDir "${sqlcipherDir}"
37 | environment("CFLAGS", "${sqlcipherCFlags}")
38 | commandLine "./configure", "--enable-tempstore=yes", "--with-crypto-lib=none"
39 | }
40 | exec {
41 | workingDir "${sqlcipherDir}"
42 | environment("CFLAGS", "${sqlcipherCFlags}")
43 | commandLine "make", "sqlite3.c"
44 | }
45 | }
46 | }
47 |
48 | task copyAmalgamation() {
49 | doLast {
50 | exec {
51 | workingDir "${sqlcipherDir}"
52 | commandLine "cp", "sqlite3.c", "sqlite3.h", "${nativeRootOutputDir}/cpp/"
53 | }
54 | }
55 | }
56 |
57 | task buildNative() {
58 | description "Build the native SQLCipher binaries"
59 | doLast {
60 | executeNdkBuild(
61 | "${nativeRootOutputDir}/libs32",
62 | file("src/main/cpp").absolutePath,
63 | file("src/main/cpp/Application32.mk").absolutePath,
64 | "${sqlcipherCFlags}", "${otherSqlcipherCFlags}",
65 | "${minimumAndroidSdkVersion}")
66 | executeNdkBuild(
67 | "${nativeRootOutputDir}/libs64",
68 | file("src/main/cpp").absolutePath,
69 | file("src/main/cpp/Application64.mk").absolutePath,
70 | "${sqlcipherCFlags}", "${otherSqlcipherCFlags}",
71 | "${minimumAndroid64BitSdkVersion}")
72 | exec {
73 | workingDir "${nativeRootOutputDir}"
74 | commandLine "mkdir", "-p", "libs"
75 | }
76 | copy {
77 | from fileTree("${nativeRootOutputDir}/libs32").include("*/*")
78 | into "${nativeRootOutputDir}/libs"
79 | from fileTree("${nativeRootOutputDir}/libs64").include("*/*")
80 | into "${nativeRootOutputDir}/libs"
81 | }
82 | }
83 | }
84 |
85 | task cleanOpenSSL() {
86 | description "Clean the OpenSSL native libraries"
87 | doLast {
88 | logger.info "Cleaning OpenSSL native libraries"
89 | exec {
90 | workingDir "${androidNativeRootDir}"
91 | ignoreExitValue true
92 | commandLine "rm", "-rf"
93 | }
94 | }
95 | }
96 |
97 | task cleanSQLCipher() {
98 | description "Clean the SQLCipher source"
99 | doLast {
100 | exec {
101 | workingDir "${sqlcipherDir}"
102 | ignoreExitValue true
103 | commandLine "make", "clean"
104 | }
105 | File amalgamationDestinationSource = new File("${nativeRootOutputDir}/cpp/sqlite3.c")
106 | File amalgamationDestinationHeader = new File("${nativeRootOutputDir}/cpp/sqlite3.h")
107 | if (amalgamationDestinationSource.exists()) amalgamationDestinationSource.delete()
108 | if (amalgamationDestinationHeader.exists()) amalgamationDestinationHeader.delete()
109 | }
110 | }
111 |
112 | task cleanNative() {
113 | description "Clean the native (JNI) build artifacts"
114 | doLast {
115 | logger.info "Cleaning native build artifacts"
116 | ["libs", "libs32", "libs64", "obj"].each {
117 | File file = new File("${projectDir}/src/main/${it}")
118 | if (file.exists()) {
119 | file.deleteDir()
120 | }
121 | }
122 | }
123 | }
124 |
125 | task distclean() {
126 | description "Clean build, SQLCipher, and OpenSSL artifacts"
127 | dependsOn clean, cleanSQLCipher, cleanOpenSSL
128 | doLast {
129 | new File("${androidNativeRootDir}/").deleteDir()
130 | }
131 | }
132 |
133 | def gitClean(directory) {
134 | logger.info "Cleaning directory:${directory}"
135 | exec {
136 | workingDir "${directory}"
137 | commandLine "git", "checkout", "-f"
138 | }
139 | exec {
140 | workingDir "${directory}"
141 | commandLine "git", "clean", "-d", "-f"
142 | }
143 | }
144 |
145 | def executeNdkBuild(outputDir, androidMkDirectory, applicationMkFile,
146 | cflags, otherSqlcipherCFlags, androidVersion) {
147 | logger.info "Executing NDK build command"
148 | def out = services.get(StyledTextOutputFactory).create("")
149 | out.style(Style.Normal).text("SQLCIPHER_CFLAGS=").style(Style.Info).println("${cflags}")
150 | out.style(Style.Normal).text("OPENSSL_DIR=").style(Style.Info).println("${opensslDir}")
151 | out.style(Style.Normal).text("SQLCIPHER_DIR=").style(Style.Info).println("${sqlcipherDir}")
152 | out.style(Style.Normal).text("SQLCIPHER_OTHER_CFLAGS=").style(Style.Info).println("${otherSqlcipherCFlags}")
153 | out.style(Style.Normal).text("ANDROID_NATIVE_ROOT_DIR=").style(Style.Info).println("${androidNativeRootDir}")
154 | out.style(Style.Normal).text("NDK_APP_PLATFORM=").style(Style.Info).println("${androidVersion}")
155 |
156 | exec {
157 | def outputDirectory = "NDK_LIBS_OUT=${outputDir}"
158 | def applicationFile = "NDK_APPLICATION_MK=${applicationMkFile}"
159 | def environmentVariables = ["SQLCIPHER_CFLAGS" : "${cflags}",
160 | "OPENSSL_DIR" : "${opensslDir}",
161 | "SQLCIPHER_DIR" : "${sqlcipherDir}",
162 | "SQLCIPHER_OTHER_CFLAGS" : "${otherSqlcipherCFlags}",
163 | "ANDROID_NATIVE_ROOT_DIR": "${androidNativeRootDir}",
164 | "NDK_APP_PLATFORM" : "${androidVersion}"]
165 | environment(environmentVariables)
166 | commandLine "ndk-build", "V=1", "${ndkBuildType}",
167 | "--environment-overrides", outputDirectory,
168 | "-C", androidMkDirectory, applicationFile
169 | }
170 | }
171 |
--------------------------------------------------------------------------------
/android-database-sqlcipher/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 |
2 | 48 | * Returned column types are 49 | *
32 | * If null is specified for DatabaeErrorHandler param in the above calls, then this class is used 33 | * as the default {@link DatabaseErrorHandler}. 34 | */ 35 | public final class DefaultDatabaseErrorHandler implements DatabaseErrorHandler { 36 | 37 | private final String TAG = getClass().getSimpleName(); 38 | 39 | /** 40 | * defines the default method to be invoked when database corruption is detected. 41 | * @param dbObj the {@link SQLiteDatabase} object representing the database on which corruption 42 | * is detected. 43 | */ 44 | public void onCorruption(SQLiteDatabase dbObj) { 45 | // NOTE: Unlike the AOSP, this version does NOT attempt to delete any attached databases. 46 | // TBD: Are we really certain that the attached databases would really be corrupt? 47 | Log.e(TAG, "Corruption reported by sqlite on database, deleting: " + dbObj.getPath()); 48 | 49 | if (dbObj.isOpen()) { 50 | Log.e(TAG, "Database object for corrupted database is already open, closing"); 51 | 52 | try { 53 | dbObj.close(); 54 | } catch (Exception e) { 55 | /* ignored */ 56 | Log.e(TAG, "Exception closing Database object for corrupted database, ignored", e); 57 | } 58 | } 59 | 60 | deleteDatabaseFile(dbObj.getPath()); 61 | } 62 | 63 | private void deleteDatabaseFile(String fileName) { 64 | if (fileName.equalsIgnoreCase(":memory:") || fileName.trim().length() == 0) { 65 | return; 66 | } 67 | Log.e(TAG, "deleting the database file: " + fileName); 68 | try { 69 | new File(fileName).delete(); 70 | } catch (Exception e) { 71 | /* print warning and ignore exception */ 72 | Log.w(TAG, "delete failed: " + e.getMessage()); 73 | } 74 | } 75 | } 76 | -------------------------------------------------------------------------------- /android-database-sqlcipher/src/main/java/net/sqlcipher/IBulkCursor.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2006 The Android Open Source Project 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | 17 | package net.sqlcipher; 18 | 19 | import android.os.RemoteException; 20 | import android.os.IBinder; 21 | import android.os.IInterface; 22 | import android.os.Bundle; 23 | 24 | import java.util.Map; 25 | 26 | /** 27 | * This interface provides a low-level way to pass bulk cursor data across 28 | * both process and language boundries. Application code should use the Cursor 29 | * interface directly. 30 | * 31 | * {@hide} 32 | */ 33 | public interface IBulkCursor extends IInterface { 34 | /** 35 | * Returns a BulkCursorWindow, which either has a reference to a shared 36 | * memory segment with the rows, or an array of JSON strings. 37 | */ 38 | public CursorWindow getWindow(int startPos) throws RemoteException; 39 | 40 | public void onMove(int position) throws RemoteException; 41 | 42 | /** 43 | * Returns the number of rows in the cursor. 44 | * 45 | * @return the number of rows in the cursor. 46 | */ 47 | public int count() throws RemoteException; 48 | 49 | /** 50 | * Returns a string array holding the names of all of the columns in the 51 | * cursor in the order in which they were listed in the result. 52 | * 53 | * @return the names of the columns returned in this query. 54 | */ 55 | public String[] getColumnNames() throws RemoteException; 56 | 57 | public boolean updateRows(Map> values) throws RemoteException; 58 | 59 | public boolean deleteRow(int position) throws RemoteException; 60 | 61 | public void deactivate() throws RemoteException; 62 | 63 | public void close() throws RemoteException; 64 | 65 | public int requery(IContentObserver observer, CursorWindow window) throws RemoteException; 66 | 67 | boolean getWantsAllOnMoveCalls() throws RemoteException; 68 | 69 | Bundle getExtras() throws RemoteException; 70 | 71 | Bundle respond(Bundle extras) throws RemoteException; 72 | 73 | /* IPC constants */ 74 | static final String descriptor = "android.content.IBulkCursor"; 75 | 76 | static final int GET_CURSOR_WINDOW_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION; 77 | static final int COUNT_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 1; 78 | static final int GET_COLUMN_NAMES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 2; 79 | static final int UPDATE_ROWS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 3; 80 | static final int DELETE_ROW_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 4; 81 | static final int DEACTIVATE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 5; 82 | static final int REQUERY_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 6; 83 | static final int ON_MOVE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 7; 84 | static final int WANTS_ON_MOVE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 8; 85 | static final int GET_EXTRAS_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 9; 86 | static final int RESPOND_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 10; 87 | static final int CLOSE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION + 11; 88 | } 89 | -------------------------------------------------------------------------------- /android-database-sqlcipher/src/main/java/net/sqlcipher/InvalidRowColumnException.java: -------------------------------------------------------------------------------- 1 | package net.sqlcipher; 2 | 3 | /** 4 | * An exception that indicates there was an error accessing a specific row/column. 5 | */ 6 | public class InvalidRowColumnException extends RuntimeException 7 | { 8 | public InvalidRowColumnException() {} 9 | 10 | public InvalidRowColumnException(String error) 11 | { 12 | super(error); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /android-database-sqlcipher/src/main/java/net/sqlcipher/MatrixCursor.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2007 The Android Open Source Project 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | 17 | package net.sqlcipher; 18 | 19 | import java.util.ArrayList; 20 | 21 | import android.database.CharArrayBuffer; 22 | 23 | 24 | /** 25 | * A mutable cursor implementation backed by an array of {@code Object}s. Use 26 | * {@link #newRow()} to add rows. Automatically expands internal capacity 27 | * as needed. 28 | */ 29 | public class MatrixCursor extends AbstractCursor { 30 | 31 | private final String[] columnNames; 32 | private Object[] data; 33 | private int rowCount = 0; 34 | private final int columnCount; 35 | 36 | /** 37 | * Constructs a new cursor with the given initial capacity. 38 | * 39 | * @param columnNames names of the columns, the ordering of which 40 | * determines column ordering elsewhere in this cursor 41 | * @param initialCapacity in rows 42 | */ 43 | public MatrixCursor(String[] columnNames, int initialCapacity) { 44 | this.columnNames = columnNames; 45 | this.columnCount = columnNames.length; 46 | 47 | if (initialCapacity < 1) { 48 | initialCapacity = 1; 49 | } 50 | 51 | this.data = new Object[columnCount * initialCapacity]; 52 | } 53 | 54 | /** 55 | * Constructs a new cursor. 56 | * 57 | * @param columnNames names of the columns, the ordering of which 58 | * determines column ordering elsewhere in this cursor 59 | */ 60 | public MatrixCursor(String[] columnNames) { 61 | this(columnNames, 16); 62 | } 63 | 64 | /** 65 | * Gets value at the given column for the current row. 66 | */ 67 | private Object get(int column) { 68 | if (column < 0 || column >= columnCount) { 69 | throw new CursorIndexOutOfBoundsException("Requested column: " 70 | + column + ", # of columns: " + columnCount); 71 | } 72 | if (mPos < 0) { 73 | throw new CursorIndexOutOfBoundsException("Before first row."); 74 | } 75 | if (mPos >= rowCount) { 76 | throw new CursorIndexOutOfBoundsException("After last row."); 77 | } 78 | return data[mPos * columnCount + column]; 79 | } 80 | 81 | /** 82 | * Adds a new row to the end and returns a builder for that row. Not safe 83 | * for concurrent use. 84 | * 85 | * @return builder which can be used to set the column values for the new 86 | * row 87 | */ 88 | public RowBuilder newRow() { 89 | rowCount++; 90 | int endIndex = rowCount * columnCount; 91 | ensureCapacity(endIndex); 92 | int start = endIndex - columnCount; 93 | return new RowBuilder(start, endIndex); 94 | } 95 | 96 | /** 97 | * Adds a new row to the end with the given column values. Not safe 98 | * for concurrent use. 99 | * 100 | * @throws IllegalArgumentException if {@code columnValues.length != 101 | * columnNames.length} 102 | * @param columnValues in the same order as the the column names specified 103 | * at cursor construction time 104 | */ 105 | public void addRow(Object[] columnValues) { 106 | if (columnValues.length != columnCount) { 107 | throw new IllegalArgumentException("columnNames.length = " 108 | + columnCount + ", columnValues.length = " 109 | + columnValues.length); 110 | } 111 | 112 | int start = rowCount++ * columnCount; 113 | ensureCapacity(start + columnCount); 114 | System.arraycopy(columnValues, 0, data, start, columnCount); 115 | } 116 | 117 | /** 118 | * Adds a new row to the end with the given column values. Not safe 119 | * for concurrent use. 120 | * 121 | * @throws IllegalArgumentException if {@code columnValues.size() != 122 | * columnNames.length} 123 | * @param columnValues in the same order as the the column names specified 124 | * at cursor construction time 125 | */ 126 | public void addRow(Iterable columnValues) { 127 | int start = rowCount * columnCount; 128 | int end = start + columnCount; 129 | ensureCapacity(end); 130 | 131 | if (columnValues instanceof ArrayList) { 132 | addRow((ArrayList) columnValues, start); 133 | return; 134 | } 135 | 136 | int current = start; 137 | Object[] localData = data; 138 | for (Object columnValue : columnValues) { 139 | if (current == end) { 140 | // TODO: null out row? 141 | throw new IllegalArgumentException( 142 | "columnValues.size() > columnNames.length"); 143 | } 144 | localData[current++] = columnValue; 145 | } 146 | 147 | if (current != end) { 148 | // TODO: null out row? 149 | throw new IllegalArgumentException( 150 | "columnValues.size() < columnNames.length"); 151 | } 152 | 153 | // Increase row count here in case we encounter an exception. 154 | rowCount++; 155 | } 156 | 157 | /** Optimization for {@link ArrayList}. */ 158 | private void addRow(ArrayList columnValues, int start) { 159 | int size = columnValues.size(); 160 | if (size != columnCount) { 161 | throw new IllegalArgumentException("columnNames.length = " 162 | + columnCount + ", columnValues.size() = " + size); 163 | } 164 | 165 | rowCount++; 166 | Object[] localData = data; 167 | for (int i = 0; i < size; i++) { 168 | localData[start + i] = columnValues.get(i); 169 | } 170 | } 171 | 172 | /** Ensures that this cursor has enough capacity. */ 173 | private void ensureCapacity(int size) { 174 | if (size > data.length) { 175 | Object[] oldData = this.data; 176 | int newSize = data.length * 2; 177 | if (newSize < size) { 178 | newSize = size; 179 | } 180 | this.data = new Object[newSize]; 181 | System.arraycopy(oldData, 0, this.data, 0, oldData.length); 182 | } 183 | } 184 | 185 | /** 186 | * Builds a row, starting from the left-most column and adding one column 187 | * value at a time. Follows the same ordering as the column names specified 188 | * at cursor construction time. 189 | */ 190 | public class RowBuilder { 191 | 192 | private int index; 193 | private final int endIndex; 194 | 195 | RowBuilder(int index, int endIndex) { 196 | this.index = index; 197 | this.endIndex = endIndex; 198 | } 199 | 200 | /** 201 | * Sets the next column value in this row. 202 | * 203 | * @throws CursorIndexOutOfBoundsException if you try to add too many 204 | * values 205 | * @return this builder to support chaining 206 | */ 207 | public RowBuilder add(Object columnValue) { 208 | if (index == endIndex) { 209 | throw new CursorIndexOutOfBoundsException( 210 | "No more columns left."); 211 | } 212 | 213 | data[index++] = columnValue; 214 | return this; 215 | } 216 | } 217 | 218 | // AbstractCursor implementation. 219 | 220 | @Override 221 | public int getCount() { 222 | return rowCount; 223 | } 224 | 225 | @Override 226 | public String[] getColumnNames() { 227 | return columnNames; 228 | } 229 | 230 | @Override 231 | public String getString(int column) { 232 | Object value = get(column); 233 | if (value == null) return null; 234 | return value.toString(); 235 | } 236 | 237 | @Override 238 | public short getShort(int column) { 239 | Object value = get(column); 240 | if (value == null) return 0; 241 | if (value instanceof Number) return ((Number) value).shortValue(); 242 | return Short.parseShort(value.toString()); 243 | } 244 | 245 | @Override 246 | public int getInt(int column) { 247 | Object value = get(column); 248 | if (value == null) return 0; 249 | if (value instanceof Number) return ((Number) value).intValue(); 250 | return Integer.parseInt(value.toString()); 251 | } 252 | 253 | @Override 254 | public long getLong(int column) { 255 | Object value = get(column); 256 | if (value == null) return 0; 257 | if (value instanceof Number) return ((Number) value).longValue(); 258 | return Long.parseLong(value.toString()); 259 | } 260 | 261 | @Override 262 | public float getFloat(int column) { 263 | Object value = get(column); 264 | if (value == null) return 0.0f; 265 | if (value instanceof Number) return ((Number) value).floatValue(); 266 | return Float.parseFloat(value.toString()); 267 | } 268 | 269 | @Override 270 | public double getDouble(int column) { 271 | Object value = get(column); 272 | if (value == null) return 0.0d; 273 | if (value instanceof Number) return ((Number) value).doubleValue(); 274 | return Double.parseDouble(value.toString()); 275 | } 276 | 277 | @Override 278 | public int getType(int column) { 279 | return DatabaseUtils.getTypeOfObject(get(column)); 280 | } 281 | 282 | @Override 283 | public boolean isNull(int column) { 284 | return get(column) == null; 285 | } 286 | 287 | 288 | } 289 | -------------------------------------------------------------------------------- /android-database-sqlcipher/src/main/java/net/sqlcipher/RowAllocationException.java: -------------------------------------------------------------------------------- 1 | package net.sqlcipher; 2 | 3 | /** 4 | * An exception that indicates there was an error attempting to allocate a row 5 | * for the CursorWindow. 6 | */ 7 | public class RowAllocationException extends RuntimeException 8 | { 9 | public RowAllocationException() {} 10 | 11 | public RowAllocationException(String error) 12 | { 13 | super(error); 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /android-database-sqlcipher/src/main/java/net/sqlcipher/StaleDataException.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2006 The Android Open Source Project 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | 17 | package net.sqlcipher; 18 | 19 | /** 20 | * This exception is thrown when a Cursor contains stale data and must be 21 | * requeried before being used again. 22 | */ 23 | public class StaleDataException extends java.lang.RuntimeException 24 | { 25 | public StaleDataException() 26 | { 27 | super(); 28 | } 29 | 30 | public StaleDataException(String description) 31 | { 32 | super(description); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /android-database-sqlcipher/src/main/java/net/sqlcipher/UnknownTypeException.java: -------------------------------------------------------------------------------- 1 | package net.sqlcipher; 2 | 3 | /** 4 | * An exception that indicates an unknown type was returned. 5 | */ 6 | public class UnknownTypeException extends RuntimeException 7 | { 8 | public UnknownTypeException() {} 9 | 10 | public UnknownTypeException(String error) 11 | { 12 | super(error); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /android-database-sqlcipher/src/main/java/net/sqlcipher/database/DatabaseObjectNotClosedException.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2006 The Android Open Source Project 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | 17 | package net.sqlcipher.database; 18 | 19 | /** 20 | * An exception that indicates that garbage-collector is finalizing a database object 21 | * that is not explicitly closed 22 | * @hide 23 | */ 24 | public class DatabaseObjectNotClosedException extends RuntimeException 25 | { 26 | private static final String s = "Application did not close the cursor or database object " + 27 | "that was opened here"; 28 | 29 | public DatabaseObjectNotClosedException() 30 | { 31 | super(s); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /android-database-sqlcipher/src/main/java/net/sqlcipher/database/SQLiteClosable.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2007 The Android Open Source Project 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | 17 | package net.sqlcipher.database; 18 | 19 | import net.sqlcipher.*; 20 | 21 | /** 22 | * An object created from a SQLiteDatabase that can be closed. 23 | */ 24 | public abstract class SQLiteClosable { 25 | private int mReferenceCount = 1; 26 | private Object mLock = new Object(); 27 | 28 | protected abstract void onAllReferencesReleased(); 29 | protected void onAllReferencesReleasedFromContainer() {} 30 | 31 | public void acquireReference() { 32 | synchronized(mLock) { 33 | if (mReferenceCount <= 0) { 34 | throw new IllegalStateException( 35 | "attempt to re-open an already-closed object: " + getObjInfo()); 36 | } 37 | mReferenceCount++; 38 | } 39 | } 40 | 41 | public void releaseReference() { 42 | synchronized(mLock) { 43 | mReferenceCount--; 44 | if (mReferenceCount == 0) { 45 | onAllReferencesReleased(); 46 | } 47 | } 48 | } 49 | 50 | public void releaseReferenceFromContainer() { 51 | synchronized(mLock) { 52 | mReferenceCount--; 53 | if (mReferenceCount == 0) { 54 | onAllReferencesReleasedFromContainer(); 55 | } 56 | } 57 | } 58 | 59 | private String getObjInfo() { 60 | StringBuilder buff = new StringBuilder(); 61 | buff.append(this.getClass().getName()); 62 | buff.append(" ("); 63 | if (this instanceof SQLiteDatabase) { 64 | buff.append("database = "); 65 | buff.append(((SQLiteDatabase)this).getPath()); 66 | } else if (this instanceof SQLiteProgram || this instanceof SQLiteStatement || 67 | this instanceof SQLiteQuery) { 68 | buff.append("mSql = "); 69 | buff.append(((SQLiteProgram)this).mSql); 70 | } 71 | /*else if (this instanceof CursorWindow) { 72 | buff.append("mStartPos = "); 73 | buff.append(((CursorWindow)this).getStartPosition()); 74 | }*/ 75 | buff.append(") "); 76 | return buff.toString(); 77 | } 78 | } 79 | -------------------------------------------------------------------------------- /android-database-sqlcipher/src/main/java/net/sqlcipher/database/SQLiteCompiledSql.java: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (C) 2009 The Android Open Source Project 3 | * 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * 8 | * http://www.apache.org/licenses/LICENSE-2.0 9 | * 10 | * Unless required by applicable law or agreed to in writing, software 11 | * distributed under the License is distributed on an "AS IS" BASIS, 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | * See the License for the specific language governing permissions and 14 | * limitations under the License. 15 | */ 16 | 17 | package net.sqlcipher.database; 18 | 19 | import android.util.Log; 20 | 21 | /** 22 | * This class encapsulates compilation of sql statement and release of the compiled statement obj. 23 | * Once a sql statement is compiled, it is cached in {@link SQLiteDatabase} 24 | * and it is released in one of the 2 following ways 25 | * 1. when {@link SQLiteDatabase} object is closed. 26 | * 2. if this is not cached in {@link SQLiteDatabase}, {@link android.database.Cursor#close()} 27 | * releaases this obj. 28 | */ 29 | /* package */ class SQLiteCompiledSql { 30 | 31 | private static final String TAG = "SQLiteCompiledSql"; 32 | 33 | /** The database this program is compiled against. */ 34 | /* package */ SQLiteDatabase mDatabase; 35 | 36 | /** 37 | * Native linkage, do not modify. This comes from the database. 38 | */ 39 | /* package */ long nHandle = 0; 40 | 41 | /** 42 | * Native linkage, do not modify. When non-0 this holds a reference to a valid 43 | * sqlite3_statement object. It is only updated by the native code, but may be 44 | * checked in this class when the database lock is held to determine if there 45 | * is a valid native-side program or not. 46 | */ 47 | /* package */ long nStatement = 0; 48 | 49 | /** the following are for debugging purposes */ 50 | private String mSqlStmt = null; 51 | 52 | /** when in cache and is in use, this member is set */ 53 | private boolean mInUse = false; 54 | 55 | /* package */ SQLiteCompiledSql(SQLiteDatabase db, String sql) { 56 | if (!db.isOpen()) { 57 | throw new IllegalStateException("database " + db.getPath() + " already closed"); 58 | } 59 | mDatabase = db; 60 | mSqlStmt = sql; 61 | this.nHandle = db.mNativeHandle; 62 | compile(sql, true); 63 | } 64 | 65 | /** 66 | * Compiles the given SQL into a SQLite byte code program using sqlite3_prepare_v2(). If 67 | * this method has been called previously without a call to close and forCompilation is set 68 | * to false the previous compilation will be used. Setting forceCompilation to true will 69 | * always re-compile the program and should be done if you pass differing SQL strings to this 70 | * method. 71 | * 72 | *
Note: this method acquires the database lock.
73 | * 74 | * @param sql the SQL string to compile 75 | * @param forceCompilation forces the SQL to be recompiled in the event that there is an 76 | * existing compiled SQL program already around 77 | */ 78 | private void compile(String sql, boolean forceCompilation) { 79 | if (!mDatabase.isOpen()) { 80 | throw new IllegalStateException("database " + mDatabase.getPath() + " already closed"); 81 | } 82 | // Only compile if we don't have a valid statement already or the caller has 83 | // explicitly requested a recompile. 84 | if (forceCompilation) { 85 | mDatabase.lock(); 86 | try { 87 | // Note that the native_compile() takes care of destroying any previously 88 | // existing programs before it compiles. 89 | native_compile(sql); 90 | } finally { 91 | mDatabase.unlock(); 92 | } 93 | } 94 | } 95 | 96 | /* package */ synchronized void releaseSqlStatement() { 97 | // Note that native_finalize() checks to make sure that nStatement is 98 | // non-null before destroying it. 99 | if (nStatement != 0) { 100 | if (SQLiteDebug.DEBUG_ACTIVE_CURSOR_FINALIZATION) { 101 | Log.v(TAG, "closed and deallocated DbObj (id#" + nStatement +")"); 102 | } 103 | native_finalize(); 104 | nStatement = 0; 105 | } 106 | } 107 | 108 | /** 109 | * returns true if acquire() succeeds. false otherwise. 110 | */ 111 | /* package */ synchronized boolean acquire() { 112 | if (mInUse) { 113 | // someone already has acquired it. 114 | return false; 115 | } 116 | mInUse = true; 117 | if (SQLiteDebug.DEBUG_ACTIVE_CURSOR_FINALIZATION) { 118 | Log.v(TAG, "Acquired DbObj (id#" + nStatement + ") from DB cache"); 119 | } 120 | return true; 121 | } 122 | 123 | /* package */ synchronized void release() { 124 | if (SQLiteDebug.DEBUG_ACTIVE_CURSOR_FINALIZATION) { 125 | Log.v(TAG, "Released DbObj (id#" + nStatement + ") back to DB cache"); 126 | } 127 | mInUse = false; 128 | } 129 | 130 | /** 131 | * Make sure that the native resource is cleaned up. 132 | */ 133 | @Override 134 | protected void finalize() throws Throwable { 135 | try { 136 | if (nStatement == 0) return; 137 | // finalizer should NEVER get called 138 | if (SQLiteDebug.DEBUG_ACTIVE_CURSOR_FINALIZATION) { 139 | Log.v(TAG, "** warning ** Finalized DbObj (id#" + nStatement + ")"); 140 | } 141 | releaseSqlStatement(); 142 | } finally { 143 | super.finalize(); 144 | } 145 | } 146 | 147 | /** 148 | * Compiles SQL into a SQLite program. 149 | * 150 | *The database lock must be held when calling this method.
151 | * @param sql The SQL to compile.
152 | */
153 | private final native void native_compile(String sql);
154 | private final native void native_finalize();
155 | }
156 |
--------------------------------------------------------------------------------
/android-database-sqlcipher/src/main/java/net/sqlcipher/database/SQLiteContentHelper.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2009 The Android Open Source Project
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package net.sqlcipher.database;
18 | import net.sqlcipher.*;
19 |
20 | import android.content.res.AssetFileDescriptor;
21 | import android.os.MemoryFile;
22 |
23 | import android.database.Cursor;
24 |
25 | import java.io.FileNotFoundException;
26 | import java.io.IOException;
27 |
28 | /**
29 | * Some helper functions for using SQLite database to implement content providers.
30 | *
31 | * @hide
32 | */
33 | public class SQLiteContentHelper {
34 |
35 | /**
36 | * Runs an SQLite query and returns an AssetFileDescriptor for the
37 | * blob in column 0 of the first row. If the first column does
38 | * not contain a blob, an unspecified exception is thrown.
39 | *
40 | * @param db Handle to a readable database.
41 | * @param sql SQL query, possibly with query arguments.
42 | * @param selectionArgs Query argument values, or {@code null} for no argument.
43 | * @return If no exception is thrown, a non-null AssetFileDescriptor is returned.
44 | * @throws FileNotFoundException If the query returns no results or the
45 | * value of column 0 is NULL, or if there is an error creating the
46 | * asset file descriptor.
47 | */
48 | public static AssetFileDescriptor getBlobColumnAsAssetFile(SQLiteDatabase db, String sql,
49 | String[] selectionArgs) throws FileNotFoundException {
50 | android.os.ParcelFileDescriptor fd = null;
51 |
52 | try {
53 | MemoryFile file = simpleQueryForBlobMemoryFile(db, sql, selectionArgs);
54 | if (file == null) {
55 | throw new FileNotFoundException("No results.");
56 | }
57 | Class c = file.getClass();
58 | try {
59 | java.lang.reflect.Method m = c.getDeclaredMethod("getParcelFileDescriptor");
60 | m.setAccessible(true);
61 | fd = (android.os.ParcelFileDescriptor)m.invoke(file);
62 | } catch (Exception e) {
63 | android.util.Log.i("SQLiteContentHelper", "SQLiteCursor.java: " + e);
64 | }
65 | AssetFileDescriptor afd = new AssetFileDescriptor(fd, 0, file.length());
66 | return afd;
67 | } catch (IOException ex) {
68 | throw new FileNotFoundException(ex.toString());
69 | }
70 | }
71 |
72 | /**
73 | * Runs an SQLite query and returns a MemoryFile for the
74 | * blob in column 0 of the first row. If the first column does
75 | * not contain a blob, an unspecified exception is thrown.
76 | *
77 | * @return A memory file, or {@code null} if the query returns no results
78 | * or the value column 0 is NULL.
79 | * @throws IOException If there is an error creating the memory file.
80 | */
81 | // TODO: make this native and use the SQLite blob API to reduce copying
82 | private static MemoryFile simpleQueryForBlobMemoryFile(SQLiteDatabase db, String sql,
83 | String[] selectionArgs) throws IOException {
84 | Cursor cursor = db.rawQuery(sql, selectionArgs);
85 | if (cursor == null) {
86 | return null;
87 | }
88 | try {
89 | if (!cursor.moveToFirst()) {
90 | return null;
91 | }
92 | byte[] bytes = cursor.getBlob(0);
93 | if (bytes == null) {
94 | return null;
95 | }
96 | MemoryFile file = new MemoryFile(null, bytes.length);
97 | file.writeBytes(bytes, 0, 0, bytes.length);
98 |
99 | // file.deactivate();
100 | return file;
101 | } finally {
102 | cursor.close();
103 | }
104 | }
105 |
106 | }
107 |
--------------------------------------------------------------------------------
/android-database-sqlcipher/src/main/java/net/sqlcipher/database/SQLiteCursorDriver.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2007 The Android Open Source Project
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package net.sqlcipher.database;
18 |
19 | import net.sqlcipher.database.SQLiteDatabase.CursorFactory;
20 | import net.sqlcipher.*;
21 |
22 | /**
23 | * A driver for SQLiteCursors that is used to create them and gets notified
24 | * by the cursors it creates on significant events in their lifetimes.
25 | */
26 | public interface SQLiteCursorDriver {
27 | /**
28 | * Executes the query returning a Cursor over the result set.
29 | *
30 | * @param factory The CursorFactory to use when creating the Cursors, or
31 | * null if standard SQLiteCursors should be returned.
32 | * @return a Cursor over the result set
33 | */
34 | Cursor query(CursorFactory factory, String[] bindArgs);
35 |
36 | /**
37 | * Called by a SQLiteCursor when it is released.
38 | */
39 | void cursorDeactivated();
40 |
41 | /**
42 | * Called by a SQLiteCursor when it is requeryed.
43 | *
44 | * @return The new count value.
45 | */
46 | void cursorRequeried(android.database.Cursor cursor);
47 |
48 | /**
49 | * Called by a SQLiteCursor when it it closed to destroy this object as well.
50 | */
51 | void cursorClosed();
52 |
53 | /**
54 | * Set new bind arguments. These will take effect in cursorRequeried().
55 | * @param bindArgs the new arguments
56 | */
57 | public void setBindArguments(String[] bindArgs);
58 | }
59 |
--------------------------------------------------------------------------------
/android-database-sqlcipher/src/main/java/net/sqlcipher/database/SQLiteDatabaseHook.java:
--------------------------------------------------------------------------------
1 | package net.sqlcipher.database;
2 |
3 | /**
4 | * An interface to perform pre and post key operations against a database.
5 | */
6 | public interface SQLiteDatabaseHook {
7 | /**
8 | * Called immediately before opening the database.
9 | */
10 | void preKey(SQLiteDatabase database);
11 | /**
12 | * Called immediately after opening the database.
13 | */
14 | void postKey(SQLiteDatabase database);
15 | }
16 |
--------------------------------------------------------------------------------
/android-database-sqlcipher/src/main/java/net/sqlcipher/database/SQLiteDebug.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2007 The Android Open Source Project
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package net.sqlcipher.database;
18 |
19 | import java.util.ArrayList;
20 |
21 | import android.util.Log;
22 |
23 | /**
24 | * Provides debugging info about all SQLite databases running in the current process.
25 | *
26 | * {@hide}
27 | */
28 | public final class SQLiteDebug {
29 | /**
30 | * Controls the printing of SQL statements as they are executed.
31 | */
32 | public static final boolean DEBUG_SQL_STATEMENTS =
33 | Log.isLoggable("SQLiteStatements", Log.VERBOSE);
34 |
35 | /**
36 | * Controls the printing of wall-clock time taken to execute SQL statements
37 | * as they are executed.
38 | */
39 | public static final boolean DEBUG_SQL_TIME =
40 | Log.isLoggable("SQLiteTime", Log.VERBOSE);
41 |
42 | /**
43 | * Controls the printing of compiled-sql-statement cache stats.
44 | */
45 | public static final boolean DEBUG_SQL_CACHE =
46 | Log.isLoggable("SQLiteCompiledSql", Log.VERBOSE);
47 |
48 | /**
49 | * Controls the stack trace reporting of active cursors being
50 | * finalized.
51 | */
52 | public static final boolean DEBUG_ACTIVE_CURSOR_FINALIZATION =
53 | Log.isLoggable("SQLiteCursorClosing", Log.VERBOSE);
54 |
55 | /**
56 | * Controls the tracking of time spent holding the database lock.
57 | */
58 | public static final boolean DEBUG_LOCK_TIME_TRACKING =
59 | Log.isLoggable("SQLiteLockTime", Log.VERBOSE);
60 |
61 | /**
62 | * Controls the printing of stack traces when tracking the time spent holding the database lock.
63 | */
64 | public static final boolean DEBUG_LOCK_TIME_TRACKING_STACK_TRACE =
65 | Log.isLoggable("SQLiteLockStackTrace", Log.VERBOSE);
66 |
67 | /**
68 | * Contains statistics about the active pagers in the current process.
69 | *
70 | * @see #getPagerStats(PagerStats)
71 | */
72 | public static class PagerStats {
73 | /** The total number of bytes in all pagers in the current process
74 | * @deprecated not used any longer
75 | */
76 | @Deprecated
77 | public long totalBytes;
78 | /** The number of bytes in referenced pages in all pagers in the current process
79 | * @deprecated not used any longer
80 | * */
81 | @Deprecated
82 | public long referencedBytes;
83 | /** The number of bytes in all database files opened in the current process
84 | * @deprecated not used any longer
85 | */
86 | @Deprecated
87 | public long databaseBytes;
88 | /** The number of pagers opened in the current process
89 | * @deprecated not used any longer
90 | */
91 | @Deprecated
92 | public int numPagers;
93 |
94 | /** the current amount of memory checked out by sqlite using sqlite3_malloc().
95 | * documented at http://www.sqlite.org/c3ref/c_status_malloc_size.html
96 | */
97 | public int memoryUsed;
98 |
99 | /** the number of bytes of page cache allocation which could not be sattisfied by the
100 | * SQLITE_CONFIG_PAGECACHE buffer and where forced to overflow to sqlite3_malloc().
101 | * The returned value includes allocations that overflowed because they where too large
102 | * (they were larger than the "sz" parameter to SQLITE_CONFIG_PAGECACHE) and allocations
103 | * that overflowed because no space was left in the page cache.
104 | * documented at http://www.sqlite.org/c3ref/c_status_malloc_size.html
105 | */
106 | public int pageCacheOverflo;
107 |
108 | /** records the largest memory allocation request handed to sqlite3.
109 | * documented at http://www.sqlite.org/c3ref/c_status_malloc_size.html
110 | */
111 | public int largestMemAlloc;
112 |
113 | /** a list of {@link DbStats} - one for each main database opened by the applications
114 | * running on the android device
115 | */
116 | public ArrayList The database lock must be held when calling this method.
343 | * @param sql The SQL to compile.
344 | */
345 | @Deprecated
346 | protected final native void native_compile(String sql);
347 |
348 | /**
349 | * @deprecated This method is deprecated and must not be used.
350 | */
351 | @Deprecated
352 | protected final native void native_finalize();
353 |
354 | protected final native void native_bind_null(int index);
355 | protected final native void native_bind_long(int index, long value);
356 | protected final native void native_bind_double(int index, double value);
357 | protected final native void native_bind_string(int index, String value);
358 | protected final native void native_bind_blob(int index, byte[] value);
359 | private final native void native_clear_bindings();
360 | }
361 |
362 |
--------------------------------------------------------------------------------
/android-database-sqlcipher/src/main/java/net/sqlcipher/database/SQLiteQuery.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2006 The Android Open Source Project
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package net.sqlcipher.database;
18 | import net.sqlcipher.*;
19 |
20 | import android.database.sqlite.SQLiteDatabaseCorruptException;
21 | import android.database.sqlite.SQLiteMisuseException;
22 | import android.os.SystemClock;
23 | import android.util.Log;
24 |
25 | /**
26 | * A SQLite program that represents a query that reads the resulting rows into a CursorWindow.
27 | * This class is used by SQLiteCursor and isn't useful itself.
28 | *
29 | * SQLiteQuery is not internally synchronized so code using a SQLiteQuery from multiple
30 | * threads should perform its own synchronization when using the SQLiteQuery.
31 | */
32 | public class SQLiteQuery extends SQLiteProgram {
33 | private static final String TAG = "Cursor";
34 |
35 | /** The index of the unbound OFFSET parameter */
36 | private int mOffsetIndex;
37 |
38 | /** Args to bind on requery */
39 | private String[] mBindArgs;
40 | private Object[] mObjectBindArgs;
41 |
42 | /**
43 | * Create a persistent query object.
44 | *
45 | * @param db The database that this query object is associated with
46 | * @param query The SQL string for this query.
47 | * @param offsetIndex The 1-based index to the OFFSET parameter,
48 | */
49 | /* package */ SQLiteQuery(SQLiteDatabase db, String query, int offsetIndex, String[] bindArgs) {
50 | super(db, query);
51 |
52 | mOffsetIndex = offsetIndex;
53 | mBindArgs = bindArgs;
54 | }
55 |
56 | SQLiteQuery(SQLiteDatabase db, String query, int offsetIndex, Object[] bindArgs) {
57 | super(db, query);
58 | mOffsetIndex = offsetIndex;
59 | mObjectBindArgs = bindArgs;
60 | int length = mObjectBindArgs != null ? mObjectBindArgs.length : 0;
61 | mBindArgs = new String[length];
62 | }
63 |
64 | /**
65 | * Reads rows into a buffer. This method acquires the database lock.
66 | *
67 | * @param window The window to fill into
68 | * @return number of total rows in the query
69 | */
70 | /* package */
71 | int fillWindow(CursorWindow window,
72 | int maxRead, int lastPos) {
73 | long timeStart = SystemClock.uptimeMillis();
74 | mDatabase.lock();
75 | try {
76 | acquireReference();
77 | try {
78 | window.acquireReference();
79 | // if the start pos is not equal to 0, then most likely window is
80 | // too small for the data set, loading by another thread
81 | // is not safe in this situation. the native code will ignore maxRead
82 | int numRows = native_fill_window(window,
83 | window.getStartPosition(),
84 | window.getRequiredPosition(),
85 | mOffsetIndex,
86 | maxRead, lastPos);
87 |
88 | // Logging
89 | if (SQLiteDebug.DEBUG_SQL_STATEMENTS) {
90 | Log.d(TAG, "fillWindow(): " + mSql);
91 | }
92 | return numRows;
93 | } catch (IllegalStateException e){
94 | // simply ignore it
95 | return 0;
96 | } catch (SQLiteDatabaseCorruptException e) {
97 | mDatabase.onCorruption();
98 | throw e;
99 | } finally {
100 | window.releaseReference();
101 | }
102 | } finally {
103 | releaseReference();
104 | mDatabase.unlock();
105 | }
106 | }
107 |
108 | /**
109 | * Get the column count for the statement. Only valid on query based
110 | * statements. The database must be locked
111 | * when calling this method.
112 | *
113 | * @return The number of column in the statement's result set.
114 | */
115 | /* package */ int columnCountLocked() {
116 | acquireReference();
117 | try {
118 | return native_column_count();
119 | } finally {
120 | releaseReference();
121 | }
122 | }
123 |
124 | /**
125 | * Retrieves the column name for the given column index. The database must be locked
126 | * when calling this method.
127 | *
128 | * @param columnIndex the index of the column to get the name for
129 | * @return The requested column's name
130 | */
131 | /* package */ String columnNameLocked(int columnIndex) {
132 | acquireReference();
133 | try {
134 | return native_column_name(columnIndex);
135 | } finally {
136 | releaseReference();
137 | }
138 | }
139 |
140 | @Override
141 | public String toString() {
142 | return "SQLiteQuery: " + mSql;
143 | }
144 |
145 | /**
146 | * Called by SQLiteCursor when it is requeried.
147 | */
148 | /* package */ void requery() {
149 | if (mBindArgs != null) {
150 | int len = mBindArgs.length;
151 | try {
152 | if(mObjectBindArgs != null) {
153 | bindArguments(mObjectBindArgs);
154 | } else {
155 | for (int i = 0; i < len; i++) {
156 | super.bindString(i + 1, mBindArgs[i]);
157 | }
158 | }
159 | } catch (SQLiteMisuseException e) {
160 | StringBuilder errMsg = new StringBuilder("mSql " + mSql);
161 | for (int i = 0; i < len; i++) {
162 | errMsg.append(" ");
163 | errMsg.append(mBindArgs[i]);
164 | }
165 | errMsg.append(" ");
166 | IllegalStateException leakProgram = new IllegalStateException(
167 | errMsg.toString(), e);
168 | throw leakProgram;
169 | }
170 | }
171 | }
172 |
173 | @Override
174 | public void bindNull(int index) {
175 | mBindArgs[index - 1] = null;
176 | if (!mClosed) super.bindNull(index);
177 | }
178 |
179 | @Override
180 | public void bindLong(int index, long value) {
181 | mBindArgs[index - 1] = Long.toString(value);
182 | if (!mClosed) super.bindLong(index, value);
183 | }
184 |
185 | @Override
186 | public void bindDouble(int index, double value) {
187 | mBindArgs[index - 1] = Double.toString(value);
188 | if (!mClosed) super.bindDouble(index, value);
189 | }
190 |
191 | @Override
192 | public void bindString(int index, String value) {
193 | mBindArgs[index - 1] = value;
194 | if (!mClosed) super.bindString(index, value);
195 | }
196 |
197 | public void bindArguments(Object[] args){
198 | if(args != null && args.length > 0){
199 | for(int i = 0; i < args.length; i++){
200 | Object value = args[i];
201 | if(value == null){
202 | bindNull(i + 1);
203 | } else if (value instanceof Double) {
204 | bindDouble(i + 1, (Double)value);
205 | } else if (value instanceof Float) {
206 | float number = ((Number)value).floatValue();
207 | bindDouble(i + 1, Double.valueOf(number));
208 | } else if (value instanceof Long) {
209 | bindLong(i + 1, (Long)value);
210 | } else if(value instanceof Integer) {
211 | int number = ((Number) value).intValue();
212 | bindLong(i + 1, Long.valueOf(number));
213 | } else if (value instanceof Boolean) {
214 | bindLong(i + 1, (Boolean)value ? 1 : 0);
215 | } else if (value instanceof byte[]) {
216 | bindBlob(i + 1, (byte[])value);
217 | } else {
218 | bindString(i + 1, value.toString());
219 | }
220 | }
221 | }
222 | }
223 |
224 | private final native int native_fill_window(CursorWindow window,
225 | int startPos, int requiredPos,
226 | int offsetParam, int maxRead,
227 | int lastPos);
228 |
229 | private final native int native_column_count();
230 |
231 | private final native String native_column_name(int columnIndex);
232 | }
233 |
--------------------------------------------------------------------------------
/android-database-sqlcipher/src/main/java/net/sqlcipher/database/SQLiteQueryStats.java:
--------------------------------------------------------------------------------
1 | package net.sqlcipher.database;
2 |
3 | public class SQLiteQueryStats {
4 | long totalQueryResultSize = 0L;
5 | long largestIndividualRowSize = 0L;
6 |
7 | public SQLiteQueryStats(long totalQueryResultSize,
8 | long largestIndividualRowSize) {
9 | this.totalQueryResultSize = totalQueryResultSize;
10 | this.largestIndividualRowSize = largestIndividualRowSize;
11 | }
12 |
13 | public long getTotalQueryResultSize(){
14 | return totalQueryResultSize;
15 | }
16 |
17 | public long getLargestIndividualRowSize(){
18 | return largestIndividualRowSize;
19 | }
20 | }
21 |
--------------------------------------------------------------------------------
/android-database-sqlcipher/src/main/java/net/sqlcipher/database/SQLiteStatement.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2006 The Android Open Source Project
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package net.sqlcipher.database;
18 |
19 | import android.os.SystemClock;
20 | import androidx.sqlite.db.SupportSQLiteStatement;
21 |
22 | /**
23 | * A pre-compiled statement against a {@link SQLiteDatabase} that can be reused.
24 | * The statement cannot return multiple rows, but 1x1 result sets are allowed.
25 | * Don't use SQLiteStatement constructor directly, please use
26 | * {@link SQLiteDatabase#compileStatement(String)}
27 | *
28 | * SQLiteStatement is not internally synchronized so code using a SQLiteStatement from multiple
29 | * threads should perform its own synchronization when using the SQLiteStatement.
30 | */
31 | public class SQLiteStatement extends SQLiteProgram implements
32 | SupportSQLiteStatement
33 | {
34 | /**
35 | * Don't use SQLiteStatement constructor directly, please use
36 | * {@link SQLiteDatabase#compileStatement(String)}
37 | * @param db
38 | * @param sql
39 | */
40 | /* package */ SQLiteStatement(SQLiteDatabase db, String sql) {
41 | super(db, sql);
42 | }
43 |
44 | /**
45 | * Execute this SQL statement, if it is not a query. For example,
46 | * CREATE TABLE, DELTE, INSERT, etc.
47 | *
48 | * @throws android.database.SQLException If the SQL string is invalid for
49 | * some reason
50 | */
51 | @Override
52 | public void execute() {
53 | if (!mDatabase.isOpen()) {
54 | throw new IllegalStateException("database " + mDatabase.getPath() + " already closed");
55 | }
56 | long timeStart = SystemClock.uptimeMillis();
57 | mDatabase.lock();
58 |
59 | acquireReference();
60 | try {
61 | native_execute();
62 | } finally {
63 | releaseReference();
64 | mDatabase.unlock();
65 | }
66 | }
67 |
68 | /**
69 | * Execute this SQL statement and return the ID of the row inserted due to this call.
70 | * The SQL statement should be an INSERT for this to be a useful call.
71 | *
72 | * @return the row ID of the last row inserted, if this insert is successful. -1 otherwise.
73 | *
74 | * @throws android.database.SQLException If the SQL string is invalid for
75 | * some reason
76 | */
77 | @Override
78 | public long executeInsert() {
79 | if (!mDatabase.isOpen()) {
80 | throw new IllegalStateException("database " + mDatabase.getPath() + " already closed");
81 | }
82 | long timeStart = SystemClock.uptimeMillis();
83 | mDatabase.lock();
84 |
85 | acquireReference();
86 | try {
87 | native_execute();
88 | return (mDatabase.lastChangeCount() > 0) ? mDatabase.lastInsertRow() : -1;
89 | } finally {
90 | releaseReference();
91 | mDatabase.unlock();
92 | }
93 | }
94 |
95 | @Override
96 | public int executeUpdateDelete() {
97 | if (!mDatabase.isOpen()) {
98 | throw new IllegalStateException("database " + mDatabase.getPath() + " already closed");
99 | }
100 | long timeStart = SystemClock.uptimeMillis();
101 | mDatabase.lock();
102 |
103 | acquireReference();
104 | try {
105 | native_execute();
106 | return mDatabase.lastChangeCount();
107 | } finally {
108 | releaseReference();
109 | mDatabase.unlock();
110 | }
111 | }
112 |
113 | /**
114 | * Execute a statement that returns a 1 by 1 table with a numeric value.
115 | * For example, SELECT COUNT(*) FROM table;
116 | *
117 | * @return The result of the query.
118 | *
119 | * @throws android.database.sqlite.SQLiteDoneException if the query returns zero rows
120 | */
121 | @Override
122 | public long simpleQueryForLong() {
123 | if (!mDatabase.isOpen()) {
124 | throw new IllegalStateException("database " + mDatabase.getPath() + " already closed");
125 | }
126 | long timeStart = SystemClock.uptimeMillis();
127 | mDatabase.lock();
128 |
129 | acquireReference();
130 | try {
131 | long retValue = native_1x1_long();
132 | return retValue;
133 | } finally {
134 | releaseReference();
135 | mDatabase.unlock();
136 | }
137 | }
138 |
139 | /**
140 | * Execute a statement that returns a 1 by 1 table with a text value.
141 | * For example, SELECT COUNT(*) FROM table;
142 | *
143 | * @return The result of the query.
144 | *
145 | * @throws android.database.sqlite.SQLiteDoneException if the query returns zero rows
146 | */
147 | @Override
148 | public String simpleQueryForString() {
149 | if (!mDatabase.isOpen()) {
150 | throw new IllegalStateException("database " + mDatabase.getPath() + " already closed");
151 | }
152 | long timeStart = SystemClock.uptimeMillis();
153 | mDatabase.lock();
154 |
155 | acquireReference();
156 | try {
157 | String retValue = native_1x1_string();
158 | return retValue;
159 | } finally {
160 | releaseReference();
161 | mDatabase.unlock();
162 | }
163 | }
164 |
165 | private final native void native_execute();
166 | private final native long native_1x1_long();
167 | private final native String native_1x1_string();
168 | }
169 |
--------------------------------------------------------------------------------
/android-database-sqlcipher/src/main/java/net/sqlcipher/database/SQLiteTransactionListener.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2009 The Android Open Source Project
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package net.sqlcipher.database;
18 |
19 | /**
20 | * A listener for transaction events.
21 | */
22 | public interface SQLiteTransactionListener {
23 | /**
24 | * Called immediately after the transaction begins.
25 | */
26 | void onBegin();
27 |
28 | /**
29 | * Called immediately before commiting the transaction.
30 | */
31 | void onCommit();
32 |
33 | /**
34 | * Called if the transaction is about to be rolled back.
35 | */
36 | void onRollback();
37 | }
38 |
--------------------------------------------------------------------------------
/android-database-sqlcipher/src/main/java/net/sqlcipher/database/SqliteWrapper.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2008 Esmertec AG.
3 | * Copyright (C) 2008 The Android Open Source Project
4 | *
5 | * Licensed under the Apache License, Version 2.0 (the "License");
6 | * you may not use this file except in compliance with the License.
7 | * You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an "AS IS" BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | */
17 |
18 | package net.sqlcipher.database;
19 |
20 | import android.content.ContentResolver;
21 | import android.content.ContentValues;
22 | import android.content.Context;
23 |
24 | import net.sqlcipher.*;
25 |
26 | import android.database.sqlite.SQLiteException;
27 | import android.net.Uri;
28 | import android.util.Log;
29 | import android.widget.Toast;
30 |
31 | /**
32 | * @hide
33 | */
34 |
35 | public final class SqliteWrapper {
36 | private static final String TAG = "SqliteWrapper";
37 | private static final String SQLITE_EXCEPTION_DETAIL_MESSAGE
38 | = "unable to open database file";
39 |
40 | private SqliteWrapper() {
41 | // Forbidden being instantiated.
42 | }
43 |
44 | // FIXME: need to optimize this method.
45 | private static boolean isLowMemory(SQLiteException e) {
46 | return e.getMessage().equals(SQLITE_EXCEPTION_DETAIL_MESSAGE);
47 | }
48 |
49 | public static void checkSQLiteException(Context context, SQLiteException e) {
50 | if (isLowMemory(e)) {
51 | Toast.makeText(context, e.getMessage(),
52 | Toast.LENGTH_SHORT).show();
53 | } else {
54 | throw e;
55 | }
56 | }
57 |
58 | public static Cursor query(Context context, ContentResolver resolver, Uri uri,
59 | String[] projection, String selection, String[] selectionArgs, String sortOrder) {
60 | try {
61 | return (Cursor) resolver.query(uri, projection, selection, selectionArgs, sortOrder);
62 | } catch (SQLiteException e) {
63 | Log.e(TAG, "Catch a SQLiteException when query: ", e);
64 | checkSQLiteException(context, e);
65 | return null;
66 | }
67 | }
68 |
69 | public static boolean requery(Context context, android.database.Cursor cursor) {
70 | try {
71 | return cursor.requery();
72 | } catch (SQLiteException e) {
73 | Log.e(TAG, "Catch a SQLiteException when requery: ", e);
74 | checkSQLiteException(context, e);
75 | return false;
76 | }
77 | }
78 | public static int update(Context context, ContentResolver resolver, Uri uri,
79 | ContentValues values, String where, String[] selectionArgs) {
80 | try {
81 | return resolver.update(uri, values, where, selectionArgs);
82 | } catch (SQLiteException e) {
83 | Log.e(TAG, "Catch a SQLiteException when update: ", e);
84 | checkSQLiteException(context, e);
85 | return -1;
86 | }
87 | }
88 |
89 | public static int delete(Context context, ContentResolver resolver, Uri uri,
90 | String where, String[] selectionArgs) {
91 | try {
92 | return resolver.delete(uri, where, selectionArgs);
93 | } catch (SQLiteException e) {
94 | Log.e(TAG, "Catch a SQLiteException when delete: ", e);
95 | checkSQLiteException(context, e);
96 | return -1;
97 | }
98 | }
99 |
100 | public static Uri insert(Context context, ContentResolver resolver,
101 | Uri uri, ContentValues values) {
102 | try {
103 | return resolver.insert(uri, values);
104 | } catch (SQLiteException e) {
105 | Log.e(TAG, "Catch a SQLiteException when insert: ", e);
106 | checkSQLiteException(context, e);
107 | return null;
108 | }
109 | }
110 | }
111 |
--------------------------------------------------------------------------------
/android-database-sqlcipher/src/main/java/net/sqlcipher/database/SupportFactory.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2019 Mark L. Murphy
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package net.sqlcipher.database;
18 |
19 | import androidx.sqlite.db.SupportSQLiteOpenHelper;
20 |
21 | public class SupportFactory implements SupportSQLiteOpenHelper.Factory {
22 | private final byte[] passphrase;
23 | private final SQLiteDatabaseHook hook;
24 | private final boolean clearPassphrase;
25 |
26 | public SupportFactory(byte[] passphrase) {
27 | this(passphrase, (SQLiteDatabaseHook)null);
28 | }
29 |
30 | public SupportFactory(byte[] passphrase, SQLiteDatabaseHook hook) {
31 | this(passphrase, hook, true);
32 | }
33 |
34 | public SupportFactory(byte[] passphrase, SQLiteDatabaseHook hook,
35 | boolean clearPassphrase) {
36 | this.passphrase = passphrase;
37 | this.hook = hook;
38 | this.clearPassphrase = clearPassphrase;
39 | }
40 |
41 | @Override
42 | public SupportSQLiteOpenHelper create(SupportSQLiteOpenHelper.Configuration configuration) {
43 | return new SupportHelper(configuration, passphrase, hook, clearPassphrase);
44 | }
45 | }
46 |
--------------------------------------------------------------------------------
/android-database-sqlcipher/src/main/java/net/sqlcipher/database/SupportHelper.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright (C) 2019 Mark L. Murphy
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package net.sqlcipher.database;
18 |
19 | import android.database.sqlite.SQLiteException;
20 | import androidx.sqlite.db.SupportSQLiteDatabase;
21 | import androidx.sqlite.db.SupportSQLiteOpenHelper;
22 |
23 | public class SupportHelper implements SupportSQLiteOpenHelper {
24 | private SQLiteOpenHelper standardHelper;
25 | private byte[] passphrase;
26 | private final boolean clearPassphrase;
27 |
28 | SupportHelper(final SupportSQLiteOpenHelper.Configuration configuration,
29 | byte[] passphrase, final SQLiteDatabaseHook hook,
30 | boolean clearPassphrase) {
31 | SQLiteDatabase.loadLibs(configuration.context);
32 | this.passphrase = passphrase;
33 | this.clearPassphrase = clearPassphrase;
34 |
35 | standardHelper =
36 | new SQLiteOpenHelper(configuration.context, configuration.name,
37 | null, configuration.callback.version, hook) {
38 | @Override
39 | public void onCreate(SQLiteDatabase db) {
40 | configuration.callback.onCreate(db);
41 | }
42 |
43 | @Override
44 | public void onUpgrade(SQLiteDatabase db, int oldVersion,
45 | int newVersion) {
46 | configuration.callback.onUpgrade(db, oldVersion,
47 | newVersion);
48 | }
49 |
50 | @Override
51 | public void onDowngrade(SQLiteDatabase db, int oldVersion,
52 | int newVersion) {
53 | configuration.callback.onDowngrade(db, oldVersion,
54 | newVersion);
55 | }
56 |
57 | @Override
58 | public void onOpen(SQLiteDatabase db) {
59 | configuration.callback.onOpen(db);
60 | }
61 |
62 | @Override
63 | public void onConfigure(SQLiteDatabase db) {
64 | configuration.callback.onConfigure(db);
65 | }
66 | };
67 | }
68 |
69 | @Override
70 | public String getDatabaseName() {
71 | return standardHelper.getDatabaseName();
72 | }
73 |
74 | @Override
75 | public void setWriteAheadLoggingEnabled(boolean enabled) {
76 | standardHelper.setWriteAheadLoggingEnabled(enabled);
77 | }
78 |
79 | @Override
80 | public SupportSQLiteDatabase getWritableDatabase() {
81 | SQLiteDatabase result;
82 | try {
83 | result = standardHelper.getWritableDatabase(passphrase);
84 | } catch (SQLiteException ex){
85 | if(passphrase != null){
86 | boolean isCleared = true;
87 | for(byte b : passphrase){
88 | isCleared = isCleared && (b == (byte)0);
89 | }
90 | if (isCleared) {
91 | throw new IllegalStateException("The passphrase appears to be cleared. This happens by " +
92 | "default the first time you use the factory to open a database, so we can remove the " +
93 | "cleartext passphrase from memory. If you close the database yourself, please use a " +
94 | "fresh SupportFactory to reopen it. If something else (e.g., Room) closed the " +
95 | "database, and you cannot control that, use SupportFactory boolean constructor option " +
96 | "to opt out of the automatic password clearing step. See the project README for more information.", ex);
97 | }
98 | }
99 | throw ex;
100 | }
101 | if(clearPassphrase && passphrase != null) {
102 | for (int i = 0; i < passphrase.length; i++) {
103 | passphrase[i] = (byte)0;
104 | }
105 | }
106 | return result;
107 | }
108 |
109 | @Override
110 | public SupportSQLiteDatabase getReadableDatabase() {
111 | return getWritableDatabase();
112 | }
113 |
114 | @Override
115 | public void close() {
116 | standardHelper.close();
117 | }
118 | }
119 |
--------------------------------------------------------------------------------
/android-database-sqlcipher/src/main/java/net/sqlcipher/database/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Contains the SQLCipher database managements classes that an application would use to manage its own private database.
3 | */
4 | package net.sqlcipher.database;
5 |
--------------------------------------------------------------------------------
/android-database-sqlcipher/src/main/java/net/sqlcipher/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Contains classes to explore data returned from a SQLCipher database.
3 | */
4 | package net.sqlcipher;
5 |
--------------------------------------------------------------------------------
/android-database-sqlcipher/src/main/res/values/android_database_sqlcipher_strings.xml:
--------------------------------------------------------------------------------
1 |
2 |