net.sqlcipher.database.SQLiteException Java Examples

/**
 * {@inheritDoc}
 *
 * NOTE: by default, this implementation zeros out the passphrase after opening the
 * database
 */
@Override
synchronized public SupportSQLiteDatabase getWritableDatabase() {
  SupportSQLiteDatabase result;

  try {
    result = delegate.getWritableSupportDatabase(passphrase);
  }
  catch (SQLiteException e) {
    if (passphrase != null) {
      boolean isCleared = true;

      for (byte b : passphrase) {
        isCleared = isCleared && (b == (byte) 0);
      }

      if (isCleared) {
        throw new IllegalStateException("The passphrase appears to be cleared. This happens by" +
            "default the first time you use the factory to open a database, so we can remove the" +
            "cleartext passphrase from memory. If you close the database yourself, please use a" +
            "fresh SafeHelperFactory to reopen it. If something else (e.g., Room) closed the" +
            "database, and you cannot control that, use SafeHelperFactory.Options to opt out of" +
            "the automatic password clearing step. See the project README for more information.");
      }
    }

    throw e;
  }

  if (clearPassphrase && passphrase != null) {
    for (int i = 0; i < passphrase.length; i++) {
      passphrase[i] = (byte) 0;
    }
  }

  return(result);
}
 

@Override
public Cursor rawQuery(String sql, String[] values) throws java.sql.SQLException {
    try {
        return new AndroidSQLiteCursor(this.database.rawQuery(sql, values));
    } catch (SQLiteException e) {
        throw new java.sql.SQLException(e);
    }
}
 

@Override
public SQLiteDatabase getWritableDatabase(String key) {
    try {
        return super.getWritableDatabase(key);
    } catch (SQLiteException sqle) {
        DbUtil.trySqlCipherDbUpdate(key, mContext, GLOBAL_DB_LOCATOR);
        return super.getWritableDatabase(key);
    }
}
 

@Override
public SQLiteDatabase getWritableDatabase(String key) {
    try {
        return super.getWritableDatabase(key);
    } catch (SQLiteException sqle) {
        DbUtil.trySqlCipherDbUpdate(key, context, getDbName(mAppId));
        return super.getWritableDatabase(key);
    }
}
 

@Override
public SQLiteDatabase getWritableDatabase(String key) {
    fileMigrationKeySeed = key.getBytes();

    try {
        return super.getWritableDatabase(key);
    } catch (SQLiteException sqle) {
        DbUtil.trySqlCipherDbUpdate(key, context, getDbName(mUserId));
        return super.getWritableDatabase(key);
    }
}
 

/**
 * {@inheritDoc}
 *
 * NOTE: by default, this implementation zeros out the passphrase after
 * opening the database
 */
@Override
synchronized public SupportSQLiteDatabase getWritableDatabase() {
	SupportSQLiteDatabase result;

	// if we don't have a passphrase, an exception will be thrown
	if (requiredPassphrase && passphrase == null) {
		Logger.fatal("Try to open ciphered database %s without any passphrase", getDatabaseName());

		throw new SQLCipherPassphraseRequiredException();
	}
	try {
		result = delegate.getWritableSupportDatabase(passphrase);
	} catch (SQLiteException e) {
		if (passphrase != null) {
			boolean isCleared = true;

			for (byte b : passphrase) {
				isCleared = isCleared && (b == (byte) 0);
			}

			if (isCleared) {
				throw new IllegalStateException("The passphrase appears to be cleared. This happens by"
						+ "default the first time you use the factory to open a database, so we can remove the"
						+ "cleartext passphrase from memory. If you close the database yourself, please use a"
						+ "fresh SafeHelperFactory to reopen it. If something else (e.g., Room) closed the"
						+ "database, and you cannot control that, use SafeHelperFactory.Options to opt out of"
						+ "the automatic password clearing step. See the project README for more information.");
			}
		}

		throw e;
	}

	if (clearPassphrase && passphrase != null) {
		for (int i = 0; i < passphrase.length; i++) {
			passphrase[i] = (byte) 0;
		}
	}

	return (result);
}
 

@Implementation
public void changePassword(char[] password) throws SQLiteException {
}
 

@Implementation
public void changePassword(String password) throws SQLiteException {
}
 

/**
 * Create and/or open a database that will be used for reading and writing.
 * Once opened successfully, the database is cached, so you can call this
 * method every time you need to write to the database. Make sure to call
 * {@link #close} when you no longer need it.
 * <p>
 * Errors such as bad permissions or a full disk may cause this operation to
 * fail, but future attempts may succeed if the problem is fixed.
 * </p>
 *
 * @throws SQLiteException if the database cannot be opened for writing
 * @return a read/write database object valid until {@link #close} is called
 */
public synchronized SQLiteDatabase getWritableDatabase() {
    if (mHandler.isLocked())
        throw new SQLiteException("Database locked. Decryption key unavailable.");

    return super.getWritableDatabase(encodeRawKey(mHandler.getEncryptionKey()));
}
 

/**
 * Create and/or open a database. This will be the same object returned by
 * {@link #getWritableDatabase} unless some problem, such as a full disk,
 * requires the database to be opened read-only. In that case, a read-only
 * database object will be returned. If the problem is fixed, a future call
 * to {@link #getWritableDatabase} may succeed, in which case the read-only
 * database object will be closed and the read/write object will be returned
 * in the future.
 *
 * @throws SQLiteException if the database cannot be opened
 * @return a database object valid until {@link #getWritableDatabase} or
 *         {@link #close} is called.
 */
public synchronized SQLiteDatabase getReadableDatabase() {
    if (mHandler.isLocked())
        throw new SQLiteException("Database locked. Decryption key unavailable.");

    return super.getReadableDatabase(encodeRawKey(mHandler.getEncryptionKey()));
}
 

/**
 * Create and/or open a database that will be used for reading and writing.
 * Once opened successfully, the database is cached, so you can call this
 * method every time you need to write to the database. Make sure to call
 * {@link #close} when you no longer need it.
 * <p>
 * Errors such as bad permissions or a full disk may cause this operation to
 * fail, but future attempts may succeed if the problem is fixed.
 * </p>
 *
 * @throws SQLiteException if the database cannot be opened for writing
 * @return a read/write database object valid until {@link #close} is called
 */
public synchronized SQLiteDatabase getWritableDatabase()
{
	if (mCacheWordHandler.isLocked())
    {
		throw new SQLiteException("Database locked. Decryption key unavailable.");
    }
    
    return super.getWritableDatabase(encodeRawKey(mCacheWordHandler.getEncryptionKey()));
}
 

/**
 * Create and/or open a database. This will be the same object returned by
 * {@link #getWritableDatabase} unless some problem, such as a full disk,
 * requires the database to be opened read-only. In that case, a read-only
 * database object will be returned. If the problem is fixed, a future call
 * to {@link #getWritableDatabase} may succeed, in which case the read-only
 * database object will be closed and the read/write object will be returned
 * in the future.
 *
 * @throws SQLiteException if the database cannot be opened
 * @return a database object valid until {@link #getWritableDatabase} or
 *         {@link #close} is called.
 */
public synchronized SQLiteDatabase getReadableDatabase()
{
	if (mCacheWordHandler.isLocked())
    {
    	throw new SQLiteException("Database locked. Decryption key unavailable.");
    }
    
    return super.getReadableDatabase(encodeRawKey(mCacheWordHandler.getEncryptionKey()));
}