From 51910b5fc9a6d951f47577dc51cd152c96d47e32 Mon Sep 17 00:00:00 2001 From: Abhinav Adduri Date: Thu, 1 Jun 2017 15:10:00 -0700 Subject: [PATCH] added browserify, refactored code to separate UI and network logic --- app.js | 111 ------- frontend/src/download.js | 132 +++++++++ frontend/src/file.js | 27 ++ frontend/src/main.js | 3 + frontend/src/upload.js | 142 +++++++++ package.json | 6 +- public/bundle.js | 614 +++++++++++++++++++++++++++++++++++++++ public/download.html | 2 +- public/download.js | 135 --------- public/file.js | 10 - public/index.html | 6 +- public/upload.js | 164 ----------- server/portal_server.js | 31 +- 13 files changed, 942 insertions(+), 441 deletions(-) delete mode 100644 app.js create mode 100644 frontend/src/download.js create mode 100644 frontend/src/file.js create mode 100644 frontend/src/main.js create mode 100644 frontend/src/upload.js create mode 100644 public/bundle.js delete mode 100644 public/download.js delete mode 100644 public/file.js delete mode 100644 public/upload.js diff --git a/app.js b/app.js deleted file mode 100644 index dcd8a9df..00000000 --- a/app.js +++ /dev/null @@ -1,111 +0,0 @@ -const express = require('express'); -const busboy = require('connect-busboy'); -const path = require('path'); -const fs = require('fs-extra'); -const bodyParser = require('body-parser'); -const crypto = require('crypto'); - -const app = express(); -const redis = require('redis'), client = redis.createClient(); - -client.on('error', function(err) { - console.log(err); -}); - -app.use(busboy()); -app.use(bodyParser.json()); -app.use(express.static(path.join(__dirname, 'public'))); - -app.get('/download/:id', function(req, res) { - res.sendFile(path.join(__dirname + '/public/download.html')); -}); - -app.get('/assets/download/:id', function(req, res) { - let id = req.params.id; - if (!validateID(id)) { - res.send(404); - return; - } - - client.hget(id, 'filename', function(err, reply) { - // maybe some expiration logic too - if (!reply) { - res.sendStatus(404); - } else { - res.setHeader('Content-Disposition', 'attachment; filename=' + reply); - res.setHeader('Content-Type', 'application/octet-stream'); - - res.download(__dirname + '/static/' + id, reply, function(err) { - if (!err) { - client.del(id); - fs.unlinkSync(__dirname + '/static/' + id); - } - }); - } - }); -}); - -app.post('/delete/:id', function(req, res) { - let id = req.params.id; - - if (!validateID(id)) { - res.send(404); - return; - } - - let delete_token = req.body.delete_token; - - if (!delete_token) { - res.sendStatus(404); - } - - client.hget(id, 'delete', function(err, reply) { - if (!reply) { - res.sendStatus(404); - } else { - client.del(id); - fs.unlinkSync(__dirname + '/static/' + id); - res.sendStatus(200); - } - }); -}); - -app.post('/upload/:id', function(req, res, next) { - if (!validateID(req.params.id)) { - res.send(404); - return; - } - - var fstream; - req.pipe(req.busboy); - req.busboy.on('file', function(fieldname, file, filename) { - console.log('Uploading: ' + filename); - - //Path where image will be uploaded - fstream = fs.createWriteStream(__dirname + '/static/' + req.params.id); - file.pipe(fstream); - fstream.on('close', function() { - let id = req.params.id; - let uuid = crypto.randomBytes(10).toString('hex'); - - client.hmset([id, 'filename', filename, 'delete', uuid]); - - // delete the file off the server in 24 hours - // setTimeout(function() { - // fs.unlinkSync(__dirname + "/static/" + id); - // }, 86400000); - - client.expire(id, 86400000); - console.log('Upload Finished of ' + filename); - res.send(uuid); - }); - }); -}); - -app.listen(3000, function() { - console.log('Portal app listening on port 3000!'); -}); - -function validateID(route_id) { - return route_id.match(/^[0-9a-fA-F]{32}$/) !== null; -} diff --git a/frontend/src/download.js b/frontend/src/download.js new file mode 100644 index 00000000..43852d75 --- /dev/null +++ b/frontend/src/download.js @@ -0,0 +1,132 @@ +const UIWrapper = require('./file').UIWrapper; + +let download = () => { + + let xhr = new XMLHttpRequest(); + xhr.open("get", "/assets" + location.pathname.slice(0, -1), true); + xhr.responseType = "blob"; + + let listelem = setupUI(); + xhr.addEventListener("progress", updateProgress.bind(null, listelem)); + + xhr.onload = function(e) { + + // maybe send a separate request before this one to get the filename? + + // maybe render the html itself with the filename, since it's generated server side + // after a get request with the unique id + listelem.emit('name', xhr.getResponseHeader("Content-Disposition").match(/filename="(.+)"/)[1]); + + if (this.status == 200) { + let self = this; + let blob = new Blob([this.response]); + let arrayBuffer; + let fileReader = new FileReader(); + fileReader.onload = function() { + arrayBuffer = this.result; + let array = new Uint8Array(arrayBuffer); + salt = strToIv(location.pathname.slice(10, -1)); + + window.crypto.subtle.importKey( + "jwk", + { + kty: "oct", + k: location.hash.slice(1), + alg: "A128CBC", + ext: true, + }, + { + name: "AES-CBC", + }, + true, + ["encrypt", "decrypt"]) + .then((key) => { + return window.crypto.subtle.decrypt( + { + name: "AES-CBC", + iv: salt, + }, + key, + array) + }) + .then((decrypted) => { + let dataView = new DataView(decrypted); + let blob = new Blob([dataView]); + let downloadUrl = URL.createObjectURL(blob); + let a = document.createElement("a"); + a.href = downloadUrl; + a.download = xhr.getResponseHeader("Content-Disposition").match(/filename="(.+)"/)[1]; + document.body.appendChild(a); + a.click(); + }) + .catch((err) => { + alert("This link is either invalid or has expired, or the uploader has deleted the file."); + console.error(err); + }); + }; + + fileReader.readAsArrayBuffer(blob); + } else { + alert("This link is either invalid or has expired, or the uploader has deleted the file.") + } + }; + xhr.send(); +} + +window.download = download; + +let setupUI = () => { + let li = document.createElement("li"); + let name = document.createElement("p"); + li.appendChild(name); + + let progress = document.createElement("p"); + li.appendChild(progress); + + document.getElementById("downloaded_files").appendChild(li); + + return new UIWrapper(li, name, null, progress); +} + +let ivToStr = (iv) => { + let hexStr = ""; + for (let i in iv) { + if (iv[i] < 16) { + hexStr += "0" + iv[i].toString(16); + } else { + hexStr += iv[i].toString(16); + } + } + window.hexStr = hexStr; + return hexStr; +} + +let strToIv = (str) => { + let iv = new Uint8Array(16); + for (let i = 0; i < str.length; i += 2) { + iv[i/2] = parseInt((str.charAt(i) + str.charAt(i + 1)), 16); + } + + return iv; +} + +let updateProgress = (UIelem, e) => { + if (e.lengthComputable) { + let percentComplete = Math.floor((e.loaded / e.total) * 100); + UIelem.emit('progress', "Progress: " + percentComplete + "%"); + + if (percentComplete === 100) { + let finished = document.createElement("p"); + finished.innerText = "Your download has finished."; + UIelem.li.appendChild(finished); + + let close = document.createElement("button"); + close.innerText = "Ok"; + close.addEventListener("click", () => { + document.getElementById("downloaded_files").removeChild(UIelem.li); + }); + + UIelem.li.appendChild(close); + } + } +} \ No newline at end of file diff --git a/frontend/src/file.js b/frontend/src/file.js new file mode 100644 index 00000000..c581b1ca --- /dev/null +++ b/frontend/src/file.js @@ -0,0 +1,27 @@ +const EventEmitter = require('events'); + +class UIWrapper extends EventEmitter { + constructor(li, name, link, progress) { + super(); + this.li = li; + this.name = name; + this.link = link; + this.progress = progress; + + this.on("name", (filename) => { + this.name.innerText = filename; + }); + + this.on("link", (link) => { + this.link.innerText = link; + this.link.setAttribute('href', link); + }); + + this.on("progress", (progress) => { + this.progress.innerText = progress; + + }); + } +} + +exports.UIWrapper = UIWrapper; \ No newline at end of file diff --git a/frontend/src/main.js b/frontend/src/main.js new file mode 100644 index 00000000..23b00a19 --- /dev/null +++ b/frontend/src/main.js @@ -0,0 +1,3 @@ +require('./upload'); +require('./download'); +require('./file'); \ No newline at end of file diff --git a/frontend/src/upload.js b/frontend/src/upload.js new file mode 100644 index 00000000..df4d2eed --- /dev/null +++ b/frontend/src/upload.js @@ -0,0 +1,142 @@ +const EventEmitter = require('events'); +const UIWrapper = require('./file').UIWrapper; + +let onChange = (event) => { + let file = event.target.files[0]; + let reader = new FileReader(); + reader.readAsArrayBuffer(file); + + let random_iv = window.crypto.getRandomValues(new Uint8Array(16)); + let hex = ivToStr(random_iv); + + reader.onload = function(event) { + let self = this; + window.crypto.subtle.generateKey({ + name: "AES-CBC", + length: 128 + }, + true, + ["encrypt", "decrypt"]) + .then((key) => { + let arrayBuffer = self.result; + let array = new Uint8Array(arrayBuffer); + + window.crypto.subtle.encrypt({ + name: "AES-CBC", + iv: random_iv }, + key, + array) + .then(uploadFile.bind(null, file, hex, key)) + .catch((err) => console.error(err)); + + }).catch((err) => console.error(err)); + }; +} + +window.onChange = onChange; + +let uploadFile = (file, hex, key, encrypted) => { + let dataView = new DataView(encrypted); + let blob = new Blob([dataView], { type: file.type }); + + let fd = new FormData(); + fd.append("fname", file.name); + fd.append("data", blob, file.name); + + let xhr = new XMLHttpRequest(); + xhr.open("post", "/upload/" + hex, true); + + let listelem = setupUI(); + listelem.emit('name', file.name); + xhr.upload.addEventListener("progress", updateProgress.bind(null, listelem)); + + xhr.onreadystatechange = () => { + if (xhr.readyState == XMLHttpRequest.DONE) { + window.crypto.subtle.exportKey("jwk", key).then((keydata) => { + localStorage.setItem(hex, xhr.responseText); + + listelem.emit('link', "http://localhost:3000/download/" + hex + "/#" + keydata.k) + + console.log("Share this link with a friend: http://localhost:3000/download/" + hex + "/#" + keydata.k); + }) + } + }; + + xhr.send(fd); +} + +let updateProgress = (UIelem, e) => { + if (e.lengthComputable) { + let percentComplete = Math.floor((e.loaded / e.total) * 100); + UIelem.emit('progress', "Progress: " + percentComplete + "%") + + if (percentComplete === 100) { + let btn = document.createElement("button"); + btn.innerText = "Delete from server"; + btn.addEventListener("click", () => { + let segments = UIelem.link.innerText.split("/"); + let key = segments[segments.length - 2]; + + let xhr = new XMLHttpRequest(); + xhr.open("post", "/delete/" + key, true); + xhr.setRequestHeader("Content-Type", "application/json"); + if (!localStorage.getItem(key)) return; + + xhr.send(JSON.stringify({delete_token: localStorage.getItem(key)})); + + xhr.onreadystatechange = () => { + if (xhr.readyState === XMLHttpRequest.DONE) { + document.getElementById("uploaded_files").removeChild(UIelem.li); + localStorage.removeItem(key); + } + + if (xhr.status === 200) { + console.log("The file was successfully deleted."); + } else { + console.log("The file has expired, or has already been deleted."); + } + } + + }); + UIelem.li.appendChild(btn); + } + } +} + +let setupUI = () => { + let li = document.createElement("li"); + let name = document.createElement("p"); + li.appendChild(name); + + let link = document.createElement("a"); + li.appendChild(link); + + let progress = document.createElement("p"); + li.appendChild(progress); + + document.getElementById("uploaded_files").appendChild(li); + + return new UIWrapper(li, name, link, progress); +} + +let ivToStr = (iv) => { + let hexStr = ""; + for (let i in iv) { + if (iv[i] < 16) { + hexStr += "0" + iv[i].toString(16); + } else { + hexStr += iv[i].toString(16); + } + } + window.hexStr = hexStr; + return hexStr; +} + +let strToIv = (str) => { + let iv = new Uint8Array(16); + for (let i = 0; i < str.length; i += 2) { + iv[i/2] = parseInt((str.charAt(i) + str.charAt(i + 1)), 16); + } + + return iv; +} \ No newline at end of file diff --git a/package.json b/package.json index 1a2c0418..0f96ffd1 100644 --- a/package.json +++ b/package.json @@ -5,7 +5,7 @@ "scripts": { "format": "prettier --single-quote --write 'public/*.js' 'app.js'", "test": "echo \"Error: no test specified\" && exit 1", - "start": "node server/portal_server.js" + "start": "watchify frontend/src/main.js -o public/bundle.js -d | node server/portal_server.js" }, "author": "", "license": "ISC", @@ -17,5 +17,9 @@ "path": "^0.12.7", "prettier": "^1.3.1", "redis": "^2.7.1" + }, + "devDependencies": { + "browserify": "^14.4.0", + "watchify": "^3.9.0" } } diff --git a/public/bundle.js b/public/bundle.js new file mode 100644 index 00000000..9a01e7fd --- /dev/null +++ b/public/bundle.js @@ -0,0 +1,614 @@ +(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o { + + let xhr = new XMLHttpRequest(); + xhr.open("get", "/assets" + location.pathname.slice(0, -1), true); + xhr.responseType = "blob"; + + let listelem = setupUI(); + xhr.addEventListener("progress", updateProgress.bind(null, listelem)); + + xhr.onload = function(e) { + + // maybe send a separate request before this one to get the filename? + + // maybe render the html itself with the filename, since it's generated server side + // after a get request with the unique id + listelem.emit('name', xhr.getResponseHeader("Content-Disposition").match(/filename="(.+)"/)[1]); + + if (this.status == 200) { + let self = this; + let blob = new Blob([this.response]); + let arrayBuffer; + let fileReader = new FileReader(); + fileReader.onload = function() { + arrayBuffer = this.result; + let array = new Uint8Array(arrayBuffer); + salt = strToIv(location.pathname.slice(10, -1)); + + window.crypto.subtle.importKey( + "jwk", + { + kty: "oct", + k: location.hash.slice(1), + alg: "A128CBC", + ext: true, + }, + { + name: "AES-CBC", + }, + true, + ["encrypt", "decrypt"]) + .then((key) => { + return window.crypto.subtle.decrypt( + { + name: "AES-CBC", + iv: salt, + }, + key, + array) + }) + .then((decrypted) => { + let dataView = new DataView(decrypted); + let blob = new Blob([dataView]); + let downloadUrl = URL.createObjectURL(blob); + let a = document.createElement("a"); + a.href = downloadUrl; + a.download = xhr.getResponseHeader("Content-Disposition").match(/filename="(.+)"/)[1]; + document.body.appendChild(a); + a.click(); + }) + .catch((err) => { + alert("This link is either invalid or has expired, or the uploader has deleted the file."); + console.error(err); + }); + }; + + fileReader.readAsArrayBuffer(blob); + } else { + alert("This link is either invalid or has expired, or the uploader has deleted the file.") + } + }; + xhr.send(); +} + +window.download = download; + +let setupUI = () => { + let li = document.createElement("li"); + let name = document.createElement("p"); + li.appendChild(name); + + let progress = document.createElement("p"); + li.appendChild(progress); + + document.getElementById("downloaded_files").appendChild(li); + + return new UIWrapper(li, name, null, progress); +} + +let ivToStr = (iv) => { + let hexStr = ""; + for (let i in iv) { + if (iv[i] < 16) { + hexStr += "0" + iv[i].toString(16); + } else { + hexStr += iv[i].toString(16); + } + } + window.hexStr = hexStr; + return hexStr; +} + +let strToIv = (str) => { + let iv = new Uint8Array(16); + for (let i = 0; i < str.length; i += 2) { + iv[i/2] = parseInt((str.charAt(i) + str.charAt(i + 1)), 16); + } + + return iv; +} + +let updateProgress = (UIelem, e) => { + if (e.lengthComputable) { + let percentComplete = Math.floor((e.loaded / e.total) * 100); + UIelem.emit('progress', "Progress: " + percentComplete + "%"); + + if (percentComplete === 100) { + let finished = document.createElement("p"); + finished.innerText = "Your download has finished."; + UIelem.li.appendChild(finished); + + let close = document.createElement("button"); + close.innerText = "Ok"; + close.addEventListener("click", () => { + document.getElementById("downloaded_files").removeChild(UIelem.li); + }); + + UIelem.li.appendChild(close); + } + } +} +},{"./file":2}],2:[function(require,module,exports){ +const EventEmitter = require('events'); + +class UIWrapper extends EventEmitter { + constructor(li, name, link, progress) { + super(); + this.li = li; + this.name = name; + this.link = link; + this.progress = progress; + + this.on("name", (filename) => { + this.name.innerText = filename; + }); + + this.on("link", (link) => { + this.link.innerText = link; + this.link.setAttribute('href', link); + }); + + this.on("progress", (progress) => { + this.progress.innerText = progress; + + }); + } +} + +exports.UIWrapper = UIWrapper; +},{"events":5}],3:[function(require,module,exports){ +require('./upload'); +require('./download'); +require('./file'); +},{"./download":1,"./file":2,"./upload":4}],4:[function(require,module,exports){ +const EventEmitter = require('events'); +const UIWrapper = require('./file').UIWrapper; + +let onChange = (event) => { + let file = event.target.files[0]; + let reader = new FileReader(); + reader.readAsArrayBuffer(file); + + let random_iv = window.crypto.getRandomValues(new Uint8Array(16)); + let hex = ivToStr(random_iv); + + reader.onload = function(event) { + let self = this; + window.crypto.subtle.generateKey({ + name: "AES-CBC", + length: 128 + }, + true, + ["encrypt", "decrypt"]) + .then((key) => { + let arrayBuffer = self.result; + let array = new Uint8Array(arrayBuffer); + + window.crypto.subtle.encrypt({ + name: "AES-CBC", + iv: random_iv }, + key, + array) + .then(uploadFile.bind(null, file, hex, key)) + .catch((err) => console.error(err)); + + }).catch((err) => console.error(err)); + }; +} + +window.onChange = onChange; + +let uploadFile = (file, hex, key, encrypted) => { + let dataView = new DataView(encrypted); + let blob = new Blob([dataView], { type: file.type }); + + let fd = new FormData(); + fd.append("fname", file.name); + fd.append("data", blob, file.name); + + let xhr = new XMLHttpRequest(); + xhr.open("post", "/upload/" + hex, true); + + let listelem = setupUI(); + listelem.emit('name', file.name); + xhr.upload.addEventListener("progress", updateProgress.bind(null, listelem)); + + xhr.onreadystatechange = () => { + if (xhr.readyState == XMLHttpRequest.DONE) { + window.crypto.subtle.exportKey("jwk", key).then((keydata) => { + localStorage.setItem(hex, xhr.responseText); + + listelem.emit('link', "http://localhost:3000/download/" + hex + "/#" + keydata.k) + + console.log("Share this link with a friend: http://localhost:3000/download/" + hex + "/#" + keydata.k); + }) + } + }; + + xhr.send(fd); +} + +let updateProgress = (UIelem, e) => { + if (e.lengthComputable) { + let percentComplete = Math.floor((e.loaded / e.total) * 100); + UIelem.emit('progress', "Progress: " + percentComplete + "%") + + if (percentComplete === 100) { + let btn = document.createElement("button"); + btn.innerText = "Delete from server"; + btn.addEventListener("click", () => { + let segments = UIelem.link.innerText.split("/"); + let key = segments[segments.length - 2]; + + let xhr = new XMLHttpRequest(); + xhr.open("post", "/delete/" + key, true); + xhr.setRequestHeader("Content-Type", "application/json"); + if (!localStorage.getItem(key)) return; + + xhr.send(JSON.stringify({delete_token: localStorage.getItem(key)})); + + xhr.onreadystatechange = () => { + if (xhr.readyState === XMLHttpRequest.DONE) { + document.getElementById("uploaded_files").removeChild(UIelem.li); + localStorage.removeItem(key); + } + + if (xhr.status === 200) { + console.log("The file was successfully deleted."); + } else { + console.log("The file has expired, or has already been deleted."); + } + } + + }); + UIelem.li.appendChild(btn); + } + } +} + +let setupUI = () => { + let li = document.createElement("li"); + let name = document.createElement("p"); + li.appendChild(name); + + let link = document.createElement("a"); + li.appendChild(link); + + let progress = document.createElement("p"); + li.appendChild(progress); + + document.getElementById("uploaded_files").appendChild(li); + + return new UIWrapper(li, name, link, progress); +} + +let ivToStr = (iv) => { + let hexStr = ""; + for (let i in iv) { + if (iv[i] < 16) { + hexStr += "0" + iv[i].toString(16); + } else { + hexStr += iv[i].toString(16); + } + } + window.hexStr = hexStr; + return hexStr; +} + +let strToIv = (str) => { + let iv = new Uint8Array(16); + for (let i = 0; i < str.length; i += 2) { + iv[i/2] = parseInt((str.charAt(i) + str.charAt(i + 1)), 16); + } + + return iv; +} +},{"./file":2,"events":5}],5:[function(require,module,exports){ +// Copyright Joyent, Inc. and other Node contributors. +// +// Permission is hereby granted, free of charge, to any person obtaining a +// copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to permit +// persons to whom the Software is furnished to do so, subject to the +// following conditions: +// +// The above copyright notice and this permission notice shall be included +// in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN +// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, +// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +// USE OR OTHER DEALINGS IN THE SOFTWARE. + +function EventEmitter() { + this._events = this._events || {}; + this._maxListeners = this._maxListeners || undefined; +} +module.exports = EventEmitter; + +// Backwards-compat with node 0.10.x +EventEmitter.EventEmitter = EventEmitter; + +EventEmitter.prototype._events = undefined; +EventEmitter.prototype._maxListeners = undefined; + +// By default EventEmitters will print a warning if more than 10 listeners are +// added to it. This is a useful default which helps finding memory leaks. +EventEmitter.defaultMaxListeners = 10; + +// Obviously not all Emitters should be limited to 10. This function allows +// that to be increased. Set to zero for unlimited. +EventEmitter.prototype.setMaxListeners = function(n) { + if (!isNumber(n) || n < 0 || isNaN(n)) + throw TypeError('n must be a positive number'); + this._maxListeners = n; + return this; +}; + +EventEmitter.prototype.emit = function(type) { + var er, handler, len, args, i, listeners; + + if (!this._events) + this._events = {}; + + // If there is no 'error' event listener then throw. + if (type === 'error') { + if (!this._events.error || + (isObject(this._events.error) && !this._events.error.length)) { + er = arguments[1]; + if (er instanceof Error) { + throw er; // Unhandled 'error' event + } else { + // At least give some kind of context to the user + var err = new Error('Uncaught, unspecified "error" event. (' + er + ')'); + err.context = er; + throw err; + } + } + } + + handler = this._events[type]; + + if (isUndefined(handler)) + return false; + + if (isFunction(handler)) { + switch (arguments.length) { + // fast cases + case 1: + handler.call(this); + break; + case 2: + handler.call(this, arguments[1]); + break; + case 3: + handler.call(this, arguments[1], arguments[2]); + break; + // slower + default: + args = Array.prototype.slice.call(arguments, 1); + handler.apply(this, args); + } + } else if (isObject(handler)) { + args = Array.prototype.slice.call(arguments, 1); + listeners = handler.slice(); + len = listeners.length; + for (i = 0; i < len; i++) + listeners[i].apply(this, args); + } + + return true; +}; + +EventEmitter.prototype.addListener = function(type, listener) { + var m; + + if (!isFunction(listener)) + throw TypeError('listener must be a function'); + + if (!this._events) + this._events = {}; + + // To avoid recursion in the case that type === "newListener"! Before + // adding it to the listeners, first emit "newListener". + if (this._events.newListener) + this.emit('newListener', type, + isFunction(listener.listener) ? + listener.listener : listener); + + if (!this._events[type]) + // Optimize the case of one listener. Don't need the extra array object. + this._events[type] = listener; + else if (isObject(this._events[type])) + // If we've already got an array, just append. + this._events[type].push(listener); + else + // Adding the second element, need to change to array. + this._events[type] = [this._events[type], listener]; + + // Check for listener leak + if (isObject(this._events[type]) && !this._events[type].warned) { + if (!isUndefined(this._maxListeners)) { + m = this._maxListeners; + } else { + m = EventEmitter.defaultMaxListeners; + } + + if (m && m > 0 && this._events[type].length > m) { + this._events[type].warned = true; + console.error('(node) warning: possible EventEmitter memory ' + + 'leak detected. %d listeners added. ' + + 'Use emitter.setMaxListeners() to increase limit.', + this._events[type].length); + if (typeof console.trace === 'function') { + // not supported in IE 10 + console.trace(); + } + } + } + + return this; +}; + +EventEmitter.prototype.on = EventEmitter.prototype.addListener; + +EventEmitter.prototype.once = function(type, listener) { + if (!isFunction(listener)) + throw TypeError('listener must be a function'); + + var fired = false; + + function g() { + this.removeListener(type, g); + + if (!fired) { + fired = true; + listener.apply(this, arguments); + } + } + + g.listener = listener; + this.on(type, g); + + return this; +}; + +// emits a 'removeListener' event iff the listener was removed +EventEmitter.prototype.removeListener = function(type, listener) { + var list, position, length, i; + + if (!isFunction(listener)) + throw TypeError('listener must be a function'); + + if (!this._events || !this._events[type]) + return this; + + list = this._events[type]; + length = list.length; + position = -1; + + if (list === listener || + (isFunction(list.listener) && list.listener === listener)) { + delete this._events[type]; + if (this._events.removeListener) + this.emit('removeListener', type, listener); + + } else if (isObject(list)) { + for (i = length; i-- > 0;) { + if (list[i] === listener || + (list[i].listener && list[i].listener === listener)) { + position = i; + break; + } + } + + if (position < 0) + return this; + + if (list.length === 1) { + list.length = 0; + delete this._events[type]; + } else { + list.splice(position, 1); + } + + if (this._events.removeListener) + this.emit('removeListener', type, listener); + } + + return this; +}; + +EventEmitter.prototype.removeAllListeners = function(type) { + var key, listeners; + + if (!this._events) + return this; + + // not listening for removeListener, no need to emit + if (!this._events.removeListener) { + if (arguments.length === 0) + this._events = {}; + else if (this._events[type]) + delete this._events[type]; + return this; + } + + // emit removeListener for all listeners on all events + if (arguments.length === 0) { + for (key in this._events) { + if (key === 'removeListener') continue; + this.removeAllListeners(key); + } + this.removeAllListeners('removeListener'); + this._events = {}; + return this; + } + + listeners = this._events[type]; + + if (isFunction(listeners)) { + this.removeListener(type, listeners); + } else if (listeners) { + // LIFO order + while (listeners.length) + this.removeListener(type, listeners[listeners.length - 1]); + } + delete this._events[type]; + + return this; +}; + +EventEmitter.prototype.listeners = function(type) { + var ret; + if (!this._events || !this._events[type]) + ret = []; + else if (isFunction(this._events[type])) + ret = [this._events[type]]; + else + ret = this._events[type].slice(); + return ret; +}; + +EventEmitter.prototype.listenerCount = function(type) { + if (this._events) { + var evlistener = this._events[type]; + + if (isFunction(evlistener)) + return 1; + else if (evlistener) + return evlistener.length; + } + return 0; +}; + +EventEmitter.listenerCount = function(emitter, type) { + return emitter.listenerCount(type); +}; + +function isFunction(arg) { + return typeof arg === 'function'; +} + +function isNumber(arg) { + return typeof arg === 'number'; +} + +function isObject(arg) { + return typeof arg === 'object' && arg !== null; +} + +function isUndefined(arg) { + return arg === void 0; +} + +},{}]},{},[3]) +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","frontend/src/download.js","frontend/src/file.js","frontend/src/main.js","frontend/src/upload.js","node_modules/events/events.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACn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file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","const UIWrapper = require('./file').UIWrapper;\n\nlet download = () => {\n\n  let xhr = new XMLHttpRequest();\n  xhr.open(\"get\", \"/assets\" + location.pathname.slice(0, -1), true);\n  xhr.responseType = \"blob\";\n  \n  let listelem = setupUI();\n  xhr.addEventListener(\"progress\", updateProgress.bind(null, listelem));\n  \n  xhr.onload = function(e) {\n\n    // maybe send a separate request before this one to get the filename?\n\n    // maybe render the html itself with the filename, since it's generated server side\n    // after a get request with the unique id\n    listelem.emit('name', xhr.getResponseHeader(\"Content-Disposition\").match(/filename=\"(.+)\"/)[1]);\n\n    if (this.status == 200) {\n      let self = this;\n      let blob = new Blob([this.response]);\n      let arrayBuffer;\n      let fileReader = new FileReader();\n      fileReader.onload = function() {\n        arrayBuffer = this.result;\n        let array = new Uint8Array(arrayBuffer);\n        salt = strToIv(location.pathname.slice(10, -1));\n\n        window.crypto.subtle.importKey(\n          \"jwk\",\n          {\n              kty: \"oct\",\n              k: location.hash.slice(1),\n              alg: \"A128CBC\",\n              ext: true,\n          },\n          {\n              name: \"AES-CBC\",\n          },\n          true,\n          [\"encrypt\", \"decrypt\"])\n        .then((key) => {  \n          return window.crypto.subtle.decrypt(\n              {\n                name: \"AES-CBC\",\n                iv: salt,\n              },\n              key,\n              array)\n        })\n        .then((decrypted) => {\n          let dataView = new DataView(decrypted);\n          let blob = new Blob([dataView]);\n          let downloadUrl = URL.createObjectURL(blob);\n          let a = document.createElement(\"a\");\n          a.href = downloadUrl;\n          a.download = xhr.getResponseHeader(\"Content-Disposition\").match(/filename=\"(.+)\"/)[1];\n          document.body.appendChild(a);\n          a.click();\n        })\n        .catch((err) => {\n          alert(\"This link is either invalid or has expired, or the uploader has deleted the file.\");\n          console.error(err);\n        });\n      };\n\n      fileReader.readAsArrayBuffer(blob);\n    } else {\n      alert(\"This link is either invalid or has expired, or the uploader has deleted the file.\")\n    }\n  };\n  xhr.send();\n}\n\nwindow.download = download;\n\nlet setupUI = () => {\n  let li = document.createElement(\"li\");\n  let name = document.createElement(\"p\");\n  li.appendChild(name);\n\n  let progress = document.createElement(\"p\");\n  li.appendChild(progress);\n\n  document.getElementById(\"downloaded_files\").appendChild(li);\n\n  return new UIWrapper(li, name, null, progress);\n}\n\nlet ivToStr = (iv) => {\n  let hexStr = \"\";\n  for (let i in iv) {\n    if (iv[i] < 16) {\n      hexStr += \"0\" + iv[i].toString(16);\n    } else {\n      hexStr += iv[i].toString(16);\n    }\n  }\n  window.hexStr = hexStr;\n  return hexStr;\n}\n\nlet strToIv = (str) => {\n  let iv = new Uint8Array(16);\n  for (let i = 0; i < str.length; i += 2) {\n    iv[i/2] = parseInt((str.charAt(i) + str.charAt(i + 1)), 16);\n  }\n\n  return iv;\n}\n\nlet updateProgress = (UIelem, e) => {\n  if (e.lengthComputable) { \n    let percentComplete = Math.floor((e.loaded / e.total) * 100);\n    UIelem.emit('progress', \"Progress: \" + percentComplete + \"%\");\n\n    if (percentComplete === 100) {\n      let finished = document.createElement(\"p\");\n      finished.innerText = \"Your download has finished.\";\n      UIelem.li.appendChild(finished);\n\n      let close = document.createElement(\"button\");\n      close.innerText = \"Ok\";\n      close.addEventListener(\"click\", () => {\n        document.getElementById(\"downloaded_files\").removeChild(UIelem.li);\n      });\n\n      UIelem.li.appendChild(close);\n    }\n  } \n}","const EventEmitter = require('events');\n\nclass UIWrapper extends EventEmitter {\n  constructor(li, name, link, progress) {\n    super();\n    this.li = li;\n    this.name = name;\n    this.link = link;\n    this.progress = progress;\n\n    this.on(\"name\", (filename) => {\n      this.name.innerText = filename;\n    });\n\n    this.on(\"link\", (link) => {\n      this.link.innerText = link;\n      this.link.setAttribute('href', link);\n    });\n\n    this.on(\"progress\", (progress) => {\n      this.progress.innerText = progress;\n      \n    });\n  }\n}\n\nexports.UIWrapper = UIWrapper;","require('./upload');\nrequire('./download');\nrequire('./file');","const EventEmitter = require('events');\nconst UIWrapper = require('./file').UIWrapper;\n\nlet onChange = (event) => {\n  let file = event.target.files[0];\n  let reader = new FileReader();\n  reader.readAsArrayBuffer(file);\n\n  let random_iv = window.crypto.getRandomValues(new Uint8Array(16));\n  let hex = ivToStr(random_iv);\n\n  reader.onload = function(event) {\n    let self = this;\n    window.crypto.subtle.generateKey({\n      name: \"AES-CBC\",\n      length: 128 \n    },\n    true,\n    [\"encrypt\", \"decrypt\"])\n    .then((key) => {\n      let arrayBuffer = self.result;\n      let array = new Uint8Array(arrayBuffer);\n\n      window.crypto.subtle.encrypt({\n        name: \"AES-CBC\",\n        iv: random_iv },\n        key,\n        array)\n      .then(uploadFile.bind(null, file, hex, key))\n      .catch((err) => console.error(err));\n\n    }).catch((err) => console.error(err));   \n  };\n}\n\nwindow.onChange = onChange;\n\nlet uploadFile = (file, hex, key, encrypted) => {\n  let dataView = new DataView(encrypted);\n  let blob = new Blob([dataView], { type: file.type });\n  \n  let fd = new FormData();\n  fd.append(\"fname\", file.name);\n  fd.append(\"data\", blob, file.name);\n\n  let xhr = new XMLHttpRequest();\n  xhr.open(\"post\", \"/upload/\" + hex, true);\n\n  let listelem = setupUI();\n  listelem.emit('name', file.name);\n  xhr.upload.addEventListener(\"progress\", updateProgress.bind(null, listelem));\n\n  xhr.onreadystatechange = () => { \n    if (xhr.readyState == XMLHttpRequest.DONE) {\n      window.crypto.subtle.exportKey(\"jwk\", key).then((keydata) => {\n        localStorage.setItem(hex, xhr.responseText);\n\n        listelem.emit('link', \"http://localhost:3000/download/\" + hex + \"/#\" + keydata.k)\n\n        console.log(\"Share this link with a friend: http://localhost:3000/download/\" + hex + \"/#\" + keydata.k);\n      })\n    }\n  };\n\n  xhr.send(fd);\n}\n\nlet updateProgress = (UIelem, e) => {\n  if (e.lengthComputable) {\n    let percentComplete = Math.floor((e.loaded / e.total) * 100);\n    UIelem.emit('progress', \"Progress: \" + percentComplete + \"%\")\n\n    if (percentComplete === 100) {\n      let btn = document.createElement(\"button\");\n      btn.innerText = \"Delete from server\";\n      btn.addEventListener(\"click\", () => {\n        let segments = UIelem.link.innerText.split(\"/\");\n        let key = segments[segments.length - 2];\n\n        let xhr = new XMLHttpRequest();\n        xhr.open(\"post\", \"/delete/\" + key, true);\n        xhr.setRequestHeader(\"Content-Type\", \"application/json\");\n        if (!localStorage.getItem(key)) return;\n\n        xhr.send(JSON.stringify({delete_token: localStorage.getItem(key)}));\n\n        xhr.onreadystatechange = () => {\n          if (xhr.readyState === XMLHttpRequest.DONE) {\n            document.getElementById(\"uploaded_files\").removeChild(UIelem.li);\n            localStorage.removeItem(key);\n          }\n\n          if (xhr.status === 200) {\n            console.log(\"The file was successfully deleted.\");\n          } else {\n            console.log(\"The file has expired, or has already been deleted.\");\n          }\n        }\n        \n      });\n      UIelem.li.appendChild(btn);\n    }\n  }\n}\n\nlet setupUI = () => {\n  let li = document.createElement(\"li\");\n  let name = document.createElement(\"p\");\n  li.appendChild(name);\n  \n  let link = document.createElement(\"a\");\n  li.appendChild(link);\n\n  let progress = document.createElement(\"p\");\n  li.appendChild(progress);\n\n  document.getElementById(\"uploaded_files\").appendChild(li);\n\n  return new UIWrapper(li, name, link, progress);\n}\n\nlet ivToStr = (iv) => {\n  let hexStr = \"\";\n  for (let i in iv) {\n    if (iv[i] < 16) {\n      hexStr += \"0\" + iv[i].toString(16);\n    } else {\n      hexStr += iv[i].toString(16);\n    }\n  }\n  window.hexStr = hexStr;\n  return hexStr;\n}\n\nlet strToIv = (str) => {\n  let iv = new Uint8Array(16);\n  for (let i = 0; i < str.length; i += 2) {\n    iv[i/2] = parseInt((str.charAt(i) + str.charAt(i + 1)), 16);\n  }\n\n  return iv;\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nfunction EventEmitter() {\n  this._events = this._events || {};\n  this._maxListeners = this._maxListeners || undefined;\n}\nmodule.exports = EventEmitter;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nEventEmitter.defaultMaxListeners = 10;\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function(n) {\n  if (!isNumber(n) || n < 0 || isNaN(n))\n    throw TypeError('n must be a positive number');\n  this._maxListeners = n;\n  return this;\n};\n\nEventEmitter.prototype.emit = function(type) {\n  var er, handler, len, args, i, listeners;\n\n  if (!this._events)\n    this._events = {};\n\n  // If there is no 'error' event listener then throw.\n  if (type === 'error') {\n    if (!this._events.error ||\n        (isObject(this._events.error) && !this._events.error.length)) {\n      er = arguments[1];\n      if (er instanceof Error) {\n        throw er; // Unhandled 'error' event\n      } else {\n        // At least give some kind of context to the user\n        var err = new Error('Uncaught, unspecified \"error\" event. (' + er + ')');\n        err.context = er;\n        throw err;\n      }\n    }\n  }\n\n  handler = this._events[type];\n\n  if (isUndefined(handler))\n    return false;\n\n  if (isFunction(handler)) {\n    switch (arguments.length) {\n      // fast cases\n      case 1:\n        handler.call(this);\n        break;\n      case 2:\n        handler.call(this, arguments[1]);\n        break;\n      case 3:\n        handler.call(this, arguments[1], arguments[2]);\n        break;\n      // slower\n      default:\n        args = Array.prototype.slice.call(arguments, 1);\n        handler.apply(this, args);\n    }\n  } else if (isObject(handler)) {\n    args = Array.prototype.slice.call(arguments, 1);\n    listeners = handler.slice();\n    len = listeners.length;\n    for (i = 0; i < len; i++)\n      listeners[i].apply(this, args);\n  }\n\n  return true;\n};\n\nEventEmitter.prototype.addListener = function(type, listener) {\n  var m;\n\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  if (!this._events)\n    this._events = {};\n\n  // To avoid recursion in the case that type === \"newListener\"! Before\n  // adding it to the listeners, first emit \"newListener\".\n  if (this._events.newListener)\n    this.emit('newListener', type,\n              isFunction(listener.listener) ?\n              listener.listener : listener);\n\n  if (!this._events[type])\n    // Optimize the case of one listener. Don't need the extra array object.\n    this._events[type] = listener;\n  else if (isObject(this._events[type]))\n    // If we've already got an array, just append.\n    this._events[type].push(listener);\n  else\n    // Adding the second element, need to change to array.\n    this._events[type] = [this._events[type], listener];\n\n  // Check for listener leak\n  if (isObject(this._events[type]) && !this._events[type].warned) {\n    if (!isUndefined(this._maxListeners)) {\n      m = this._maxListeners;\n    } else {\n      m = EventEmitter.defaultMaxListeners;\n    }\n\n    if (m && m > 0 && this._events[type].length > m) {\n      this._events[type].warned = true;\n      console.error('(node) warning: possible EventEmitter memory ' +\n                    'leak detected. %d listeners added. ' +\n                    'Use emitter.setMaxListeners() to increase limit.',\n                    this._events[type].length);\n      if (typeof console.trace === 'function') {\n        // not supported in IE 10\n        console.trace();\n      }\n    }\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.once = function(type, listener) {\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  var fired = false;\n\n  function g() {\n    this.removeListener(type, g);\n\n    if (!fired) {\n      fired = true;\n      listener.apply(this, arguments);\n    }\n  }\n\n  g.listener = listener;\n  this.on(type, g);\n\n  return this;\n};\n\n// emits a 'removeListener' event iff the listener was removed\nEventEmitter.prototype.removeListener = function(type, listener) {\n  var list, position, length, i;\n\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  if (!this._events || !this._events[type])\n    return this;\n\n  list = this._events[type];\n  length = list.length;\n  position = -1;\n\n  if (list === listener ||\n      (isFunction(list.listener) && list.listener === listener)) {\n    delete this._events[type];\n    if (this._events.removeListener)\n      this.emit('removeListener', type, listener);\n\n  } else if (isObject(list)) {\n    for (i = length; i-- > 0;) {\n      if (list[i] === listener ||\n          (list[i].listener && list[i].listener === listener)) {\n        position = i;\n        break;\n      }\n    }\n\n    if (position < 0)\n      return this;\n\n    if (list.length === 1) {\n      list.length = 0;\n      delete this._events[type];\n    } else {\n      list.splice(position, 1);\n    }\n\n    if (this._events.removeListener)\n      this.emit('removeListener', type, listener);\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.removeAllListeners = function(type) {\n  var key, listeners;\n\n  if (!this._events)\n    return this;\n\n  // not listening for removeListener, no need to emit\n  if (!this._events.removeListener) {\n    if (arguments.length === 0)\n      this._events = {};\n    else if (this._events[type])\n      delete this._events[type];\n    return this;\n  }\n\n  // emit removeListener for all listeners on all events\n  if (arguments.length === 0) {\n    for (key in this._events) {\n      if (key === 'removeListener') continue;\n      this.removeAllListeners(key);\n    }\n    this.removeAllListeners('removeListener');\n    this._events = {};\n    return this;\n  }\n\n  listeners = this._events[type];\n\n  if (isFunction(listeners)) {\n    this.removeListener(type, listeners);\n  } else if (listeners) {\n    // LIFO order\n    while (listeners.length)\n      this.removeListener(type, listeners[listeners.length - 1]);\n  }\n  delete this._events[type];\n\n  return this;\n};\n\nEventEmitter.prototype.listeners = function(type) {\n  var ret;\n  if (!this._events || !this._events[type])\n    ret = [];\n  else if (isFunction(this._events[type]))\n    ret = [this._events[type]];\n  else\n    ret = this._events[type].slice();\n  return ret;\n};\n\nEventEmitter.prototype.listenerCount = function(type) {\n  if (this._events) {\n    var evlistener = this._events[type];\n\n    if (isFunction(evlistener))\n      return 1;\n    else if (evlistener)\n      return evlistener.length;\n  }\n  return 0;\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  return emitter.listenerCount(type);\n};\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\n"]} diff --git a/public/download.html b/public/download.html index bf5686b0..3a0e6ac5 100644 --- a/public/download.html +++ b/public/download.html @@ -2,7 +2,7 @@ Download your file - + diff --git a/public/download.js b/public/download.js deleted file mode 100644 index 7ecc9a49..00000000 --- a/public/download.js +++ /dev/null @@ -1,135 +0,0 @@ -function download() { - var xhr = new XMLHttpRequest(); - xhr.open('get', '/assets' + location.pathname.slice(0, -1), true); - xhr.responseType = 'blob'; - - var li = document.createElement('li'); - var progress = document.createElement('p'); - li.appendChild(progress); - document.getElementById('downloaded_files').appendChild(li); - - xhr.addEventListener('progress', returnBindedLI(li, progress)); - - xhr.onload = function(e) { - // maybe send a separate request before this one to get the filename? - - // maybe render the html itself with the filename, since it's generated server side - // after a get request with the unique id - var name = document.createElement('p'); - name.innerHTML = xhr - .getResponseHeader('Content-Disposition') - .match(/filename="(.+)"/)[1]; - li.insertBefore(name, li.firstChild); - - if (this.status == 200) { - let self = this; - var blob = new Blob([this.response]); - var arrayBuffer; - var fileReader = new FileReader(); - fileReader.onload = function() { - arrayBuffer = this.result; - var array = new Uint8Array(arrayBuffer); - salt = strToIv(location.pathname.slice(10, -1)); - - window.crypto.subtle - .importKey( - 'jwk', - { - kty: 'oct', - k: location.hash.slice(1), - alg: 'A128CBC', - ext: true - }, - { - name: 'AES-CBC' - }, - true, - ['encrypt', 'decrypt'] - ) - .then(function(key) { - window.crypto.subtle - .decrypt( - { - name: 'AES-CBC', - iv: salt - }, - key, - array - ) - .then(function(decrypted) { - var dataView = new DataView(decrypted); - var blob = new Blob([dataView]); - var downloadUrl = URL.createObjectURL(blob); - var a = document.createElement('a'); - a.href = downloadUrl; - a.download = xhr - .getResponseHeader('Content-Disposition') - .match(/filename="(.+)"/)[1]; - document.body.appendChild(a); - a.click(); - }) - .catch(function(err) { - alert( - 'This link is either invalid or has expired, or the uploader has deleted the file.' - ); - console.error(err); - }); - }) - .catch(function(err) { - console.error(err); - }); - }; - fileReader.readAsArrayBuffer(blob); - } else { - alert( - 'This link is either invalid or has expired, or the uploader has deleted the file.' - ); - } - }; - xhr.send(); -} - -function ivToStr(iv) { - let hexStr = ''; - for (var i in iv) { - if (iv[i] < 16) { - hexStr += '0' + iv[i].toString(16); - } else { - hexStr += iv[i].toString(16); - } - } - window.hexStr = hexStr; - return hexStr; -} - -function strToIv(str) { - var iv = new Uint8Array(16); - for (var i = 0; i < str.length; i += 2) { - iv[i / 2] = parseInt(str.charAt(i) + str.charAt(i + 1), 16); - } - - return iv; -} - -function returnBindedLI(li, progress) { - return function updateProgress(e) { - if (e.lengthComputable) { - var percentComplete = Math.floor(e.loaded / e.total * 100); - progress.innerHTML = 'Progress: ' + percentComplete + '%'; - } - - if (percentComplete === 100) { - var finished = document.createElement('p'); - finished.innerHTML = 'Your download has finished.'; - li.appendChild(finished); - - var close = document.createElement('button'); - close.innerHTML = 'Ok'; - close.addEventListener('click', function() { - document.getElementById('downloaded_files').removeChild(li); - }); - - li.appendChild(close); - } - }; -} diff --git a/public/file.js b/public/file.js deleted file mode 100644 index ce680be4..00000000 --- a/public/file.js +++ /dev/null @@ -1,10 +0,0 @@ -function ProgressEmitter(name, uuid, type) { - this.name = name; - this.uuid = uuid; - this.type = type; - this.link = null; - - this.emit = () => { - - }; -} \ No newline at end of file diff --git a/public/index.html b/public/index.html index aa77f317..e258c9f1 100644 --- a/public/index.html +++ b/public/index.html @@ -2,8 +2,8 @@ Firefox Fileshare - - + + @@ -13,6 +13,6 @@ - + diff --git a/public/upload.js b/public/upload.js deleted file mode 100644 index f213490f..00000000 --- a/public/upload.js +++ /dev/null @@ -1,164 +0,0 @@ -function onChange(event) { - - var file = event.target.files[0]; - var reader = new FileReader(); - reader.readAsArrayBuffer(file); - - let random_iv = window.crypto.getRandomValues(new Uint8Array(16)); - var hex = ivToStr(random_iv); - - reader.onload = function(event) { - let self = this; - window.crypto.subtle.generateKey({ - name: "AES-CBC", - length: 128 - }, - true, - ["encrypt", "decrypt"]) - .then((key) => { - let arrayBuffer = self.result; - let array = new Uint8Array(arrayBuffer); - - window.crypto.subtle.encrypt({ - name: "AES-CBC", - iv: random_iv }, - key, - array) - .then(uploadFile.bind(null, file, hex, key)) - .catch((err) => console.error(err)); - - }).catch((err) => console.error(err)); - }; -} - -let uploadFile = (file, hex, key, encrypted) => { - var dataView = new DataView(encrypted); - var blob = new Blob([dataView], { type: file.type }); - - var fd = new FormData(); - fd.append("fname", file.name); - fd.append("data", blob, file.name); - - var xhr = new XMLHttpRequest(); - - xhr.open("post", "/upload/" + hex, true); - - let prog = new window.ProgressEmitter(file.name, hex, file.type); - - var li = document.createElement("li"); - var name = document.createElement("p"); - name.innerHTML = file.name; - li.appendChild(name); - - var link = document.createElement("a"); - li.appendChild(link); - - var progress = document.createElement("p"); - li.appendChild(progress); - - - document.getElementById("uploaded_files").appendChild(li); - - - xhr.upload.addEventListener("progress", returnBindedLI(progress, name, link, li)); - - xhr.onreadystatechange = function() { - if (xhr.readyState == XMLHttpRequest.DONE) { - window.crypto.subtle.exportKey("jwk", key).then(function(keydata) { - var curr_name = localStorage.getItem(file.name); - - localStorage.setItem(hex, xhr.responseText); - - prog.link = "http://localhost:3000/download/" + hex + "/#" + keydata.k; - prog.emit(); - - link.innerHTML = "http://localhost:3000/download/" + hex + "/#" + keydata.k; - link.setAttribute("href", "http://localhost:3000/download/" + hex + "/#" + keydata.k); - - console.log("Share this link with a friend: http://localhost:3000/download/" + hex + "/#" + keydata.k); - }) - } - }; - - xhr.send(fd); - // setupLI(file.name); - -} - -function setupLI(emitter) { - var li = document.createElement("li"); - var name = document.createElement("p"); - name.innerHTML = emitter; - li.appendChild(name); - - var link = document.createElement("a"); - link.addEventListener('NotifyProgress', (progress_event) => { - console.log(progress_event); - }); - li.appendChild(link); - - var progress = document.createElement("p"); - li.appendChild(progress); - document.getElementById("uploaded_files").appendChild(li); -} - -function ivToStr(iv) { - let hexStr = ''; - for (var i in iv) { - if (iv[i] < 16) { - hexStr += '0' + iv[i].toString(16); - } else { - hexStr += iv[i].toString(16); - } - } - window.hexStr = hexStr; - return hexStr; -} - -function strToIv(str) { - var iv = new Uint8Array(16); - for (var i = 0; i < str.length; i += 2) { - iv[i / 2] = parseInt(str.charAt(i) + str.charAt(i + 1), 16); - } - - return iv; -} - -function returnBindedLI(a_element, name, link, li) { - return function updateProgress(e) { - if (e.lengthComputable) { - var percentComplete = Math.floor(e.loaded / e.total * 100); - a_element.innerHTML = 'Progress: ' + percentComplete + '%'; - - if (percentComplete === 100) { - var btn = document.createElement('button'); - btn.innerHTML = 'Delete from server'; - btn.addEventListener('click', function() { - var segments = link.innerHTML.split('/'); - var key = segments[segments.length - 2]; - - var xhr = new XMLHttpRequest(); - xhr.open('post', '/delete/' + key, true); - xhr.setRequestHeader('Content-Type', 'application/json'); - if (!localStorage.getItem(key)) return; - - xhr.send(JSON.stringify({ delete_token: localStorage.getItem(key) })); - - xhr.onreadystatechange = function() { - if (xhr.readyState === XMLHttpRequest.DONE) { - document.getElementById('uploaded_files').removeChild(li); - localStorage.removeItem(key); - } - - if (xhr.status === 200) { - console.log('The file was successfully deleted.'); - } else { - console.log('The file has expired, or has already been deleted.'); - } - }; - }); - li.appendChild(btn); - } - } - }; -} diff --git a/server/portal_server.js b/server/portal_server.js index 4cc91688..df726ae4 100644 --- a/server/portal_server.js +++ b/server/portal_server.js @@ -1,4 +1,3 @@ - const express = require("express") const busboy = require("connect-busboy"); const path = require("path"); @@ -10,7 +9,7 @@ const app = express() const redis = require("redis"), client = redis.createClient(); -client.on("error", function(err) { +client.on("error", (err) => { console.log(err); }) @@ -18,12 +17,12 @@ app.use(busboy()); app.use(bodyParser.json()); app.use(express.static(path.join(__dirname, "../public"))); -app.get("/download/:id", function(req, res) { +app.get("/download/:id", (req, res) => { res.sendFile(path.join(__dirname + "/../public/download.html")); }); -app.get("/assets/download/:id", function(req, res) { - +app.get("/assets/download/:id", (req, res) => { + let id = req.params.id; if (!validateID(id)){ res.send(404); @@ -31,14 +30,14 @@ app.get("/assets/download/:id", function(req, res) { } - client.hget(id, "filename", function(err, reply) { // maybe some expiration logic too + client.hget(id, "filename", (err, reply) => { // maybe some expiration logic too if (!reply) { res.sendStatus(404); } else { res.setHeader("Content-Disposition", "attachment; filename=" + reply); res.setHeader("Content-Type", "application/octet-stream"); - res.download(__dirname + "/../static/" + id, reply, function(err) { + res.download(__dirname + "/../static/" + id, reply, (err) => { if (!err) { client.del(id); fs.unlinkSync(__dirname + "/../static/" + id); @@ -49,7 +48,7 @@ app.get("/assets/download/:id", function(req, res) { }); -app.post("/delete/:id", function(req, res) { +app.post("/delete/:id", (req, res) => { let id = req.params.id; if (!validateID(id)){ @@ -63,7 +62,7 @@ app.post("/delete/:id", function(req, res) { res.sendStatus(404); } - client.hget(id, "delete", function(err, reply) { + client.hget(id, "delete", (err, reply) => { if (!reply) { res.sendStatus(404); } else { @@ -74,29 +73,29 @@ app.post("/delete/:id", function(req, res) { }) }); -app.post("/upload/:id", function (req, res, next) { +app.post("/upload/:id", (req, res, next) => { if (!validateID(req.params.id)){ res.send(404); return; } - var fstream; + let fstream; req.pipe(req.busboy); - req.busboy.on("file", function (fieldname, file, filename) { + req.busboy.on("file", (fieldname, file, filename) => { console.log("Uploading: " + filename); //Path where image will be uploaded fstream = fs.createWriteStream(__dirname + "/../static/" + req.params.id); file.pipe(fstream); - fstream.on("close", function () { + fstream.on("close", () => { let id = req.params.id; let uuid = crypto.randomBytes(10).toString('hex'); client.hmset([id, "filename", filename, "delete", uuid]); // delete the file off the server in 24 hours - // setTimeout(function() { + // setTimeout(() => { // fs.unlinkSync(__dirname + "/static/" + id); // }, 86400000); @@ -107,10 +106,10 @@ app.post("/upload/:id", function (req, res, next) { }); }); -app.listen(3000, function () { +app.listen(3000, () => { console.log("Portal app listening on port 3000!") }) -function validateID(route_id) { +let validateID = (route_id) => { return route_id.match(/^[0-9a-fA-F]{32}$/) !== null; } \ No newline at end of file