curtain-web-api 1.0.36 → 1.0.38

package/build/classes/curtain-api.d.ts

@@ -1,4 +1,5 @@
 import { User } from "./curtain-user";
+import { CurtainEncryption } from "./curtain-encryption";
 export declare const replacer: (key: any, value: any) => any;
 export declare const reviver: (key: any, value: any) => any;
 export declare class CurtainWebAPI {
@@ -20,7 +21,7 @@ export declare class CurtainWebAPI {
     ORCIDLogin(authorizationCode: string, redirectURI: string): Promise<User>;
     checkIfRefreshTokenExpired(): boolean;
     deleteCurtainLink(curtainLinkID: string): Promise<import("axios").AxiosResponse<any, any>>;
-    putSettings(settings: any, enable?: boolean, description?: string, sessionType?: string, encrypted?: boolean, md5?: string, e2e?: boolean, onUploadProgress?: any): Promise<import("axios").AxiosResponse<any, any>>;
+    putSettings(settings: any, enable?: boolean, description?: string, sessionType?: string, encryption?: CurtainEncryption, onUploadProgress?: any): Promise<import("axios").AxiosResponse<any, any>>;
     postSettings(id: string, token: string, onDownloadProgress?: any): Promise<import("axios").AxiosResponse<any, any>>;
     getPrideData(accession: string): Promise<import("axios").AxiosResponse<any, any>>;
     generateTemporarySession(linkId: string, lifetime: number): Promise<import("axios").AxiosResponse<any, any>>;

package/build/classes/curtain-api.js

@@ -26,6 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CurtainWebAPI = exports.reviver = exports.replacer = void 0;
 const curtain_user_1 = require("./curtain-user");
 const axios_1 = __importStar(require("axios"));
+const curtain_encryption_1 = require("./curtain-encryption");
 const base = "https://celsus.muttsu.xyz/";
 const replacer = (key, value) => {
     if (value instanceof Map) {
@@ -208,28 +209,38 @@ class CurtainWebAPI {
             return response;
         });
     }
-    putSettings(settings, enable = true, description = "", sessionType = "TP", encrypted = false, md5 = "", e2e = false, onUploadProgress = undefined) {
+    putSettings(settings, enable = true, description = "", sessionType = "TP", encryption = {
+        encrypted: false,
+        e2e: false,
+    }, onUploadProgress = undefined) {
         let form = new FormData();
-        form.append("file", new Blob([JSON.stringify(settings, exports.replacer)], { type: 'text/json' }), "curtain-settings.json");
+        let data = JSON.stringify(settings, exports.replacer);
         if (enable) {
             form.append("enable", "True");
         }
         else {
             form.append("enable", "False");
         }
-        if (encrypted) {
+        if (encryption.encrypted) {
             form.append("encrypted", "True");
         }
         else {
             form.append("encrypted", "False");
         }
-        form.append("md5", md5);
-        if (e2e) {
+        if (encryption.e2e) {
             form.append("e2e", "True");
         }
         else {
             form.append("e2e", "False");
         }
+        if (encryption.encrypted && encryption.e2e && encryption.publicKey !== undefined) {
+            (0, curtain_encryption_1.encryptDataRSA)(data, encryption.publicKey).then((response) => {
+                form.append("file", new Blob([response], { type: 'text/json' }), "curtain-settings.json");
+            });
+        }
+        else {
+            form.append("file", new Blob([data], { type: 'text/json' }), "curtain-settings.json");
+        }
         form.append("description", description);
         form.append("curtain_type", sessionType);
         let headers = new axios_1.AxiosHeaders();

package/build/classes/curtain-encryption.d.ts

@@ -0,0 +1,20 @@
+export declare function encryptDataRSA(data: string, publicKey: CryptoKey): Promise<ArrayBuffer>;
+export declare function decryptDataRSA(data: string, privateKey: CryptoKey): Promise<ArrayBuffer>;
+export declare function importPublicKey(key: ArrayBuffer): Promise<CryptoKey>;
+export declare function importPrivateKey(key: ArrayBuffer): Promise<CryptoKey>;
+export declare function generateKeyPair(modulusLength?: number, publicExponent?: Uint8Array): Promise<CryptoKeyPair>;
+export declare function exportPublicKey(key: CryptoKey): Promise<ArrayBuffer>;
+export declare function exportPrivateKey(key: CryptoKey): Promise<ArrayBuffer>;
+export declare function importKey(key: ArrayBuffer, type: "public" | "private"): Promise<CryptoKey>;
+export declare function exportKeyString(key: CryptoKey, type: "public" | "private"): Promise<string>;
+export declare function saveToLocalStorage(key: CryptoKey, type: "public" | "private"): Promise<void>;
+export declare function loadFromLocalStorage(type: "public" | "private"): Promise<CryptoKey | undefined>;
+export interface CurtainEncryption {
+    encrypted: boolean;
+    publicKey?: CryptoKey;
+    e2e: boolean;
+}
+export declare function arrayBufferToBase64String(arrayBuffer: ArrayBuffer): string;
+export declare function removeLines(str_data: string): string;
+export declare function base64ToArrayBuffer(b64: string): Uint8Array;
+export declare function pemToArrayBuffer(pem: string): Uint8Array;

package/build/classes/curtain-encryption.js

@@ -0,0 +1,127 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pemToArrayBuffer = exports.base64ToArrayBuffer = exports.removeLines = exports.arrayBufferToBase64String = exports.loadFromLocalStorage = exports.saveToLocalStorage = exports.exportKeyString = exports.importKey = exports.exportPrivateKey = exports.exportPublicKey = exports.generateKeyPair = exports.importPrivateKey = exports.importPublicKey = exports.decryptDataRSA = exports.encryptDataRSA = void 0;
+function encryptDataRSA(data, publicKey) {
+    return crypto.subtle.encrypt({ name: 'RSA-OAEP' }, publicKey, new TextEncoder().encode(data));
+}
+exports.encryptDataRSA = encryptDataRSA;
+function decryptDataRSA(data, privateKey) {
+    return crypto.subtle.decrypt({ name: 'RSA-OAEP' }, privateKey, new TextEncoder().encode(data));
+}
+exports.decryptDataRSA = decryptDataRSA;
+function importPublicKey(key) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield crypto.subtle.importKey('spki', key, { name: 'RSA-OAEP', hash: 'SHA-256' }, true, ['encrypt']);
+    });
+}
+exports.importPublicKey = importPublicKey;
+function importPrivateKey(key) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield crypto.subtle.importKey('pkcs8', key, { name: 'RSA-OAEP', hash: 'SHA-256' }, true, ['decrypt']);
+    });
+}
+exports.importPrivateKey = importPrivateKey;
+function generateKeyPair(modulusLength = 2048, publicExponent = new Uint8Array([1, 0, 1])) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield crypto.subtle.generateKey({
+            name: "RSA-OAEP",
+            modulusLength: modulusLength,
+            publicExponent: publicExponent,
+            hash: "SHA-256",
+        }, true, ["encrypt", "decrypt"]);
+    });
+}
+exports.generateKeyPair = generateKeyPair;
+function exportPublicKey(key) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield crypto.subtle.exportKey('spki', key);
+    });
+}
+exports.exportPublicKey = exportPublicKey;
+function exportPrivateKey(key) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield crypto.subtle.exportKey('pkcs8', key);
+    });
+}
+exports.exportPrivateKey = exportPrivateKey;
+function importKey(key, type) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (type === "public") {
+            return yield importPublicKey(key);
+        }
+        else {
+            return yield importPrivateKey(key);
+        }
+    });
+}
+exports.importKey = importKey;
+function exportKeyString(key, type) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (type === "public") {
+            const k = yield exportPublicKey(key);
+            return arrayBufferToBase64String(k);
+        }
+        else {
+            const k = yield exportPrivateKey(key);
+            return arrayBufferToBase64String(k);
+        }
+    });
+}
+exports.exportKeyString = exportKeyString;
+function saveToLocalStorage(key, type) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const k = yield exportKeyString(key, type);
+        localStorage.setItem(type + "_key", k);
+    });
+}
+exports.saveToLocalStorage = saveToLocalStorage;
+function loadFromLocalStorage(type) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const k = localStorage.getItem(type + "_key");
+        if (k) {
+            return yield importKey(pemToArrayBuffer(k), type);
+        }
+        return undefined;
+    });
+}
+exports.loadFromLocalStorage = loadFromLocalStorage;
+function arrayBufferToBase64String(arrayBuffer) {
+    const byteArray = new Uint8Array(arrayBuffer);
+    let byteString = '';
+    for (let i = 0; i < byteArray.byteLength; i++) {
+        byteString += String.fromCharCode(byteArray[i]);
+    }
+    return btoa(byteString);
+}
+exports.arrayBufferToBase64String = arrayBufferToBase64String;
+function removeLines(str_data) {
+    return str_data.replace("\n", "");
+}
+exports.removeLines = removeLines;
+function base64ToArrayBuffer(b64) {
+    const byteString = atob(b64);
+    const byteArray = new Uint8Array(byteString.length);
+    for (let i = 0; i < byteString.length; i++) {
+        byteArray[i] = byteString.charCodeAt(i);
+    }
+    return byteArray;
+}
+exports.base64ToArrayBuffer = base64ToArrayBuffer;
+function pemToArrayBuffer(pem) {
+    const b64Lines = removeLines(pem);
+    let b64Prefix = b64Lines.replace('-----BEGIN PRIVATE KEY-----', '');
+    b64Prefix = b64Prefix.replace('-----BEGIN PUBLIC KEY-----', '');
+    let b64Final = b64Prefix.replace('-----END PRIVATE KEY-----', '');
+    b64Final = b64Final.replace('-----END PUBLIC KEY-----', '');
+    return base64ToArrayBuffer(b64Final);
+}
+exports.pemToArrayBuffer = pemToArrayBuffer;

package/build/index.d.ts

@@ -1,4 +1,5 @@
 import { CurtainWebAPI, replacer, reviver } from "./classes/curtain-api";
 import { User } from "./classes/curtain-user";
 import { getProteomicsData, getPrideData, getEBIAlpha, getInteractomeAtlas, getStringDBInteractions } from "./utilities";
-export { CurtainWebAPI, User, getProteomicsData, getPrideData, getEBIAlpha, getInteractomeAtlas, getStringDBInteractions, replacer, reviver };
+import { importKey, importPrivateKey, exportPrivateKey, exportKeyString, exportPublicKey, importPublicKey, CurtainEncryption, generateKeyPair, encryptDataRSA, decryptDataRSA, loadFromLocalStorage, saveToLocalStorage } from "./classes/curtain-encryption";
+export { CurtainWebAPI, User, getProteomicsData, getPrideData, getEBIAlpha, getInteractomeAtlas, getStringDBInteractions, replacer, reviver, importKey, importPrivateKey, exportPrivateKey, exportKeyString, exportPublicKey, importPublicKey, CurtainEncryption, generateKeyPair, encryptDataRSA, decryptDataRSA, loadFromLocalStorage, saveToLocalStorage };

package/build/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.reviver = exports.replacer = exports.getStringDBInteractions = exports.getInteractomeAtlas = exports.getEBIAlpha = exports.getPrideData = exports.getProteomicsData = exports.User = exports.CurtainWebAPI = void 0;
+exports.saveToLocalStorage = exports.loadFromLocalStorage = exports.decryptDataRSA = exports.encryptDataRSA = exports.generateKeyPair = exports.importPublicKey = exports.exportPublicKey = exports.exportKeyString = exports.exportPrivateKey = exports.importPrivateKey = exports.importKey = exports.reviver = exports.replacer = exports.getStringDBInteractions = exports.getInteractomeAtlas = exports.getEBIAlpha = exports.getPrideData = exports.getProteomicsData = exports.User = exports.CurtainWebAPI = void 0;
 const curtain_api_1 = require("./classes/curtain-api");
 Object.defineProperty(exports, "CurtainWebAPI", { enumerable: true, get: function () { return curtain_api_1.CurtainWebAPI; } });
 Object.defineProperty(exports, "replacer", { enumerable: true, get: function () { return curtain_api_1.replacer; } });
@@ -13,3 +13,15 @@ Object.defineProperty(exports, "getPrideData", { enumerable: true, get: function
 Object.defineProperty(exports, "getEBIAlpha", { enumerable: true, get: function () { return utilities_1.getEBIAlpha; } });
 Object.defineProperty(exports, "getInteractomeAtlas", { enumerable: true, get: function () { return utilities_1.getInteractomeAtlas; } });
 Object.defineProperty(exports, "getStringDBInteractions", { enumerable: true, get: function () { return utilities_1.getStringDBInteractions; } });
+const curtain_encryption_1 = require("./classes/curtain-encryption");
+Object.defineProperty(exports, "importKey", { enumerable: true, get: function () { return curtain_encryption_1.importKey; } });
+Object.defineProperty(exports, "importPrivateKey", { enumerable: true, get: function () { return curtain_encryption_1.importPrivateKey; } });
+Object.defineProperty(exports, "exportPrivateKey", { enumerable: true, get: function () { return curtain_encryption_1.exportPrivateKey; } });
+Object.defineProperty(exports, "exportKeyString", { enumerable: true, get: function () { return curtain_encryption_1.exportKeyString; } });
+Object.defineProperty(exports, "exportPublicKey", { enumerable: true, get: function () { return curtain_encryption_1.exportPublicKey; } });
+Object.defineProperty(exports, "importPublicKey", { enumerable: true, get: function () { return curtain_encryption_1.importPublicKey; } });
+Object.defineProperty(exports, "generateKeyPair", { enumerable: true, get: function () { return curtain_encryption_1.generateKeyPair; } });
+Object.defineProperty(exports, "encryptDataRSA", { enumerable: true, get: function () { return curtain_encryption_1.encryptDataRSA; } });
+Object.defineProperty(exports, "decryptDataRSA", { enumerable: true, get: function () { return curtain_encryption_1.decryptDataRSA; } });
+Object.defineProperty(exports, "loadFromLocalStorage", { enumerable: true, get: function () { return curtain_encryption_1.loadFromLocalStorage; } });
+Object.defineProperty(exports, "saveToLocalStorage", { enumerable: true, get: function () { return curtain_encryption_1.saveToLocalStorage; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "curtain-web-api",
-  "version": "1.0.36",
+  "version": "1.0.38",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",

package/src/classes/curtain-api.ts

@@ -1,5 +1,6 @@
 import {User} from "./curtain-user";
 import axios, {AxiosHeaders} from "axios";
+import {CurtainEncryption, encryptDataRSA} from "./curtain-encryption";
 
 const base: string = "https://celsus.muttsu.xyz/"
 
@@ -198,26 +199,36 @@ export class CurtainWebAPI {
     }
 
 
-    putSettings(settings: any, enable: boolean = true, description: string = "", sessionType: string = "TP", encrypted: boolean = false, md5: string = "", e2e: boolean = false,  onUploadProgress: any = undefined) {
+    putSettings(settings: any, enable: boolean = true, description: string = "", sessionType: string = "TP", encryption: CurtainEncryption = {
+        encrypted: false,
+        e2e: false,
+    },   onUploadProgress: any = undefined) {
         let form: FormData = new FormData();
-        form.append("file", new Blob([JSON.stringify(settings, replacer)], {type: 'text/json'}), "curtain-settings.json")
+        let data = JSON.stringify(settings, replacer)
         if (enable) {
             form.append("enable", "True")
         } else {
             form.append("enable", "False")
         }
-        if (encrypted) {
+        if (encryption.encrypted) {
             form.append("encrypted", "True")
         } else {
             form.append("encrypted", "False")
         }
-        form.append("md5", md5)
-        if (e2e) {
+        if (encryption.e2e) {
             form.append("e2e", "True")
         } else {
             form.append("e2e", "False")
         }
 
+        if (encryption.encrypted && encryption.e2e && encryption.publicKey !== undefined) {
+            encryptDataRSA(data, encryption.publicKey).then((response) => {
+                form.append("file", new Blob([response], {type: 'text/json'}), "curtain-settings.json")
+            })
+        } else {
+            form.append("file", new Blob([data], {type: 'text/json'}), "curtain-settings.json")
+        }
+
         form.append("description", description)
         form.append("curtain_type", sessionType)
         let headers = new AxiosHeaders();

package/src/classes/curtain-encryption.ts

@@ -0,0 +1,106 @@
+export function encryptDataRSA(data: string, publicKey: CryptoKey) {
+  return crypto.subtle.encrypt({name: 'RSA-OAEP'}, publicKey, new TextEncoder().encode(data))
+}
+
+export function decryptDataRSA(data: string, privateKey: CryptoKey) {
+  return crypto.subtle.decrypt({name: 'RSA-OAEP'}, privateKey, new TextEncoder().encode(data))
+}
+
+export async function importPublicKey(key: ArrayBuffer) {
+  return await crypto.subtle.importKey('spki', key, {name: 'RSA-OAEP', hash: 'SHA-256'}, true, ['encrypt'])
+}
+
+export async function importPrivateKey(key: ArrayBuffer) {
+  return await crypto.subtle.importKey('pkcs8', key, {name: 'RSA-OAEP', hash: 'SHA-256'}, true, ['decrypt'])
+}
+
+export async function generateKeyPair(modulusLength: number = 2048, publicExponent: Uint8Array = new Uint8Array([1, 0, 1])) {
+  return await crypto.subtle.generateKey(
+    {
+      name: "RSA-OAEP",
+      modulusLength: modulusLength,
+      publicExponent: publicExponent,
+      hash: "SHA-256",
+    },
+    true,
+    ["encrypt", "decrypt"],
+  )
+}
+
+export async function exportPublicKey(key: CryptoKey) {
+  return await crypto.subtle.exportKey('spki', key)
+}
+
+export async function exportPrivateKey(key: CryptoKey) {
+  return await crypto.subtle.exportKey('pkcs8', key)
+}
+
+export async function importKey(key: ArrayBuffer, type: "public"|"private") {
+  if (type === "public") {
+    return await importPublicKey(key)
+  } else {
+    return await importPrivateKey(key)
+  }
+}
+
+export async function exportKeyString(key: CryptoKey, type: "public"|"private"): Promise<string> {
+  if (type === "public") {
+    const k = await exportPublicKey(key)
+    return arrayBufferToBase64String(k)
+  } else {
+    const k = await exportPrivateKey(key)
+    return arrayBufferToBase64String(k)
+  }
+}
+
+export async function saveToLocalStorage(key: CryptoKey, type: "public"|"private") {
+  const k = await exportKeyString(key, type)
+  localStorage.setItem(type + "_key", k)
+}
+
+export async function loadFromLocalStorage(type: "public"|"private") {
+  const k = localStorage.getItem(type + "_key")
+  if (k) {
+    return await importKey(pemToArrayBuffer(k), type)
+  }
+  return undefined
+}
+
+export interface CurtainEncryption {
+  encrypted: boolean,
+  publicKey?: CryptoKey,
+  e2e: boolean,
+}
+
+export function arrayBufferToBase64String(arrayBuffer: ArrayBuffer) {
+  const byteArray = new Uint8Array(arrayBuffer)
+  let byteString = ''
+  for (let i=0; i<byteArray.byteLength; i++) {
+    byteString += String.fromCharCode(byteArray[i])
+  }
+  return btoa(byteString)
+}
+
+export function removeLines(str_data: string) {
+  return str_data.replace("\n", "");
+}
+
+export function base64ToArrayBuffer(b64: string) {
+  const byteString = atob(b64);
+  const byteArray = new Uint8Array(byteString.length);
+  for(let i=0; i < byteString.length; i++) {
+    byteArray[i] = byteString.charCodeAt(i);
+  }
+
+  return byteArray;
+}
+
+export function pemToArrayBuffer(pem: string) {
+  const b64Lines = removeLines(pem);
+  let b64Prefix = b64Lines.replace('-----BEGIN PRIVATE KEY-----', '');
+  b64Prefix = b64Prefix.replace('-----BEGIN PUBLIC KEY-----', '');
+  let b64Final = b64Prefix.replace('-----END PRIVATE KEY-----', '');
+  b64Final = b64Final.replace('-----END PUBLIC KEY-----', '');
+
+  return base64ToArrayBuffer(b64Final);
+}

package/src/index.ts

@@ -1,5 +1,27 @@
 import {CurtainWebAPI, replacer, reviver} from "./classes/curtain-api";
 import {User} from "./classes/curtain-user";
 import {getProteomicsData, getPrideData, getEBIAlpha, getInteractomeAtlas, getStringDBInteractions} from "./utilities";
-
-export {CurtainWebAPI, User, getProteomicsData, getPrideData, getEBIAlpha, getInteractomeAtlas, getStringDBInteractions, replacer, reviver};
+import {importKey, importPrivateKey, exportPrivateKey, exportKeyString, exportPublicKey, importPublicKey, CurtainEncryption, generateKeyPair, encryptDataRSA, decryptDataRSA, loadFromLocalStorage, saveToLocalStorage} from "./classes/curtain-encryption";
+export {
+  CurtainWebAPI,
+  User,
+  getProteomicsData,
+  getPrideData,
+  getEBIAlpha,
+  getInteractomeAtlas,
+  getStringDBInteractions,
+  replacer,
+  reviver,
+  importKey,
+  importPrivateKey,
+  exportPrivateKey,
+  exportKeyString,
+  exportPublicKey,
+  importPublicKey,
+  CurtainEncryption,
+  generateKeyPair,
+  encryptDataRSA,
+  decryptDataRSA,
+  loadFromLocalStorage,
+  saveToLocalStorage
+};