def _init_u1db_sqlcipher_backend(self): """ Initialize the U1DB SQLCipher database for local storage. Instantiates a modified twisted adbapi that will maintain a threadpool with a u1db-sqclipher connection for each thread, and will return deferreds for each u1db query. Currently, Soledad uses the default SQLCipher cipher, i.e. 'aes-256-cbc'. We use scrypt to derive a 256-bit encryption key, and internally the SQLCipherDatabase initialization uses the 'raw PRAGMA key' format to handle the key to SQLCipher. """ tohex = binascii.b2a_hex # sqlcipher only accepts the hex version key = tohex(self._secrets.get_local_storage_key()) sync_db_key = tohex(self._secrets.get_sync_db_key()) opts = SQLCipherOptions( self._local_db_path, key, is_raw_key=True, create=True, defer_encryption=self._defer_encryption, sync_db_key=sync_db_key, ) self._sqlcipher_opts = opts self._dbpool = adbapi.getConnectionPool(opts)
def setUp(self): SoledadWithCouchServerMixin.setUp(self) # config info self.db1_file = os.path.join(self.tempdir, "db1.u1db") os.unlink(self.db1_file) self.db_pass = DBPASS self.email = ADDRESS # get a random prefix for each test, so we do not mess with # concurrency during initialization and shutting down of # each local db. self.rand_prefix = ''.join( map(lambda x: random.choice(string.ascii_letters), range(6))) # open test dbs: db1 will be the local sqlcipher db (which # instantiates a syncdb). We use the self._soledad instance that was # already created on some setUp method. import binascii tohex = binascii.b2a_hex key = tohex(self._soledad.secrets.get_local_storage_key()) sync_db_key = tohex(self._soledad.secrets.get_sync_db_key()) dbpath = self._soledad._local_db_path self.opts = SQLCipherOptions(dbpath, key, is_raw_key=True, create=False, defer_encryption=True, sync_db_key=sync_db_key) self.db1 = SQLCipherDatabase(self.opts) self.db2 = couch.CouchDatabase.open_database(urljoin( 'http://localhost:' + str(self.wrapper.port), 'test'), create=True, ensure_ddocs=True)
def __init__(self, path, key=None): self.path = os.path.abspath(os.path.join(path, 'soledad_blob.db')) if not key: raise ValueError('key cannot be None') backend = 'pysqlcipher.dbapi2' opts = SQLCipherOptions('/tmp/ignored', key) pragmafun = partial(pragmas.set_init_pragmas, opts=opts) openfun = _sqlcipherInitFactory(pragmafun) self.dbpool = ConnectionPool(backend, self.path, check_same_thread=False, timeout=5, cp_openfun=openfun, cp_min=1, cp_max=2, cp_name='blob_pool')
def setUp(self): """ Need to explicitely invoke inicialization on all bases. """ SoledadWithCouchServerMixin.setUp(self) self.server = self.server_thread = None self.startTwistedServer() self.syncer = None # config info self.db1_file = os.path.join(self.tempdir, "db1.u1db") os.unlink(self.db1_file) self.db_pass = DBPASS self.email = ADDRESS # get a random prefix for each test, so we do not mess with # concurrency during initialization and shutting down of # each local db. self.rand_prefix = ''.join( map(lambda x: random.choice(string.ascii_letters), range(6))) # open test dbs: db1 will be the local sqlcipher db (which # instantiates a syncdb). We use the self._soledad instance that was # already created on some setUp method. import binascii tohex = binascii.b2a_hex key = tohex(self._soledad.secrets.get_local_storage_key()) sync_db_key = tohex(self._soledad.secrets.get_sync_db_key()) dbpath = self._soledad._local_db_path self.opts = SQLCipherOptions(dbpath, key, is_raw_key=True, create=False, defer_encryption=True, sync_db_key=sync_db_key) self.db1 = SQLCipherDatabase(self.opts) self.db2 = self.request_state._create_database(replica_uid='test')
def _get_dbpool(self): tmpdb = os.path.join(self.tempdir, "test.soledad") opts = SQLCipherOptions(tmpdb, "secret", create=True) return adbapi.getConnectionPool(opts)
def debug(*args): if not silent: print(*args) debug("[+] db path:", tmpdb) debug("[+] num docs", numdocs) if os.path.isfile(tmpdb): debug("[+] Removing existing db file...") os.remove(tmpdb) start_time = datetime.datetime.now() opts = SQLCipherOptions(tmpdb, "secret", create=True) dbpool = adbapi.getConnectionPool(opts) def createDoc(doc, doc_id): return dbpool.runU1DBQuery("create_doc", doc, doc_id=doc_id) db_indexes = {'by-chash': ['chash'], 'by-number': ['number']} def create_indexes(_): deferreds = [] for index, definition in db_indexes.items(): d = dbpool.runU1DBQuery("create_index", index, *definition) deferreds.append(d)
def make_sqlcipher_database_for_test(test, replica_uid): db = SQLCipherDatabase(SQLCipherOptions(':memory:', PASSWORD)) db._set_replica_uid(replica_uid) return db
def sqlcipher_open(path, passphrase, create=True, document_factory=None): return SQLCipherDatabase(SQLCipherOptions(path, passphrase, create=create))
def __init__(self, dbname, ntry): self._try = ntry self._is_initialized_invocations = 0 SQLCipherDatabase.__init__(self, SQLCipherOptions(dbname, PASSWORD))