This chapter is from the book
This chapter is from the book
This chapter is from the book
SQLite
SQLite is a fully functional database. It has many of the features you would expect in a modern database, such as indexes and stored procedures. You can even do an explain plan for optimizing your queries to find out exactly where your SQL code is spending most of its time.
Any and all of your runtime app information—which includes all the shared preference files and databases—can be backed up by anyone with access to your phone using a USB cable. Because of an oversight at Google, no one running Android after version 4.0 even needs root access—they just need physical access to the phone. To be fair, I think this was an intentional feature, not an oversight. The feature just has significant unintended consequences.
Putting any personal health information unencrypted in a SQLite database is not HIPAA compliant because we cannot be sure that only persons that have been granted access have access to the databases. Under most circumstances encrypted information in a SQLite database is also not compliant. A quick way to check whether you have an issue is to put the phone in Airplane mode and then see whether there is any sensitive information, or what is known as Protected Health Information (PHI), being displayed by the application. This will typically tell you that the information is either not encrypted or the encryption key is somewhere on the phone, neither of which is HIPAA compliant.
Backing Up the Database Using adb
Let’s look at how to write to a SQLite application and how someone can pull the database off the phone. To begin, we need to add a SQLite database to the Android HelloWorld app. Listing 5-1 shows how to add a SQLite database to your Android app.
Listing 5-1 Adding SQLite to your code
package com.riis.sqlite3;
import java.io.File;
import android.os.Bundle;
import android.app.Activity;
import android.database.sqlite.SQLiteDatabase; // line 7
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
InitializeSQLite3(); // line 16
}
private void InitializeSQLite3() {
File databaseFile = getDatabasePath("names.db");
databaseFile.mkdirs();
databaseFile.delete();
SQLiteDatabase database = // line 26
SQLiteDatabase.openOrCreateDatabase(databaseFile, null);
database.execSQL("create table user(id integer primary key autoincrement,
" +
"first text not null, last text not null, " + // line 28
"username text not null, password text not null)");
database.execSQL("insert into user(first,last,username, password) " +
"values('Bertie','Ahern','bahern','celia123')");
// line 31
}
}
To add SQLite to your application, import the library (see line 7), initialize the SQLite database (see line 26), and then create your tables (see line 28) as well as add any initial data (see line 31).
In the example shown we are adding just a single row of data to the database. We are adding a first name, a last name, and a corresponding username and password to our database.
We can now recover the database using the following steps on a compatible phone:
- Compile the code, push it to your phone or emulator, and make sure it executes.
- Run the app.
Back up the databases using the following command:
adb backup com.riis.sqlite3
- If all is working, device will respond with “Now unlock your device and confirm the backup operation.”
On the device or emulator, click Back up my data to enable it to be backed up (see Figure 5-3).
Figure 5-3 Back up my data
- The backup file is a tar file with a custom header. We need to download the Android Backup Extractor from https://github.com/nelenkov/android-backup-extractor to get it into a tar format.
Convert your backup.ab file using the following command:
java -jar abe.jar unpack backup.ab backup.tar
- Uncompress your tar file using tar -xvf or 7zip if you’re on a Windows machine.
- Change directory to apps/com.riis.sqlite3/db, where you can now find your names.db database.
Open names.db in sqlitebrowser from http://sqlitebrowser.org (see Figure 5-4). As you see, the user information is in cleartext.
Figure 5-4 View the backup database data using the SQLite browser.
)
)
If you don’t have sqlitebrowser, you can always gain access to the sqlite database from the command line (refer ahead to Figure 5-6).
Note that if your backup.ab file is empty, then it’s likely that you have used the wrong package name. For commercial apps the best way to find the correct package name is to look at the target ID in the app’s Google Play URL (see Figure 5-5 for Facebook’s target ID). In this example, to back up the Facebook database you would type the following:
adb backup com.facebook.katana
)
Figure 5-5 Finding an App’s package name
Disabling Backup
If anyone with access to your phone can back it up, then we’ll need some way to hide the information if we’re going to be HIPAA compliant.
We can start with something simple by disabling backups using the allowBackup attribute in the Android Manifest file. By default this is set to true. Changing it to false, as in Listing 5-2, will stop the adb backup command working for any phone, even for a full system backup.
However, it would be a mistake to solely rely on this, as a rooted phone has access to databases and can still remove them from the phone via Unix commands. Figure 5-6 shows how someone can shell onto the phone, cd to the databases directory, and then dump the database table to view the data.
)
Figure 5-6 Viewing the backup database data from command line SQLite
adb pull can also be used to get the database off the phone. But you may also need to run a chmod 777 <filename> to fully open the file’s permissions before you can retrieve them.
Listing 5-2 Disabling backup
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.riis.sqlite3"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk
android:minSdkVersion="16"
android:targetSdkVersion="16" />
<application
android:allowBackup="false"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >
<activity
android:name="com.riis.sqlite3.MainActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>