FilesExpand file tree

 master

/

sqlcipher.test.js

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

110 lines (90 loc) · 3.23 KB

 master

/

sqlcipher.test.js

Copy path

Top

File metadata and controls

• Code
• Blame

110 lines (90 loc) · 3.23 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

var sqlite3 = require('..');

var assert = require('assert');

var fs = require('fs');

var helper = require('./support/helper');

describe('sqlcipher', function() {

before(function() {

helper.ensureExists('test/tmp');

});

before(function() {

helper.deleteFile('test/tmp/test_create.db.enc');

});

var db;

it('should open the database', function(done) {

db = new sqlite3.Database('test/tmp/test_create.db.enc', done);

});

it('should enable encryption', function(done) {

db.run("PRAGMA key = 'mysecret'", done);

});

it("should use openssl", function(done) {

db.get("PRAGMA cipher_provider", (err, result) => {

assert.deepEqual(result, { cipher_provider: 'openssl' });

done(err);

});

});

it('should create a table', function(done) {

db.run("CREATE TABLE foo (id INT, num INT)", done);

});

it('should insert data', function(done) {

var stmt = db.prepare("INSERT INTO foo (id, num) VALUES (?, ?)");

stmt.run(1, 2, function() {

stmt.finalize();

done();

});

});

it('should read the table', function(done) {

db.run("SELECT * FROM foo", done);

});

it('should close the database', function(done) {

db.close(done);

});

it('should have created the file', function() {

assert.fileExists('test/tmp/test_create.db.enc');

});

it("should not be plaintext", function(done) {

const buffer = fs.readFileSync("test/tmp/test_create.db.enc");

const sqliteMagic = "SQLite format 3";

const actual = buffer.slice(0, sqliteMagic.length).toString("utf8");

if (actual == sqliteMagic) {

// The file contains the header in plain-text.

// This means it's definitely not encrypted.

done(new Error("The database is not encrypted!"));

} else {

// Not necessarily encrypted, but at least we did a basic check.

done();

}

});

it('should open the database without a key', function(done) {

db = new sqlite3.Database('test/tmp/test_create.db.enc', done);

});

it('should fail to read a table', function(done) {

db.run("SELECT * FROM foo", function(err) {

if (err) {

assert.equal(err.message, 'SQLITE_NOTADB: file is not a database');

assert.equal(err.errno, sqlite3.NOTADB);

assert.equal(err.code, 'SQLITE_NOTADB');

done();

} else {

done(new Error('Completed query without error, but expected SQLITE_NOTADB'));

}

});

});

it('should close the database', function(done) {

db.close(done);

});

it('should open the database again', function(done) {

db = new sqlite3.Database('test/tmp/test_create.db.enc', done);

});

it('should set the same key', function(done) {

db.run("PRAGMA key = 'mysecret'", done);

});

it('should read the table', function(done) {

db.run("SELECT * FROM foo", done);

});

it('should close the database', function(done) {

db.close(done);

});

after(function() {

helper.deleteFile('test/tmp/test_create.db.enc');

});

});