def decrypt( key ,operation): if operation==1: conn = sqlite.connect( ORIGINAL_FILE ) else: conn = sqlite.connect( DECRYPTED_FILE ) c = conn.cursor() try: if operation==1: c.execute( "PRAGMA key = '" + key + "';" ) c.execute( "PRAGMA cipher_use_hmac = OFF;" ) c.execute( "PRAGMA cipher_page_size = 1024;" ) c.execute( "PRAGMA kdf_iter = 4000;" ) c.execute( "ATTACH DATABASE '"+DECRYPTED_FILE+"' AS wechatdecrypted KEY '';" ) c.execute( "SELECT sqlcipher_export( 'wechatdecrypted' );" ) c.execute( "DETACH DATABASE wechatdecrypted;" ) else: c.execute( "ATTACH DATABASE '"+ENCRYPTED_FILE_NEW+"' AS wechatencrypted KEY '"+ key +"';" ) c.execute( "PRAGMA wechatencrypted.cipher_use_hmac = OFF;" ) c.execute( "PRAGMA wechatencrypted.cipher_page_size = 1024;" ) c.execute( "PRAGMA wechatencrypted.kdf_iter = 4000;" ) c.execute( "SELECT sqlcipher_export( 'wechatencrypted' );" ) c.execute( "DETACH DATABASE wechatencrypted;" ) c.close() status = 1 except: c.close() status = 0 return status
def decrypt(key, operation): if operation == 1: conn = sqlite.connect(ORIGINAL_FILE) else: conn = sqlite.connect(DECRYPTED_FILE) c = conn.cursor() try: if operation == 1: c.execute("PRAGMA key = '" + key + "';") c.execute("PRAGMA cipher_use_hmac = OFF;") c.execute("PRAGMA cipher_page_size = 1024;") c.execute("PRAGMA kdf_iter = 4000;") c.execute("ATTACH DATABASE '" + DECRYPTED_FILE + "' AS wechatdecrypted KEY '';") c.execute("SELECT sqlcipher_export( 'wechatdecrypted' );") c.execute("DETACH DATABASE wechatdecrypted;") else: c.execute("ATTACH DATABASE '" + ENCRYPTED_FILE_NEW + "' AS wechatencrypted KEY '" + key + "';") c.execute("PRAGMA wechatencrypted.cipher_use_hmac = OFF;") c.execute("PRAGMA wechatencrypted.cipher_page_size = 1024;") c.execute("PRAGMA wechatencrypted.kdf_iter = 4000;") c.execute("SELECT sqlcipher_export( 'wechatencrypted' );") c.execute("DETACH DATABASE wechatencrypted;") c.close() status = 1 except: c.close() status = 0 return status
def setUp(self): try: os.remove(get_db_path()) except OSError: pass self.con1 = sqlite.connect(get_db_path(), timeout=0.1) self.cur1 = self.con1.cursor() self.con2 = sqlite.connect(get_db_path(), timeout=0.1) self.cur2 = self.con2.cursor()
def init_db(): # Initialize in-memory database app_db = sqlcipher.connect(':memory:', check_same_thread = False) # Connect to disk-based database and use key db = sqlcipher.connect(app.config['DB']) db.executescript('pragma key = "{}"'.format(app.config['KEY'])) # Copy database to memory app_db.executescript(''.join(line for line in db.iterdump())) return app_db
def CheckFailedOpen(self): YOU_CANNOT_OPEN_THIS = "/foo/bar/bla/23534/mydb.db" try: con = sqlite.connect(YOU_CANNOT_OPEN_THIS) except sqlite.OperationalError: return self.fail("should have raised an OperationalError")
def CheckAutoCommit(self): """ Verifies that creating a connection in autocommit mode works. 2.5.3 introduced a regression so that these could no longer be created. """ con = sqlite.connect(":memory:", isolation_level=None)
def CheckSetIsolationLevel(self): """ See issue 3312. """ con = sqlite.connect(":memory:") self.assertRaises(UnicodeEncodeError, setattr, con, "isolation_level", u"\xe9")
def encrypt(args): print print yellow('Generating key...') key = _generate_key(args.imei, args.uin) print print green('=' * 80) print green('The key is:') print print cyan(' %s' % key) print print yellow('Encrypting, hang on...') _delete_file_if_exists(args.output_file) conn = sqlite.connect(args.input_file) c = conn.cursor() try: c.execute('PRAGMA cipher_default_use_hmac = OFF;') c.execute('ATTACH DATABASE \'%s\' AS encrypted KEY \'%s\';' % (args.output_file, key)) c.execute('PRAGMA cipher_use_hmac = OFF;') c.execute('SELECT sqlcipher_export(\'encrypted\');') c.execute('DETACH DATABASE encrypted;') except: print print red('=' * 80) print red('An error occurred.') sys.exit(1) else: print print green('=' * 80) print green('Success!') finally: c.close()
def db_connect(password): db = dbapi2.connect(path(app.config['DB_NAME'])) # TODO: Use something better than re.escape for this # For some reason, normal '?' placeholders don't work for PRAGMA's db.execute("PRAGMA key = '%s'" % re.escape(password)) db.execute("PRAGMA foreign_keys = ON") return db
def setUp(self): self.cx = sqlite.connect(":memory:") self.cx.execute("create table test(id integer primary key, blob_col blob)") self.blob_data = "a" * 100 self.cx.execute("insert into test(blob_col) values (?)", (self.blob_data, )) self.blob = self.cx.blob("test", "blob_col", 1, 1) self.second_data = "b" * 100
def main(): argv = sys.argv if len(argv) != 4: print 'usage: python desql.py encrypted_file password decrypted_file' return encrypted_file = argv[1] password = argv[2] decrypted_file = argv[3] conn = sqlite.connect(encrypted_file) c = conn.cursor() try: c.execute("PRAGMA key = '" + password + "';") c.execute("PRAGMA cipher_use_hmac = OFF;") c.execute("PRAGMA cipher_page_size = 1024;") c.execute("PRAGMA kdf_iter = 4000;") c.execute("ATTACH DATABASE '" + decrypted_file + "' AS wechatdecrypted KEY '';") c.execute("SELECT sqlcipher_export( 'wechatdecrypted' );") c.execute("DETACH DATABASE wechatdecrypted;") c.close() print 'Decrypt Success!' except: c.close() os.remove(decrypted_file) print 'Decrypt Error!' print 'Exception:' print traceback.format_exc()
def _open_database(cls, sqlite_file, password, document_factory=None, soledad=None): if not os.path.isfile(sqlite_file): raise errors.DatabaseDoesNotExist() tries = 2 while True: # Note: There seems to be a bug in sqlite 3.5.9 (with python2.6) # where without re-opening the database on Windows, it # doesn't see the transaction that was just committed db_handle = dbapi2.connect(sqlite_file) SQLCipherDatabase.set_pragma_key(db_handle, password) c = db_handle.cursor() v, err = cls._which_index_storage(c) db_handle.close() if v is not None: break # possibly another process is initializing it, wait for it to be # done if tries == 0: raise err # go for the richest error? tries -= 1 time.sleep(cls.WAIT_FOR_PARALLEL_INIT_HALF_INTERVAL) return SQLCipherDatabase._sqlite_registry[v]( sqlite_file, password, document_factory=document_factory, soledad=soledad)
def init_cuppoc_db(): ''' Use pysqlcipher to create an encrypted targets.db or open the existing one with the correct key. ''' while True: print("NOTE:") print("[!] Checking to see if \"targets.db\" exists or not.") print("[!] If it doesn't, cuppoc will make one.") print("[!] cuppoc uses AES256 to encrypt your local database.") print("[!] This is due to Personally Identifiable Information (PII)") print("[!] which will be stored in the database.\n") print("[!] You will be asked to enter a password.") print("[!] This password is the key to your database. Don't forget :P") print("[!] If you have already done this before,") print("[!] Then please use the password you used before.") db = sqlite.connect("./targets.db") cursor = db.cursor() user_key = raw_input("> Please enter the password for database: ") cursor.execute("PRAGMA key='%s'" % user_key) try: cursor.execute("CREATE TABLE IF NOT EXISTS Targets (" + "ID INTEGER PRIMARY KEY," + "First_Name TEXT," + "Last_Name TEXT)") print("[+] Done... Starting cuppoc!") print_separator() sleep(3) break except PYSQLDBERR: print("[-] Database doesn't exist or is encrypted.") print("[-] If database exists, enter the correct password.") print_separator() db.close() sys.exit(0) return [db, cursor]
def setUp(self): self.cx = sqlite.connect(":memory:") self.cu = self.cx.cursor() self.cu.execute( "create table test(id integer primary key, name text, income number)" ) self.cu.execute("insert into test(name) values (?)", ("foo", ))
def CheckConnectionExecutemany(self): con = sqlite.connect(":memory:") con.execute("create table test(foo)") con.executemany("insert into test(foo) values (?)", [(3,), (4,)]) result = con.execute("select foo from test order by foo").fetchall() self.assertEqual(result[0][0], 3, "Basic test of Connection.executemany") self.assertEqual(result[1][0], 4, "Basic test of Connection.executemany")
def CheckCreateCollationNotCallable(self): con = sqlite.connect(":memory:") try: con.create_collation("X", 42) self.fail("should have raised a TypeError") except TypeError, e: self.assertEqual(e.args[0], "parameter must be callable")
def __GET_STATUS(self): status = "" try: conn = sqlite3.connect( path_constants.installation + '/stats.db', timeout=10) except: pass try: cur = conn.cursor() cur.execute("PRAGMA key='f$$pm->>>'") status = cur.execute("select error from errors where ptid='%s' and accession='%s' and series='%s'" % (self.__patient.ID, self.__patient.AccessionNumber, self.__patient.SeriesDescription)).fetchall()[0][0] conn.close() except IndexError: print "Not processed before." conn.close() except Exception as exc: print "Problem reading status: %s" % exc conn.close() if(status and (re.findall("error", status, flags=re.IGNORECASE) or re.findall("problem", status, flags=re.IGNORECASE))): print "Already processed, but with errors." self.__set_state(STATES.FS) elif(status and re.findall("Already processed", status, flags=re.IGNORECASE)): print "Already processed without errors, but attempted reprocessed before." self.__set_state(STATES.FS) # Not procssed elif(not status): self.__set_state(STATES.FS) else: self.__success = "Already processed." self.__set_state(STATES.QUITTING)
def CheckCreateCollationNotAscii(self): con = sqlite.connect(":memory:") try: con.create_collation("collä", cmp) self.fail("should have raised a ProgrammingError") except sqlite.ProgrammingError, e: pass
def CheckCollationIsUsed(self): if sqlite.version_info < (3, 2, 1): # old SQLite versions crash on this test return def mycoll(x, y): # reverse order return -cmp(x, y) con = sqlite.connect(":memory:") con.create_collation("mycoll", mycoll) sql = """ select x from ( select 'a' as x union select 'b' as x union select 'c' as x ) order by x collate mycoll """ result = con.execute(sql).fetchall() if result[0][0] != "c" or result[1][0] != "b" or result[2][0] != "a": self.fail("the expected order was not returned") con.create_collation("mycoll", None) try: result = con.execute(sql).fetchall() self.fail("should have raised an OperationalError") except sqlite.OperationalError, e: self.assertEqual(e.args[0].lower(), "no such collation sequence: mycoll")
def _connect(self): params = dict(self.connect_params) passphrase = params.pop('passphrase', '') kdf_iter = params.pop('kdf_iter', 64000) if len(passphrase) < 8: raise ImproperlyConfigured( 'SqlCipherDatabase passphrase should be at least eight ' 'character long.') if kdf_iter and kdf_iter < 10000: raise ImproperlyConfigured( 'SqlCipherDatabase kdf_iter should be at least 10000.') conn = sqlcipher.connect(self.database, **params) conn.isolation_level = None try: self._add_conn_hooks(conn) conn.execute( 'PRAGMA key=\'{0}\''.format(passphrase.replace("'", "''"))) conn.execute('PRAGMA kdf_iter={0:d}'.format(kdf_iter)) except: conn.close() raise else: return conn
def decrypt(key): if not key: print('key is empty!!!') sys.exit(-1) print('password is {}!'.format(key)) for name in os.listdir('.'): if os.path.splitext(name)[1] == '.db': conn = sqlite.connect(name) c = conn.cursor() try: c.execute("PRAGMA key = '{}';".format(key)) c.execute("PRAGMA cipher_page_size = 1024;") c.execute("PRAGMA kdf_iter = 4000;") c.execute("PRAGMA cipher_hmac_algorithm = HMAC_SHA1;") c.execute("PRAGMA cipher_kdf_algorithm = PBKDF2_HMAC_SHA1;") c.execute("PRAGMA cipher_use_hmac = OFF;") c.execute("ATTACH DATABASE '{}' AS plaintext KEY '';".format( 'decrypt-' + name)) c.execute("SELECT sqlcipher_export('plaintext');") c.execute("DETACH DATABASE plaintext;") conn.commit() c.close() except Exception as e: print(repr(e)) print('An error occurred!!!') print('The possible reason is the wrong password?') sys.exit(-1) finally: c.close()
def getDecryptFile(db, key, fileIn, fileOut ): status = False if not os.path.isfile(fileOut): # # code source: http://articles.forensicfocus.com/2014/10/01/decrypt-wechat-enmicromsgdb-database/ # conn = sqlite3.connect( u'%s' % fileIn ) conn.row_factory = sqlite3.Row cur = conn.cursor() if setDecryptParams(cur, key): try: print( u'Decrypting...' ) cur.execute( 'ATTACH DATABASE "%s" AS wechatdecrypted KEY "";' % fileOut) cur.execute( 'SELECT sqlcipher_export( "wechatdecrypted" );' ) cur.execute( 'DETACH DATABASE wechatdecrypted;' ) print( u'Detaching database...' ) cur.close() status = True except: print(u'Decrypting failed!') pass cur.close() return(status)
def getFuncTemplate(db, decrypted=True, key=None): results = [] # Create query query = 'SELECT * FROM friend_ext;' # Open database, set up cursor to read database conn = sqlite3.connect(db) conn.row_factory = sqlite3.Row cur = conn.cursor() if not decrypted: if not setDecryptParams(cur, key): cur.close() return(result) # Execute query cur.execute(query) try: for index, row in enumerate(cur): pass except: pass cur.close() return(results)
def CheckClosed(self): con = sqlite.connect(":memory:") cur = con.cursor() cur.close() for method_name in ("execute", "executemany", "executescript", "fetchall", "fetchmany", "fetchone"): if method_name in ("execute", "executescript"): params = ("select 4 union select 5", ) elif method_name == "executemany": params = ("insert into foo(bar) values (?)", [(3, ), (4, )]) else: params = [] try: method = getattr(cur, method_name) method(*params) self.fail("Should have raised a ProgrammingError: method " + method_name) except sqlite.ProgrammingError: pass except: self.fail("Should have raised a ProgrammingError: " + method_name)
def test__open_database_during_init(self): temp_dir = self.createTempDir(prefix='u1db-test-') path = temp_dir + '/initialised.db' db = SQLCipherDatabase.__new__( SQLCipherDatabase) db._db_handle = dbapi2.connect(path) # db is there but not yet init-ed db._syncers = {} c = db._db_handle.cursor() c.execute('PRAGMA key="%s"' % PASSWORD) self.addCleanup(db.close) observed = [] class SQLiteDatabaseTesting(SQLCipherDatabase): WAIT_FOR_PARALLEL_INIT_HALF_INTERVAL = 0.1 @classmethod def _which_index_storage(cls, c): res = SQLCipherDatabase._which_index_storage(c) db._ensure_schema() # init db observed.append(res[0]) return res db2 = SQLiteDatabaseTesting._open_database(path, PASSWORD) self.addCleanup(db2.close) self.assertIsInstance(db2, SQLCipherDatabase) self.assertEqual( [None, SQLCipherDatabase._index_storage_value], observed)
def _connect(self): params = dict(self.connect_params) passphrase = params.pop('passphrase', '') kdf_iter = params.pop('kdf_iter', 64000) if len(passphrase) < 8: raise ImproperlyConfigured( 'SqlCipherDatabase passphrase should be at least eight ' 'character long.') if kdf_iter and kdf_iter < 10000: raise ImproperlyConfigured( 'SqlCipherDatabase kdf_iter should be at least 10000.') conn = sqlcipher.connect(self.database, **params) conn.isolation_level = None try: conn.execute( 'PRAGMA key=\'{0}\''.format(passphrase.replace("'", "''"))) conn.execute('PRAGMA kdf_iter={0:d}'.format(kdf_iter)) self._add_conn_hooks(conn) except: conn.close() raise else: return conn
def _decrpyt(src, dst, key, cipher, kdf_iter, cipher_page_size): conn = sqlite.connect(src) c = conn.cursor() c.execute("PRAGMA key='{0}'".format(key)) if kdf_iter is not None: c.execute("PRAGMA kdf_iter={0}".format(kdf_iter)) if cipher is not None: c.execute("PRAGMA cipher='{0}'".format(cipher)) if cipher_page_size is not None: c.execute("PRAGMA cipher_page_size={0}".format(cipher_page_size)) c.close() c = conn.cursor() try: c.execute('SELECT COUNT(*) from sqlite_master') count = c.fetchone()[0] except sqlite.DatabaseError as ex: print('wrong key: {0}'.format(ex)) sys.exit(1) finally: c.close() c = conn.cursor() c.execute("ATTACH DATABASE '{0}' AS plaintext KEY ''".format(dst)) c.execute("SELECT sqlcipher_export('plaintext');") c.execute("DETACH DATABASE plaintext") c.close()
def setUp(self): self.con = sqlite.connect(":memory:") cur = self.con.cursor() cur.execute(""" create table test( t text, i integer, f float, n, b blob ) """) cur.execute("insert into test(t, i, f, n, b) values (?, ?, ?, ?, ?)", ( "foo", 5, 3.14, None, buffer("blob"), )) self.con.create_aggregate("nostep", 1, AggrNoStep) self.con.create_aggregate("nofinalize", 1, AggrNoFinalize) self.con.create_aggregate("excInit", 1, AggrExceptionInInit) self.con.create_aggregate("excStep", 1, AggrExceptionInStep) self.con.create_aggregate("excFinalize", 1, AggrExceptionInFinalize) self.con.create_aggregate("checkType", 2, AggrCheckType) self.con.create_aggregate("mysum", 1, AggrSum)
def __init__(self, sqlite_file, password, document_factory=None, soledad=None): """Create a new sqlcipher file.""" self._check_if_db_is_encrypted(sqlite_file) self._db_handle = dbapi2.connect(sqlite_file) SQLCipherDatabase.set_pragma_key(self._db_handle, password) self._real_replica_uid = None self._ensure_schema() self._soledad = soledad def factory(doc_id=None, rev=None, json='{}', has_conflicts=False, encrypted_json=None, syncable=True): return LeapDocument(doc_id=doc_id, rev=rev, json=json, has_conflicts=has_conflicts, encrypted_json=encrypted_json, syncable=syncable, soledad=self._soledad) self.set_document_factory(factory)
def test__open_database_during_init(self): temp_dir = self.createTempDir(prefix='u1db-test-') path = temp_dir + '/initialised.db' db = sqlite_backend.SQLitePartialExpandDatabase.__new__( sqlite_backend.SQLitePartialExpandDatabase) db._db_handle = dbapi2.connect(path) # db is there but not yet init-ed self.addCleanup(db.close) observed = [] class SQLiteDatabaseTesting(sqlite_backend.SQLiteDatabase): WAIT_FOR_PARALLEL_INIT_HALF_INTERVAL = 0.1 @classmethod def _which_index_storage(cls, c): res = super(SQLiteDatabaseTesting, cls)._which_index_storage(c) db._ensure_schema() # init db observed.append(res[0]) return res db2 = SQLiteDatabaseTesting._open_database(path) self.addCleanup(db2.close) self.assertIsInstance(db2, sqlite_backend.SQLitePartialExpandDatabase) self.assertEqual( [None, sqlite_backend.SQLitePartialExpandDatabase._index_storage_value], observed)
def test__open_database_during_init(self): temp_dir = self.createTempDir(prefix='u1db-test-') path = temp_dir + '/initialised.db' db = sqlite_backend.SQLitePartialExpandDatabase.__new__( sqlite_backend.SQLitePartialExpandDatabase) db._db_handle = dbapi2.connect(path) # db is there but not yet init-ed self.addCleanup(db.close) observed = [] class SQLiteDatabaseTesting(sqlite_backend.SQLiteDatabase): WAIT_FOR_PARALLEL_INIT_HALF_INTERVAL = 0.1 @classmethod def _which_index_storage(cls, c): res = super(SQLiteDatabaseTesting, cls)._which_index_storage(c) db._ensure_schema() # init db observed.append(res[0]) return res db2 = SQLiteDatabaseTesting._open_database(path) self.addCleanup(db2.close) self.assertIsInstance(db2, sqlite_backend.SQLitePartialExpandDatabase) self.assertEqual([ None, sqlite_backend.SQLitePartialExpandDatabase._index_storage_value ], observed)
def setUp(self): self.con = sqlite.connect(":memory:") try: del sqlite.adapters[int] except: pass sqlite.register_adapter(int, ObjectAdaptationTests.cast) self.cur = self.con.cursor()
def get_all_users(table): try: db = sqlcipher.connect("users.db") db.executescript('pragma key="testing"; pragma kdf_iter=64000;') row = db.execute("select * from " + table).fetchall() return row finally: db.close()
def connect(self, *args, **kwargs): if not self._connection: self._connection = sqlite.connect(*args, **kwargs) #return Status(status=True) #return None #p("NEW CONNECTION WAS ESTABL. {}, {}".format(inspect.stack()[-18][3], args[0]), c="g") return self else: raise ZASConnectionError, "Connection is already exist!"
def have_usleep(): fname = tempfile.mktemp() db = dbapi2.connect(fname) cursor = db.cursor() cursor.execute('PRAGMA compile_options;') options = map(lambda t: t[0], cursor.fetchall()) db.close() os.unlink(fname) return u'HAVE_USLEEP' in options
def queryCDR(id): db = sqlcipher.connect(app.config['db']) id = tuple([id]) db.executescript('pragma key = "%s" ' % app.config['key']) results = db.execute('select * from terms where id like ?', id).fetchall() db.close() return results
def CheckScriptErrorNormal(self): con = sqlite.connect(":memory:") cur = con.cursor() raised = False try: cur.executescript("create table test(sadfsadfdsa); select foo from hurz;") except sqlite.OperationalError: raised = True self.assertEqual(raised, True, "should have raised an exception")
def get_random_user(table): try: db = sqlcipher.connect("users.db") db.executescript('pragma key="testing"; pragma kdf_iter=64000;') row = db.execute('SELECT * FROM ' + table + ' ORDER BY RANDOM() LIMIT 1;').fetchall() return row[0] finally: db.close()
def get_selected_user(table, user): try: db = sqlcipher.connect("users.db") db.executescript('pragma key="testing"; pragma kdf_iter=64000;') row = db.execute("select * from " + table + " where usr like '" + user + "' LIMIT 1").fetchall() return row[0] finally: db.close()
def getEntries(db, password): """Get everything in the database. Used a lot in testing stuff after insertions and deletions.""" conn = sqlite.connect(db) c = conn.cursor() c.execute("PRAGMA key='{}'".format(password)) entries = c.execute("SELECT * FROM entries").fetchall() c.close() conn.close() return entries
def setUp(self): self.con = sqlite.connect(":memory:", detect_types=sqlite.PARSE_COLNAMES) self.cur = self.con.cursor() self.cur.execute("create table test(x foo)") sqlite.converters["FOO"] = lambda x: "[%s]" % x sqlite.converters["BAR"] = lambda x: "<%s>" % x sqlite.converters["EXC"] = lambda x: 5 // 0 sqlite.converters["B1B1"] = lambda x: "MARKER"
def CheckPragmaSchemaVersion(self): # This still crashed pysqlite <= 2.2.1 con = sqlite.connect(":memory:", detect_types=sqlite.PARSE_COLNAMES) try: cur = self.con.cursor() cur.execute("pragma schema_version") finally: cur.close() con.close()
def CheckScriptSyntaxError(self): con = sqlite.connect(":memory:") cur = con.cursor() raised = False try: cur.executescript("create table test(x); asdf; create table test2(x)") except sqlite.OperationalError: raised = True self.assertEqual(raised, True, "should have raised an exception")
def CheckConnectionExecutemany(self): con = sqlite.connect(":memory:") con.execute("create table test(foo)") con.executemany("insert into test(foo) values (?)", [(3, ), (4, )]) result = con.execute("select foo from test order by foo").fetchall() self.assertEqual(result[0][0], 3, "Basic test of Connection.executemany") self.assertEqual(result[1][0], 4, "Basic test of Connection.executemany")
def openDBFile(self): fileExists = os.path.isfile(self.filename) self.connection = dbapi2.connect(self.filename) self.cursor = self.connection.cursor() self.cursor.execute("PRAGMA KEY = '" + self.key + "';") if not fileExists: self.cursor.execute("CREATE TABLE testvalid(nothing);") self.cursor.execute("CREATE TABLE log(name NOT NULL, personType NOT NULL, direction NOT NULL, time INTEGER NOT NULL, room integer);") self.cursor.execute("CREATE TABLE status(name NOT NULL, personType NOT NULL, isHere NOT NULL DEFAULT 'f', currentRoom integer, enterTime INTEGER, exitTime INTEGER);")
def open(self): fileExists = os.path.isfile(self.file) self.connection = sqlite.connect(self.file) self.cursor = self.connection.cursor() self.cursor.execute("PRAGMA KEY = '" + self.key + "';") self.cursor.execute("PRAGMA case_sensitive_like=ON;") if not fileExists: self.cursor.execute("CREATE TABLE testvalid(nothing);") self.cursor.execute("CREATE TABLE log(name NOT NULL, role NOT NULL, direction NOT NULL, room_id integer, time integer NOT NULL);") self.cursor.execute("CREATE TABLE status(name NOT NULL, role NOT NULL, is_here NOT NULL DEFAULT 0, cur_room integer, enter_time integer, accumulated_time NOT NULL DEFAULT 0);")
def emptyEntries(db, password): """Empty the entries table. Clean table required for each test.""" conn = sqlite.connect(db) c = conn.cursor() c.execute("PRAGMA key='{}'".format(password)) c.execute("""DELETE FROM entries""") conn.commit() c.close() conn.close() return