cloudron 5.6.2 → 5.7.1

package/bin/cloudron

@@ -53,7 +53,7 @@ backupCommand.command('list')
     .option('--app <id>', 'App id')
     .action(actions.backupList);
 
-backupCommand.command('decrypt <file>')
+backupCommand.command('decrypt <infile> <outfile>')
     .description('Decrypt an encrypted file')
     .option('--password <password>', 'password')
     .action(backupTools.decrypt);
@@ -68,7 +68,7 @@ backupCommand.command('decrypt-filename <path>')
     .option('--password <password>', 'password')
     .action(backupTools.decryptFilename);
 
-backupCommand.command('encrypt <input>')
+backupCommand.command('encrypt <infile> <outfile>')
     .description('Encrypt a file')
     .option('--password <password>', 'password')
     .action(backupTools.encrypt);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudron",
-  "version": "5.6.2",
+  "version": "5.7.1",
   "license": "MIT",
   "description": "Cloudron Commandline Tool",
   "main": "main.js",

package/src/actions.js

@@ -1526,6 +1526,8 @@ function init(localOptions, cmd) {
         fs.chmodSync('start.sh', 0o0775);
     }
 
+    fs.copyFileSync(path.join(__dirname, 'templates/', 'logo.png'), 'logo.png');
+
     if (options.appstore) {
         if (!fs.existsSync('.gitignore')) fs.writeFileSync('.gitignore', 'node_modules/\n', 'utf8');
         if (!fs.existsSync('DESCRIPTION.md')) fs.writeFileSync('DESCRIPTION.md', '## About\n\nThis app changes everything\n\n', 'utf8');

package/src/backup-tools.js

@@ -18,6 +18,7 @@ const assert = require('assert'),
     path = require('path'),
     readlinePromises = require('readline/promises'),
     safe = require('safetydance'),
+    stream = require('stream/promises'),
     TransformStream = require('stream').Transform;
 
 function encryptFilePath(filePath, encryption) {
@@ -25,7 +26,7 @@ function encryptFilePath(filePath, encryption) {
     assert.strictEqual(typeof encryption, 'object');
 
     const encryptedParts = filePath.split('/').map(function (part) {
-        let hmac = crypto.createHmac('sha256', Buffer.from(encryption.filenameHmacKey, 'hex'));
+        const hmac = crypto.createHmac('sha256', Buffer.from(encryption.filenameHmacKey, 'hex'));
         const iv = hmac.update(part).digest().subarray(0, 16); // iv has to be deterministic, for our sync (copy) logic to work
         const cipher = crypto.createCipheriv('aes-256-cbc', Buffer.from(encryption.filenameKey, 'hex'), iv);
         let crypt = cipher.update(part);
@@ -193,24 +194,23 @@ function aesKeysFromPassword(password) {
     };
 }
 
-async function encrypt(input, options) {
+async function encrypt(infile, outfile, options) {
+    if (!fs.existsSync(infile)) return exit(`Could not open ${infile}`);
+
     if (!options.password) {
         const rl = readlinePromises.createInterface({ input: process.stdin, output: process.stdout });
-        options.password = rl.question('Enter encryption password: ');
+        options.password = await rl.question('Enter encryption password: ');
         rl.close();
         if (!options.password) return exit('--password is needed');
     }
 
     const encryption = aesKeysFromPassword(options.password);
-
-    const inStream = fs.createReadStream(input);
-    const outStream = process.stdout;
+    const inStream = fs.createReadStream(infile);
+    const outStream = outfile === '-' ? process.stdout : fs.createWriteStream(outfile);
     const encryptStream = new EncryptStream(encryption);
 
-    inStream.on('error', exit);
-    encryptStream.on('error', exit);
-
-    inStream.pipe(encryptStream).pipe(outStream);
+    const [encryptError] = await safe(stream.pipeline(inStream, encryptStream, outStream));
+    if (encryptError) return exit(`Could not encrypt: ${encryptError.message}`);
 }
 
 async function encryptFilename(filePath, options) {
@@ -226,7 +226,14 @@ async function encryptFilename(filePath, options) {
     console.log(encryptFilePath(filePath, encryption));
 }
 
-async function decrypt(input, options) {
+async function decrypt(infile, outfile, options) {
+    const fd = safe.fs.openSync(infile, 'r'); // returns a number!
+    if (!fd || fd === -1) return exit(`Could not open ${infile} for read: ${safe.error.message}`);
+    const header = Buffer.alloc(4);
+    if (!safe.fs.readSync(fd, header, 0, 4, 0)) return exit(safe.error);
+    if (!header.equals(Buffer.from('CBV2'))) return exit('Legacy stream decryption not implemented yet');
+    safe.fs.closeSync(fd);
+
     if (!options.password) {
         const rl = readlinePromises.createInterface({ input: process.stdin, output: process.stdout });
         options.password = await rl.question('Enter encryption password: ');
@@ -234,23 +241,17 @@ async function decrypt(input, options) {
         if (!options.password) return exit('--password is needed');
     }
 
-    const fd = safe.fs.openSync(input, 'r');
-    if (!fd) return exit(safe.error);
-    let header = Buffer.alloc(4);
-    if (!safe.fs.readSync(fd, header, 0, 4, 0)) return exit(safe.error);
-    if (!header.equals(Buffer.from('CBV2'))) return exit('Legacy stream decryption not implemented yet');
-    safe.fs.closeSync(fd);
-
     const encryption = aesKeysFromPassword(options.password);
 
-    const inStream = fs.createReadStream(input);
-    const outStream = process.stdout;
+    const inStream = fs.createReadStream(infile);
+    const outStream = outfile === '-' ? process.stdout : fs.createWriteStream(outfile);
     const decryptStream = new DecryptStream(encryption);
 
-    inStream.on('error', exit);
-    decryptStream.on('error', exit);
-
-    inStream.pipe(decryptStream).pipe(outStream);
+    const [decryptError] = await safe(stream.pipeline(inStream, decryptStream, outStream));
+    if (decryptError) {
+        safe.fs.rmSync(outfile);
+        return exit(`Could not decrypt: ${decryptError.message}`);
+    }
 }
 
 async function decryptDir(inDir, outDir, options) {
@@ -266,31 +267,37 @@ async function decryptDir(inDir, outDir, options) {
     const inDirAbs = path.resolve(process.cwd(), inDir);
     const outDirAbs = path.resolve(process.cwd(), outDir);
 
-    let tbd = [ '' ]; // only has paths relative to inDirAbs
+    const tbd = [ '' ]; // only has paths relative to inDirAbs
     async.whilst((done) => done(null, tbd.length !== 0), function iteratee(whilstCallback) {
         const cur = tbd.pop();
         const entries = fs.readdirSync(path.join(inDirAbs, cur), { withFileTypes: true });
-        async.eachSeries(entries, function (entry, iteratorCallback) {
+        async.eachSeries(entries, async function (entry) {
             if (entry.isDirectory()) {
                 tbd.push(path.join(cur, entry.name));
-                return iteratorCallback();
+                return;
             } else if (!entry.isFile()) {
-                return iteratorCallback();
+                return;
             }
 
             const encryptedFilePath = path.join(cur, entry.name);
-            const { error, decryptedFilePath } = decryptFilePath(encryptedFilePath, encryption);
-            if (error) return iteratorCallback(error);
 
-            let inStream = fs.createReadStream(path.join(inDirAbs, cur, entry.name));
-            fs.mkdirSync(path.dirname(path.join(outDirAbs, decryptedFilePath)), { recursive: true });
-            let outStream = fs.createWriteStream(path.join(outDirAbs, decryptedFilePath));
-            let decryptStream = new DecryptStream(encryption);
+            const { error, decryptedFilePath } = decryptFilePath(encryptedFilePath, encryption);
+            if (error) throw error;
 
-            inStream.on('error', iteratorCallback);
-            decryptStream.on('error', iteratorCallback);
+            console.log(`Decrypting ${decryptedFilePath}`);
 
-            inStream.pipe(decryptStream).pipe(outStream).on('finish', iteratorCallback);
+            const infile = path.join(inDirAbs, cur, entry.name);
+            const inStream = fs.createReadStream(infile);
+            fs.mkdirSync(path.dirname(path.join(outDirAbs, decryptedFilePath)), { recursive: true });
+            const outfile = path.join(outDirAbs, decryptedFilePath);
+            const outStream = fs.createWriteStream(outfile);
+            const decryptStream = new DecryptStream(encryption);
+
+            const [decryptError] = await safe(stream.pipeline(inStream, decryptStream, outStream));
+            if (decryptError) {
+                safe.fs.rmSync(outfile);
+                throw new Error(`Could not decrypt ${infile}: ${decryptError.message}`);
+            }
         }, whilstCallback);
     }, exit);
 }

package/src/templates/dockerignore.ejs

@@ -2,4 +2,6 @@
 .gitignore
 .dockerignore
 node_modules
+screenshots
+test