libves 2.0.3 → 2.1.2

package/libVES.node.js

@@ -27,20 +27,24 @@
  *
  * @title libVES
  * @dev A JavaScript end-to-end encryption interface to VESvault REST API
- * @version 2.00
+ * @version 2.01
  *
  * @dev Official source code: https://github.com/vesvault/libVES
  *
  * @author Jim Zubov <jz@vesvault.com> (VESvault Corp)
  *
  ***************************************************************************/
+crypto = require('crypto');
+crypto.subtle = require('subtle');
+XMLHttpRequest = require('xhr2');
 
-if (!window.libVES) window.libVES = function(optns) {
+
+if (typeof(libVES) != 'function') function libVES(optns) {
     try {
-	if (!window.crypto.subtle.digest) throw new libVES.Error('Init','crypto.subtle is improperly implemented?');
+	if (!crypto.subtle.digest) throw new libVES.Error('Init', 'crypto.subtle is unavailable or improperly implemented');
     } catch (e) {
 	if (e instanceof libVES.Error) throw e;
-	throw new libVES.Error('Init','crypto.subtle is not usable' + (document.location.protocol.match(/https/) ? '' : ' (try https?)'));
+	throw new libVES.Error('Init', 'crypto.subtle is not available');
     }
     for (var k in optns) this[k] = optns[k];
     if (this.domain) this.type = 'secondary';
@@ -586,7 +590,7 @@ libVES.prototype = {
 	}
 	if (!optns || !optns.n) return Promise.reject(new libVES.Error('InvalidValue','optns.n must be an integer'));
 	var rkey = new Uint8Array(32);
-	window.crypto.getRandomValues(rkey);
+	crypto.getRandomValues(rkey);
 	var algo = optns.v ? libVES.Scramble.algo[optns.v] : libVES.Scramble.RDX;
 	if (!algo) return Promise.reject(new libVES.Error('InvalidValue','Unknown scramble algorithm: ' + optns.v));
 	var s = new algo(optns.n);
@@ -1587,7 +1591,7 @@ libVES.Math.Shifter.prototype = {
 
 libVES.Object = function(data) {
     for (var k in data) this[k] = data[k];
-    if (window.Trigger) this.trigger = Trigger.resolve(this);
+    if (typeof(Trigger) != 'undefined') this.trigger = Trigger.resolve(this);
 };
 
 libVES.Object.prototype = {
@@ -2426,7 +2430,6 @@ libVES.Algo = {
 		case 'public':
 		    return crypto.subtle.exportKey('spki', data).then(function(der) {
 			var asn = libVES.Util.ASN1.decode(new Uint8Array(der))[0];
-			console.log(asn);
 			switch (String(asn[0][0])) {
 			    case '1.2.840.10045.2.1':
 				return der;
@@ -2546,7 +2549,7 @@ libVES.Algo = {
     },
     acquire: function(key,optns) {
 	return Promise.resolve(key).then(function(k) {
-	    if (k instanceof window.CryptoKey) return k;
+	    if (typeof(CryptoKey) != 'undefined' && (k instanceof CryptoKey)) return k;
 	    else if (typeof(k) == 'object') {
 		if (k.privateKey) return k.privateKey;
 		else if (k.publicKey) return k.publicKey;
@@ -2838,7 +2841,7 @@ libVES.Scramble.RDX.prototype = {
 	var u = [sc];
 	for (var i = 1; i < this.size; i++) {
 	    u[i] = new Uint8Array(sc.length);
-	    window.crypto.getRandomValues(u[i]);
+	    crypto.getRandomValues(u[i]);
 	}
 	var v = [];
 	for (var i = 0; i < this.size - 1; i++) v[i] = (function(ui,ui1) {
@@ -3537,4 +3540,103 @@ libVES.Flow.prototype.logout = function() {
     return libVES.Flow.logout();
 };
 
+
+libVES.Auth = function(optns) {
+    for (var k in optns) this[k] = optns[k];
+    return this;
+};
+
+libVES.Auth.prototype.getToken = function() {
+    if (this.vaultItem) return Promise.all([this.vaultItem.getId(), this.vaultItem.getField('verifyToken')]).then(function(flds) {
+	return 'vaultItem.' + flds[0] + '.' + flds[1];
+    });
+    else if (this.vaultKey) return Promise.all([this.vaultKey.getId(), this.vaultItem.getSessionToken()]).then(function(flds) {
+	return 'vaultKey.' + flds[0] + '.' + flds[1];
+    });
+    else if ((VES = this.VES) && VES.token) return this.VES.getVaultKey().then(function(vkey) {
+	return vkey.getId().then(function(id) {
+	    return 'vaultKey.' + id + '.' + VES.token;
+	});
+    });
+    return Promise.reject({code: 'VESauth', message: 'No object to generate a VESauth token for'});
+};
+
+libVES.Auth.prototype.getData = function(url, type) {
+    return this.getToken().then(function(tkn) {
+	return new Promise(function(resolve, reject) {
+	    var xhr = new XMLHttpRequest();
+	    xhr.open('GET', url);
+	    if (type) xhr.responseType = type;
+	    xhr.onreadystatechange = function() {
+		switch(xhr.readyState) {
+		    case 4:
+			if (xhr.status == 200) resolve(xhr.response);
+			else reject({code: xhr.status, message: xhr.statusText});
+		}
+	    };
+	    xhr.setRequestHeader('X-VES-Authorization', tkn);
+	    xhr.send();
+	});
+    });
+};
+
+libVES.Auth.prototype.getJSON = function(url) {
+    return this.getData(url, 'json').then(function(json) {
+	var a = document.createElement('a');
+	a.href = url;
+	if (!a.hash) return json;
+	var path = a.hash.split(/\//);
+	for (var i = 1; i < path.length; i++) if (path[i]) {
+	    if (json instanceof Array) json = json[Number(path[i])];
+	    else if (json instanceof Object) json = json[path[i]];
+	    else return null;
+	}
+	return json;
+    });
+};
+
+libVES.Auth.prototype.auth = function(token) {
+    return this.verify(token, true);
+};
+
+libVES.Auth.prototype.verify = function(token, auth) {
+    var tk = token.match(/^(\w*)\.(\d*)\.(.*)$/);
+    if (!tk) return Promise.reject(new libVES.Error('VESauth', 'Invalid VESauth token'));
+    var ves = new libVES({domain: (this.domain || '*'), token: tk[3]});
+    if (tk[1] == 'vaultItem') {
+	if (auth) return Promise.reject(new libVES.Error('VESauth', 'Verify token cannot be used for authentication'));
+	return Promise.resolve(this.vaultItem ? this.vaultItem.getId() : tk[2]).then(function(id) {
+	    var vi = new libVES.VaultItem({id: id}, ves);
+	    return vi.getFile().then(function(file) {
+		return vi.getField('deleted').then(function(f) {
+		    if (f) throw new libVES.Error('VESauth', 'Verify token expired');
+		    return file.getCreator();
+		});
+	    });
+	});
+    }
+    if (tk[1] != 'vaultKey') return Promise.reject(new libVES.Error('VESauth', 'Unknown token type'));
+    if (this.vaultItem) return this.vaultItem.getId().then(function(id) {
+	var vi = new libVES.VaultItem({id: id}, ves);
+	return vi.getVaultEntries().then(function(vents) {
+	    if (!auth && vents && vents.length) return ves.me();
+	    if (vents && tk[2]) for (var i = 0; i < vents.length; i++) if (vents[i].vaultKey && Number(vents[i].vaultKey.id) == Number(tk[2])) return ves.me();
+	    throw new libVES.Error('VESauth', 'ACL not authorized');
+	});
+    });
+    if (!auth) return ves.me();
+    return Promise.resolve(this.vaultKey ? this.vaultKey.getId() : tk[2]).then(function(id) {
+	return (new libVES.VaultKey({id: id}, ves)).getExternals().then(function(ext) {
+	    if (!ext || !ext[0]) throw new libVES.Error('VESauth', 'Bad vaultKey for VESauth');
+	    return ext[0].getDomain().then(function(dom) {
+		return ext[0].getExternalId().then(function(extid) {
+		    if (!extid || !extid.match(/^[^\!\@]+\@[^\!\@]+$/)) throw new libVES.Error('VESauth', 'Bad vaultKey for VESauth');
+		    if (dom && dom.toLowerCase() == ves.domain.toLowerCase()) return ves.me();
+		    throw new libVES.Error('VESuath', 'VES domain does not match');
+		});
+	    });
+	});
+    });
+};
+
 module.exports = libVES;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libves",
-  "version": "2.0.3",
+  "version": "2.1.2",
   "description": "Simple, safe and secure end-to-end encryption for data at-rest",
   "main": "libVES.node.js",
   "scripts": {
@@ -17,9 +17,15 @@
     "e2e",
     "at-rest",
     "end-to-end",
-    "browser encryption",
+    "browser",
+    "browser-encryption",
     "pin"
   ],
+  "dependencies": {
+    "crypto": "*",
+    "subtle": "*",
+    "xh2r": "*"
+  },
   "author": "jz@vesvault.com",
   "license": "GPL-3.0",
   "bugs": {