Support for full backup/restore to sdcard

src/org/thoughtcrime/securesms/backup/BackupDialog.java

@@ -0,0 +1,86 @@
+package org.thoughtcrime.securesms.backup;
+
+
+import android.content.ClipData;
+import android.content.ClipboardManager;
+import android.content.Context;
+import android.support.annotation.NonNull;
+import android.support.v7.app.AlertDialog;
+import android.widget.Button;
+import android.widget.CheckBox;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import org.thoughtcrime.securesms.R;
+import org.thoughtcrime.securesms.components.SwitchPreferenceCompat;
+import org.thoughtcrime.securesms.service.LocalBackupListener;
+import org.thoughtcrime.securesms.util.BackupUtil;
+import org.thoughtcrime.securesms.util.TextSecurePreferences;
+import org.thoughtcrime.securesms.util.Util;
+
+public class BackupDialog {
+
+  public static void showEnableBackupDialog(@NonNull Context context, @NonNull SwitchPreferenceCompat preference) {
+    String[]    password = BackupUtil.generateBackupPassphrase();
+    AlertDialog dialog   = new AlertDialog.Builder(context)
+                                          .setTitle(R.string.BackupDialog_enable_local_backups)
+                                          .setView(R.layout.backup_enable_dialog)
+                                          .setPositiveButton(R.string.BackupDialog_enable_backups, null)
+                                          .setNegativeButton(android.R.string.cancel, null)
+                                          .create();
+
+    dialog.setOnShowListener(created -> {
+      Button button = ((AlertDialog) created).getButton(AlertDialog.BUTTON_POSITIVE);
+      button.setOnClickListener(v -> {
+        CheckBox confirmationCheckBox = dialog.findViewById(R.id.confirmation_check);
+        if (confirmationCheckBox.isChecked()) {
+          TextSecurePreferences.setBackupPassphrase(context, Util.join(password, " "));
+          TextSecurePreferences.setBackupEnabled(context, true);
+          LocalBackupListener.schedule(context);
+
+          preference.setChecked(true);
+          created.dismiss();
+        } else {
+          Toast.makeText(context, R.string.BackupDialog_please_acknowledge_your_understanding_by_marking_the_confirmation_check_box, Toast.LENGTH_LONG).show();
+        }
+      });
+    });
+
+    dialog.show();
+
+    CheckBox checkBox = dialog.findViewById(R.id.confirmation_check);
+    TextView textView = dialog.findViewById(R.id.confirmation_text);
+
+    ((TextView)dialog.findViewById(R.id.code_first)).setText(password[0]);
+    ((TextView)dialog.findViewById(R.id.code_second)).setText(password[1]);
+    ((TextView)dialog.findViewById(R.id.code_third)).setText(password[2]);
+
+    ((TextView)dialog.findViewById(R.id.code_fourth)).setText(password[3]);
+    ((TextView)dialog.findViewById(R.id.code_fifth)).setText(password[4]);
+    ((TextView)dialog.findViewById(R.id.code_sixth)).setText(password[5]);
+
+    textView.setOnClickListener(v -> checkBox.toggle());
+
+    dialog.findViewById(R.id.number_table).setOnClickListener(v -> {
+      ((ClipboardManager)context.getSystemService(Context.CLIPBOARD_SERVICE)).setPrimaryClip(ClipData.newPlainText("text", Util.join(password, " ")));
+      Toast.makeText(context, R.string.BackupDialog_copied_to_clipboard, Toast.LENGTH_LONG).show();
+    });
+
+
+  }
+
+  public static void showDisableBackupDialog(@NonNull Context context, @NonNull SwitchPreferenceCompat preference) {
+    new AlertDialog.Builder(context)
+                   .setTitle(R.string.BackupDialog_delete_backups)
+                   .setMessage(R.string.BackupDialog_disable_and_delete_all_local_backups)
+                   .setNegativeButton(android.R.string.cancel, null)
+                   .setPositiveButton(R.string.BackupDialog_delete_backups_statement, (dialog, which) -> {
+                     TextSecurePreferences.setBackupPassphrase(context, null);
+                     TextSecurePreferences.setBackupEnabled(context, false);
+                     BackupUtil.deleteAllBackups();
+                     preference.setChecked(false);
+                   })
+                   .create()
+                   .show();
+  }
+}

src/org/thoughtcrime/securesms/backup/FullBackupBase.java

@@ -0,0 +1,62 @@
+package org.thoughtcrime.securesms.backup;
+
+
+import android.support.annotation.NonNull;
+import android.util.Log;
+
+import org.greenrobot.eventbus.EventBus;
+import org.whispersystems.libsignal.util.ByteUtil;
+
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
+public abstract class FullBackupBase {
+
+  private static final String TAG = FullBackupBase.class.getSimpleName();
+
+  protected static @NonNull byte[] getBackupKey(@NonNull String passphrase) {
+    try {
+      EventBus.getDefault().post(new BackupEvent(BackupEvent.Type.PROGRESS, 0));
+
+      MessageDigest digest = MessageDigest.getInstance("SHA-512");
+      byte[]        input  = passphrase.replace(" ", "").getBytes();
+      byte[]        hash   = input;
+
+      long start = System.currentTimeMillis();
+      for (int i=0;i<250000;i++) {
+        if (i % 1000 == 0) EventBus.getDefault().post(new BackupEvent(BackupEvent.Type.PROGRESS, 0));
+        digest.update(hash);
+        hash = digest.digest(input);
+      }
+      Log.w(TAG, "Generated: " + (System.currentTimeMillis()- start));
+
+      return ByteUtil.trim(hash, 32);
+    } catch (NoSuchAlgorithmException e) {
+      throw new AssertionError(e);
+    }
+  }
+
+  public static class BackupEvent {
+    public enum Type {
+      PROGRESS,
+      FINISHED
+    }
+
+    private final Type type;
+    private final int count;
+
+    BackupEvent(Type type, int count) {
+      this.type  = type;
+      this.count = count;
+    }
+
+    public Type getType() {
+      return type;
+    }
+
+    public int getCount() {
+      return count;
+    }
+  }
+
+}

src/org/thoughtcrime/securesms/backup/FullBackupExporter.java

@@ -0,0 +1,312 @@
+package org.thoughtcrime.securesms.backup;
+
+
+import android.content.Context;
+import android.database.Cursor;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.text.TextUtils;
+import android.util.Log;
+
+import com.annimon.stream.function.Consumer;
+import com.annimon.stream.function.Predicate;
+import com.google.protobuf.ByteString;
+
+import net.sqlcipher.database.SQLiteDatabase;
+
+import org.greenrobot.eventbus.EventBus;
+import org.thoughtcrime.securesms.attachments.AttachmentId;
+import org.thoughtcrime.securesms.crypto.AttachmentSecret;
+import org.thoughtcrime.securesms.crypto.ClassicDecryptingPartInputStream;
+import org.thoughtcrime.securesms.crypto.IdentityKeyUtil;
+import org.thoughtcrime.securesms.crypto.ModernDecryptingPartInputStream;
+import org.thoughtcrime.securesms.database.AttachmentDatabase;
+import org.thoughtcrime.securesms.database.MmsDatabase;
+import org.thoughtcrime.securesms.database.MmsSmsColumns;
+import org.thoughtcrime.securesms.database.OneTimePreKeyDatabase;
+import org.thoughtcrime.securesms.database.SessionDatabase;
+import org.thoughtcrime.securesms.database.SignedPreKeyDatabase;
+import org.thoughtcrime.securesms.database.SmsDatabase;
+import org.thoughtcrime.securesms.util.Conversions;
+import org.thoughtcrime.securesms.util.Hex;
+import org.thoughtcrime.securesms.util.Util;
+import org.whispersystems.libsignal.kdf.HKDFv3;
+import org.whispersystems.libsignal.util.ByteUtil;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.security.InvalidAlgorithmParameterException;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
+import java.util.LinkedList;
+import java.util.List;
+
+import javax.crypto.BadPaddingException;
+import javax.crypto.Cipher;
+import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.Mac;
+import javax.crypto.NoSuchPaddingException;
+import javax.crypto.spec.IvParameterSpec;
+import javax.crypto.spec.SecretKeySpec;
+
+public class FullBackupExporter extends FullBackupBase {
+
+  @SuppressWarnings("unused")
+  private static final String TAG = FullBackupExporter.class.getSimpleName();
+
+  public static void export(@NonNull Context context,
+                            @NonNull AttachmentSecret attachmentSecret,
+                            @NonNull SQLiteDatabase input,
+                            @NonNull File output,
+                            @NonNull String passphrase)
+      throws IOException
+  {
+    byte[]                  key          = getBackupKey(passphrase);
+    BackupFrameOutputStream outputStream = new BackupFrameOutputStream(output, key);
+    outputStream.writeDatabaseVersion(input.getVersion());
+
+    List<String> tables = exportSchema(input, outputStream);
+    int          count  = 0;
+
+    for (String table : tables) {
+      if (table.equals(SmsDatabase.TABLE_NAME) || table.equals(MmsDatabase.TABLE_NAME)) {
+        count = exportTable(table, input, outputStream, cursor -> cursor.getInt(cursor.getColumnIndexOrThrow(MmsSmsColumns.EXPIRES_IN)) <= 0, null, count);
+      } else if (table.equals(AttachmentDatabase.TABLE_NAME)) {
+        count = exportTable(table, input, outputStream, null, cursor -> exportAttachment(attachmentSecret, cursor, outputStream), count);
+      } else if (!table.equals(SignedPreKeyDatabase.TABLE_NAME)  &&
+                 !table.equals(OneTimePreKeyDatabase.TABLE_NAME) &&
+                 !table.equals(SessionDatabase.TABLE_NAME))
+      {
+        count = exportTable(table, input, outputStream, null, null, count);
+      }
+    }
+
+    for (BackupProtos.SharedPreference preference : IdentityKeyUtil.getBackupRecord(context)) {
+      if (++count % 100 == 0) EventBus.getDefault().post(new BackupEvent(BackupEvent.Type.PROGRESS, count));
+      outputStream.write(preference);
+    }
+
+    outputStream.writeEnd();
+    outputStream.close();
+    EventBus.getDefault().post(new BackupEvent(BackupEvent.Type.FINISHED, count));
+  }
+
+  private static List<String> exportSchema(@NonNull SQLiteDatabase input, @NonNull BackupFrameOutputStream outputStream)
+      throws IOException
+  {
+    List<String> tables = new LinkedList<>();
+
+    try (Cursor cursor = input.rawQuery("SELECT sql, name, type FROM sqlite_master", null)) {
+      while (cursor != null && cursor.moveToNext()) {
+        String sql  = cursor.getString(0);
+        String name = cursor.getString(1);
+        String type = cursor.getString(2);
+
+        if (sql != null) {
+          if ("table".equals(type)) {
+            outputStream.write(BackupProtos.SqlStatement.newBuilder().setStatement("DROP TABLE IF EXISTS " + name).build());
+            tables.add(name);
+          } else if ("index".equals(type)) {
+            outputStream.write(BackupProtos.SqlStatement.newBuilder().setStatement("DROP INDEX IF EXISTS " + name).build());
+          }
+
+          outputStream.write(BackupProtos.SqlStatement.newBuilder().setStatement(cursor.getString(0)).build());
+        }
+      }
+    }
+
+    return tables;
+  }
+
+  private static int exportTable(@NonNull   String table,
+                                 @NonNull   SQLiteDatabase input,
+                                 @NonNull   BackupFrameOutputStream outputStream,
+                                 @Nullable  Predicate<Cursor> predicate,
+                                 @Nullable  Consumer<Cursor> postProcess,
+                                            int count)
+      throws IOException
+  {
+    String template = "INSERT INTO " + table + " VALUES ";
+
+    try (Cursor cursor = input.rawQuery("SELECT * FROM " + table, null)) {
+      while (cursor != null && cursor.moveToNext()) {
+        if (++count % 100 == 0) EventBus.getDefault().post(new BackupEvent(BackupEvent.Type.PROGRESS, count));
+
+        if (predicate == null || predicate.test(cursor)) {
+          StringBuilder statement = new StringBuilder(template);
+
+          statement.append('(');
+
+          for (int i=0;i<cursor.getColumnCount();i++) {
+            if (cursor.getType(i) == Cursor.FIELD_TYPE_STRING) {
+              statement.append('\'');
+              statement.append(cursor.getString(i));
+              statement.append('\'');
+            } else if (cursor.getType(i) == Cursor.FIELD_TYPE_FLOAT) {
+              statement.append(cursor.getFloat(i));
+            } else if (cursor.getType(i) == Cursor.FIELD_TYPE_INTEGER) {
+              statement.append(cursor.getLong(i));
+            } else if (cursor.getType(i) == Cursor.FIELD_TYPE_BLOB) {
+              statement.append("x'");
+              statement.append(Hex.toStringCondensed(cursor.getBlob(i)));
+              statement.append('\'');
+            } else if (cursor.getType(i) == Cursor.FIELD_TYPE_NULL) {
+              statement.append("NULL");
+            } else {
+              throw new AssertionError("unknown type?"  + cursor.getType(i));
+            }
+
+            if (i < cursor.getColumnCount()-1) {
+              statement.append(',');
+            }
+          }
+
+          statement.append(')');
+
+          outputStream.write(BackupProtos.SqlStatement.newBuilder().setStatement(statement.toString()).build());
+
+          if (postProcess != null) postProcess.accept(cursor);
+        }
+      }
+    }
+
+    return count;
+  }
+
+  private static void exportAttachment(@NonNull AttachmentSecret attachmentSecret, @NonNull Cursor cursor, @NonNull BackupFrameOutputStream outputStream) {
+    try {
+      long rowId    = cursor.getLong(cursor.getColumnIndexOrThrow(AttachmentDatabase.ROW_ID));
+      long uniqueId = cursor.getLong(cursor.getColumnIndexOrThrow(AttachmentDatabase.UNIQUE_ID));
+      long size     = cursor.getLong(cursor.getColumnIndexOrThrow(AttachmentDatabase.SIZE));
+
+      String data   = cursor.getString(cursor.getColumnIndexOrThrow(AttachmentDatabase.DATA));
+      byte[] random = cursor.getBlob(cursor.getColumnIndexOrThrow(AttachmentDatabase.DATA_RANDOM));
+
+      if (!TextUtils.isEmpty(data)) {
+        InputStream inputStream;
+
+        if (random != null && random.length == 32) inputStream = ModernDecryptingPartInputStream.createFor(attachmentSecret, random, new File(data), 0);
+        else                                       inputStream = ClassicDecryptingPartInputStream.createFor(attachmentSecret, new File(data));
+
+        outputStream.write(new AttachmentId(rowId, uniqueId), inputStream, size);
+      }
+    } catch (IOException e) {
+      Log.w(TAG, e);
+    }
+  }
+
+  private static class BackupFrameOutputStream {
+
+    private final OutputStream outputStream;
+    private final Cipher       cipher;
+    private final Mac          mac;
+
+    private final byte[]       cipherKey;
+    private final byte[]       macKey;
+
+    private byte[] iv;
+    private int    counter;
+
+    private BackupFrameOutputStream(@NonNull File output, @NonNull byte[] key) throws IOException {
+      try {
+        byte[] derived = new HKDFv3().deriveSecrets(key, "Backup Export".getBytes(), 64);
+        byte[][] split = ByteUtil.split(derived, 32, 32);
+
+        this.cipherKey = split[0];
+        this.macKey    = split[1];
+
+        this.cipher       = Cipher.getInstance("AES/CTR/NoPadding");
+        this.mac          = Mac.getInstance("HmacSHA256");
+        this.outputStream = new FileOutputStream(output);
+        this.iv           = Util.getSecretBytes(16);
+        this.counter      = Conversions.byteArrayToInt(iv);
+
+        mac.init(new SecretKeySpec(macKey, "HmacSHA256"));
+
+        byte[] header = BackupProtos.BackupFrame.newBuilder().setHeader(BackupProtos.Header.newBuilder().setIv(ByteString.copyFrom(iv))).build().toByteArray();
+
+        outputStream.write(Conversions.intToByteArray(header.length));
+        outputStream.write(header);
+      } catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException e) {
+        throw new AssertionError(e);
+      }
+    }
+
+    public void write(BackupProtos.SharedPreference preference) throws IOException {
+      write(outputStream, BackupProtos.BackupFrame.newBuilder().setPreference(preference).build());
+    }
+
+    public void write(BackupProtos.SqlStatement statement) throws IOException {
+      write(outputStream, BackupProtos.BackupFrame.newBuilder().setStatement(statement).build());
+    }
+
+    public void write(@NonNull AttachmentId attachmentId, @NonNull InputStream in, long size) throws IOException {
+      write(outputStream, BackupProtos.BackupFrame.newBuilder()
+                                                  .setAttachment(BackupProtos.Attachment.newBuilder()
+                                                                                        .setRowId(attachmentId.getRowId())
+                                                                                        .setAttachmentId(attachmentId.getUniqueId())
+                                                                                        .setLength(Util.toIntExact(size))
+                                                                                        .build())
+                                                  .build());
+
+
+      try {
+        Conversions.intToByteArray(iv, 0, counter++);
+        cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(cipherKey, "AES"), new IvParameterSpec(iv));
+
+        byte[] buffer = new byte[8192];
+        int read;
+
+        while ((read = in.read(buffer)) != -1) {
+          byte[] ciphertext = cipher.update(buffer, 0, read);
+          outputStream.write(ciphertext);
+          mac.update(ciphertext);
+        }
+
+        byte[] remainder = cipher.doFinal();
+        outputStream.write(remainder);
+        mac.update(remainder);
+
+        byte[] attachmentDigest = mac.doFinal();
+        outputStream.write(attachmentDigest, 0, 10);
+      } catch (InvalidKeyException | InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) {
+        throw new AssertionError(e);
+      }
+    }
+
+    void writeDatabaseVersion(int version) throws IOException {
+      write(outputStream, BackupProtos.BackupFrame.newBuilder()
+                                                  .setVersion(BackupProtos.DatabaseVersion.newBuilder().setVersion(version))
+                                                  .build());
+    }
+
+    void writeEnd() throws IOException {
+      write(outputStream, BackupProtos.BackupFrame.newBuilder().setEnd(true).build());
+    }
+
+    private void write(@NonNull OutputStream out, @NonNull BackupProtos.BackupFrame frame) throws IOException {
+      try {
+        Conversions.intToByteArray(iv, 0, counter++);
+        cipher.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(cipherKey, "AES"), new IvParameterSpec(iv));
+
+        byte[] frameCiphertext = cipher.doFinal(frame.toByteArray());
+        byte[] frameMac        = mac.doFinal(frameCiphertext);
+        byte[] length          = Conversions.intToByteArray(frameCiphertext.length + 10);
+
+        out.write(length);
+        out.write(frameCiphertext);
+        out.write(frameMac, 0, 10);
+      } catch (InvalidKeyException | InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) {
+        throw new AssertionError(e);
+      }
+    }
+
+    public void close() throws IOException {
+      outputStream.close();
+    }
+
+  }
+}

src/org/thoughtcrime/securesms/backup/FullBackupImporter.java

@@ -0,0 +1,240 @@
+package org.thoughtcrime.securesms.backup;
+
+
+import android.annotation.SuppressLint;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.support.annotation.NonNull;
+import android.util.Pair;
+
+import net.sqlcipher.database.SQLiteDatabase;
+
+import org.greenrobot.eventbus.EventBus;
+import org.thoughtcrime.securesms.backup.BackupProtos.Attachment;
+import org.thoughtcrime.securesms.backup.BackupProtos.BackupFrame;
+import org.thoughtcrime.securesms.backup.BackupProtos.DatabaseVersion;
+import org.thoughtcrime.securesms.backup.BackupProtos.SharedPreference;
+import org.thoughtcrime.securesms.backup.BackupProtos.SqlStatement;
+import org.thoughtcrime.securesms.crypto.AttachmentSecret;
+import org.thoughtcrime.securesms.crypto.ModernEncryptingPartOutputStream;
+import org.thoughtcrime.securesms.database.AttachmentDatabase;
+import org.thoughtcrime.securesms.util.Conversions;
+import org.thoughtcrime.securesms.util.Util;
+import org.whispersystems.libsignal.kdf.HKDFv3;
+import org.whispersystems.libsignal.util.ByteUtil;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.security.InvalidAlgorithmParameterException;
+import java.security.InvalidKeyException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
+import javax.crypto.BadPaddingException;
+import javax.crypto.Cipher;
+import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.Mac;
+import javax.crypto.NoSuchPaddingException;
+import javax.crypto.spec.IvParameterSpec;
+import javax.crypto.spec.SecretKeySpec;
+
+public class FullBackupImporter extends FullBackupBase {
+
+  @SuppressWarnings("unused")
+  private static final String TAG = FullBackupImporter.class.getSimpleName();
+
+  public static void importFile(@NonNull Context context, @NonNull AttachmentSecret attachmentSecret,
+                                @NonNull SQLiteDatabase db, @NonNull File file, @NonNull String passphrase)
+      throws IOException
+  {
+    byte[]                  key         = getBackupKey(passphrase);
+    BackupRecordInputStream inputStream = new BackupRecordInputStream(file, key);
+    int                     count       = 0;
+
+    try {
+      db.beginTransaction();
+
+      BackupFrame frame;
+
+      while (!(frame = inputStream.readFrame()).getEnd()) {
+        if (count++ % 100 == 0) EventBus.getDefault().post(new BackupEvent(BackupEvent.Type.PROGRESS, count));
+
+        if      (frame.hasVersion())    processVersion(db, frame.getVersion());
+        else if (frame.hasStatement())  processStatement(db, frame.getStatement());
+        else if (frame.hasPreference()) processPreference(context, frame.getPreference());
+        else if (frame.hasAttachment()) processAttachment(context, attachmentSecret, db, frame.getAttachment(), inputStream);
+      }
+
+      db.setTransactionSuccessful();
+    } finally {
+      db.endTransaction();
+    }
+
+    EventBus.getDefault().post(new BackupEvent(BackupEvent.Type.FINISHED, count));
+  }
+
+  private static void processVersion(@NonNull SQLiteDatabase db, DatabaseVersion version) {
+    db.setVersion(version.getVersion());
+  }
+
+  private static void processStatement(@NonNull SQLiteDatabase db, SqlStatement statement) {
+    db.execSQL(statement.getStatement());
+  }
+
+  private static void processAttachment(@NonNull Context context, @NonNull AttachmentSecret attachmentSecret, @NonNull SQLiteDatabase db, @NonNull Attachment attachment, BackupRecordInputStream inputStream)
+      throws IOException
+  {
+    File partsDirectory = context.getDir(AttachmentDatabase.DIRECTORY, Context.MODE_PRIVATE);
+    File dataFile       = File.createTempFile("part", ".mms", partsDirectory);
+
+    Pair<byte[], OutputStream> output = ModernEncryptingPartOutputStream.createFor(attachmentSecret, dataFile, false);
+
+    inputStream.readAttachmentTo(output.second, attachment.getLength());
+
+    ContentValues contentValues = new ContentValues();
+    contentValues.put(AttachmentDatabase.DATA, dataFile.getAbsolutePath());
+    contentValues.put(AttachmentDatabase.THUMBNAIL, (String)null);
+    contentValues.put(AttachmentDatabase.DATA_RANDOM, output.first);
+
+    db.update(AttachmentDatabase.TABLE_NAME, contentValues,
+              AttachmentDatabase.ROW_ID + " = ? AND " + AttachmentDatabase.UNIQUE_ID + " = ?",
+              new String[] {String.valueOf(attachment.getRowId()), String.valueOf(attachment.getAttachmentId())});
+  }
+
+  @SuppressLint("ApplySharedPref")
+  private static void processPreference(@NonNull Context context, SharedPreference preference) {
+    SharedPreferences preferences = context.getSharedPreferences(preference.getFile(), 0);
+    preferences.edit().putString(preference.getKey(), preference.getValue()).commit();
+  }
+
+  private static class BackupRecordInputStream {
+
+    private final InputStream in;
+    private final Cipher      cipher;
+    private final Mac         mac;
+
+    private final byte[] cipherKey;
+    private final byte[] macKey;
+
+    private byte[] iv;
+    private int    counter;
+
+    private BackupRecordInputStream(@NonNull File file, @NonNull byte[] key) throws IOException {
+      try {
+        byte[]   derived = new HKDFv3().deriveSecrets(key, "Backup Export".getBytes(), 64);
+        byte[][] split   = ByteUtil.split(derived, 32, 32);
+
+        this.cipherKey = split[0];
+        this.macKey    = split[1];
+
+        this.cipher = Cipher.getInstance("AES/CTR/NoPadding");
+        this.mac    = Mac.getInstance("HmacSHA256");
+        this.in     = new FileInputStream(file);
+        this.mac.init(new SecretKeySpec(macKey, "HmacSHA256"));
+
+        byte[] headerLengthBytes = new byte[4];
+        Util.readFully(in, headerLengthBytes);
+
+        int headerLength = Conversions.byteArrayToInt(headerLengthBytes);
+        byte[] headerFrame = new byte[headerLength];
+        Util.readFully(in, headerFrame);
+
+        BackupFrame frame = BackupFrame.parseFrom(headerFrame);
+
+        if (!frame.hasHeader()) {
+          throw new IOException("Backup stream does not start with header!");
+        }
+
+        BackupProtos.Header header = frame.getHeader();
+
+        this.iv = header.getIv().toByteArray();
+
+        if (iv.length != 16) {
+          throw new IOException("Invalid IV length!");
+        }
+
+        this.counter = Conversions.byteArrayToInt(iv);
+      } catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException e) {
+        throw new AssertionError(e);
+      }
+    }
+
+    BackupFrame readFrame() throws IOException {
+      return readFrame(in);
+    }
+
+    void readAttachmentTo(OutputStream out, int length) throws IOException {
+      try {
+        Conversions.intToByteArray(iv, 0, counter++);
+        cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(cipherKey, "AES"), new IvParameterSpec(iv));
+
+        byte[] buffer = new byte[8192];
+
+        while (length > 0) {
+          int read = in.read(buffer, 0, Math.min(buffer.length, length));
+          if (read == -1) throw new IOException("File ended early!");
+
+          mac.update(buffer, 0, read);
+
+          byte[] plaintext = cipher.update(buffer, 0, read);
+          out.write(plaintext, 0, plaintext.length);
+
+          length -= read;
+        }
+
+        out.close();
+
+        byte[] ourMac   = mac.doFinal();
+        byte[] theirMac = new byte[10];
+
+        try {
+          Util.readFully(in, theirMac);
+        } catch (IOException e) {
+          //destination.delete();
+          throw new IOException(e);
+        }
+
+        if (MessageDigest.isEqual(ourMac, theirMac)) {
+          //destination.delete();
+          throw new IOException("Bad MAC");
+        }
+      } catch (InvalidKeyException | InvalidAlgorithmParameterException e) {
+        throw new AssertionError(e);
+      }
+    }
+
+    private BackupFrame readFrame(InputStream in) throws IOException {
+      try {
+        byte[] length = new byte[4];
+        Util.readFully(in, length);
+
+        byte[] frame = new byte[Conversions.byteArrayToInt(length)];
+        Util.readFully(in, frame);
+
+        byte[] theirMac = new byte[10];
+        System.arraycopy(frame, frame.length - 10, theirMac, 0, theirMac.length);
+
+        mac.update(frame, 0, frame.length - 10);
+        byte[] ourMac = mac.doFinal();
+
+        if (MessageDigest.isEqual(ourMac, theirMac)) {
+          throw new IOException("Bad MAC");
+        }
+
+        Conversions.intToByteArray(iv, 0, counter++);
+        cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(cipherKey, "AES"), new IvParameterSpec(iv));
+
+        byte[] plaintext = cipher.doFinal(frame, 0, frame.length - 10);
+
+        return BackupFrame.parseFrom(plaintext);
+      } catch (InvalidKeyException | InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) {
+        throw new AssertionError(e);
+      }
+    }
+  }
+
+}