@drifted/raven 0.0.11 → 0.0.13

package/index.js

@@ -1,14 +1,12 @@
 const path = require('path');
 const crypto = require('crypto');
 const fs = require('fs');
-const { fileTypeFromBuffer } = require('file-type');
 const ivLength = 16;
 const { Readable, pipeline, buffer } = require('stream');
 const Bufferable = require(path.join(__dirname, 'bufferable'));
-const { isUtf8, isAscii } = require('node:buffer');
 
-class RavenDataFile {
 
+class RavenDataFile {
 
   constructor(options={}) {
     Object.assign(this, options)
@@ -131,7 +129,10 @@ class RavenDataFile {
       });
     })
   }
- 
+
+  static createIV() {
+    return crypto.randomBytes(ivLength);
+  }
 
   static secret() {
     return crypto.randomBytes(32).toString('base64');
@@ -153,7 +154,6 @@ class RavenDataFile {
   }
 
   cipher(options={}) {
-    //console.log(options);
     return crypto.createCipheriv(options.algorithm, 
       Buffer.from(options.secret, 'base64'), 
       options.iv);
@@ -166,7 +166,7 @@ class RavenDataFile {
   }
 
   encrypt(buffer) {
-    const iv = crypto.randomBytes(ivLength);
+    const iv = RavenDataFile.createIV();
     const cipher = this.cipher({iv: iv, secret: this.secret, algorithm: this.algorithm});  
 
     var encrypted = cipher.update(buffer, 'utf8', 'hex');
@@ -199,9 +199,8 @@ class RavenDataFile {
       if (fs.existsSync(self.file) == false) {
         return reject(new Error('file doesnt exist.'))
       }
+      
       fs.readFile(self.file, {}, async (err, data) => {
-        //self.type = isAscii(data);
-        //console.log('type', self.type);
         self.data = data;      
         
         resolve(data);
@@ -230,33 +229,30 @@ class RavenDataFile {
   conceal() {
     var self = this;
     return new Promise(async(resolve) => {
-      const iv = crypto.randomBytes(ivLength);
+      const iv = RavenDataFile.createIV();
       const cipher = self.cipher({iv: iv, secret: self.secret, algorithm: self.algorithm});
 
-      //console.log(self);
-
-     self.read().then(async (buffer) => {
+      self.read().then(async (buffer) => {
         var readable = Readable.from(buffer)
-        const output = new Bufferable();
-        readable.pipe(cipher).pipe(output);
+        const collector = new Bufferable();
+        readable.pipe(cipher).pipe(collector);
 
-        output.on('finish', async() => {
+        collector.on('finish', async() => {
           const authTag = cipher.getAuthTag().toString('hex');    
-          var encrypted = output.buffer;
-
+          var encrypted = collector.buffer;
 
           fs.truncate(self.file, 0, () => {
-            const stream = fs.createWriteStream(self.file, { flags: 'a' });
-            stream.write(`${iv.toString('hex')}:${authTag}:`);
-            stream.write(encrypted.toString('base64'));
-            stream.end(); 
+            const destination = fs.createWriteStream(self.file, { flags: 'a' });
+            destination.write(`${iv.toString('hex')}:${authTag}:`);
+            destination.write(encrypted.toString('base64'));
+            destination.end(); 
 
-            stream.on('finish', () => {
+            destination.on('finish', () => {
               resolve({success: true});
             });
           })
         });
-     }) 
+      }) 
     })
   }
 
@@ -266,16 +262,17 @@ class RavenDataFile {
     return new Promise(async(resolve) => {
       self.read().then((buffer) => {
         const [ivHex, authTagHex, encryptedText] = buffer.toString().split(':');
-      
+
         var readable = Readable.from(Buffer.from(encryptedText, 'base64'))
-        const output = new Bufferable();
+        const collector = new Bufferable();
+        
         const decipher = self.decipher({iv:ivHex, secret: self.secret, algorithm: self.algorithm});
         decipher.setAuthTag(Buffer.from(authTagHex, 'hex'));
+        
+        readable.pipe(decipher).pipe(collector);
 
-        readable.pipe(decipher).pipe(output);
-
-        output.on('finish', () => {
-          self.data = output.buffer;
+        collector.on('finish', () => {
+          self.data = collector.buffer;
 
           self.save().then(() => {
             resolve({success: true});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drifted/raven",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "",
   "homepage": "https://github.com/driftless-group/raven",
   "bin": {

package/test/cli.test.js

@@ -22,11 +22,9 @@ describe('raven', function() {
   before(async() => {
     var file = path.join(__dirname, 'data', '1984.pdf');
     var encrypted = path.join(__dirname, 'data','1984.pdf.encrypted');
-
     if (fs.existsSync(encrypted)) {
       await remove(encrypted)
-    }
-
+    } 
     await copy(file, encrypted); 
   })
 
@@ -156,6 +154,7 @@ describe('raven', function() {
 
       run('conceal', '-f', encrypted, '-s', secret).then(() => {
         compare(original, encrypted).then((response) => {
+          //console.log(response);
           assert.equal(response.equal, false);
 
           run('expose', '-f', encrypted, '-s', secret).then(() => {

package/test/helpers.js

@@ -73,13 +73,15 @@ function compare(file1, file2) {
 
   return new Promise((resolve, reject) => {
     if (fs.statSync(file1).size !== fs.statSync(file2).size) {
-      response.equal = true;
+      response.equal = false;
+      response.reason = 'size';
       return resolve(response)
     } else {
       const hash1 = crypto.createHash('sha256').update(fs.readFileSync(file1)).digest('hex');
       const hash2 = crypto.createHash('sha256').update(fs.readFileSync(file2)).digest('hex');
       
       if (hash1 !== hash2) {
+        response.reason = 'hash';
         response.equal = false;
         resolve(response);
       } else {