curtain-web-api 1.0.76 → 1.0.78

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

@@ -178,7 +178,7 @@ export declare class CurtainWebAPI {
     addOwner(linkId: string, owner: string): Promise<import("axios").AxiosResponse<any, any, {}>>;
     removeOwner(linkId: string, owner: string): Promise<import("axios").AxiosResponse<any, any, {}>>;
     getCurtainLinks(username: string, sessionDescription?: string, offset?: number, sessionType?: string): Promise<import("axios").AxiosResponse<any, any, {}>>;
-    getSiteProperties(): Promise<import("axios").AxiosResponse<SiteProperties, any, {}>>;
+    getSiteProperties(appType?: string): Promise<import("axios").AxiosResponse<SiteProperties, any, {}>>;
     saveDataFilterList(name: string, data: string, category?: string): Promise<import("axios").AxiosResponse<any, any, {}>>;
     getDataFilterListByID(id: number, limit?: number): Promise<import("axios").AxiosResponse<any, any, {}>>;
     getDataFilterList(title?: string, searchTerm?: string, category?: string, limit?: number, offset?: number): Promise<import("axios").AxiosResponse<any, any, {}>>;

package/build/classes/curtain-api.js

@@ -1,6 +1,6 @@
 import { User } from "./curtain-user";
 import axios, { AxiosHeaders } from "axios";
-import { arrayBufferToBase64String, base64ToArrayBuffer, encryptAESData, encryptAESKey, exportAESKey, generateAESKey } from "./curtain-encryption";
+import { arrayBufferToBase64String, base64ToArrayBuffer, decodeJWTPayload, encryptAESData, encryptAESKey, exportAESKey, generateAESKey } from "./curtain-encryption";
 const base = "https://celsus.muttsu.xyz/";
 export const replacer = (key, value) => {
     if (value instanceof Map) {
@@ -175,6 +175,12 @@ export class CurtainWebAPI {
         });
     }
     checkIfRefreshTokenExpired() {
+        if (this.user.refresh_token) {
+            const payload = decodeJWTPayload(this.user.refresh_token);
+            if (payload && payload.exp) {
+                return Date.now() >= payload.exp * 1000;
+            }
+        }
         let now = new Date();
         let diff = (now.getTime() - this.user.lastRefreshTokenUpdate.getTime()) / 1000;
         diff = diff / 60 / 60;
@@ -414,10 +420,14 @@ export class CurtainWebAPI {
             return response;
         });
     }
-    getSiteProperties() {
+    getSiteProperties(appType) {
         let headers = new AxiosHeaders();
         headers["Accept"] = "application/json";
-        return this.axiosInstance.get(this.baseURL + "site-properties/", { headers: headers, responseType: "json" });
+        let params = new URLSearchParams();
+        if (appType) {
+            params.append("app", appType);
+        }
+        return this.axiosInstance.get(this.baseURL + "site-properties/", { headers: headers, params: params, responseType: "json" });
     }
     saveDataFilterList(name, data, category = "") {
         let headers = new AxiosHeaders();

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

@@ -37,3 +37,4 @@ export declare function encryptDataAES(data: string, publicKey: CryptoKey): Prom
 }>;
 export declare function decryptDataAES(encryptedKey: ArrayBuffer, encryptedData: string, iv: string, privateKey: CryptoKey): Promise<string>;
 export declare function hashData(data: string): Promise<string>;
+export declare function decodeJWTPayload(token: string): any;

package/build/classes/curtain-encryption.js

@@ -137,3 +137,24 @@ export async function hashData(data) {
     const hash = await crypto.subtle.digest("SHA-256", encoded);
     return arrayBufferToBase64String(hash);
 }
+export function decodeJWTPayload(token) {
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 3) {
+            return null;
+        }
+        const base64Url = parts[1];
+        let base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
+        const pad = base64.length % 4;
+        if (pad) {
+            base64 += new Array(5 - pad).join('=');
+        }
+        const jsonPayload = decodeURIComponent(atob(base64).split('').map(function (c) {
+            return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
+        }).join(''));
+        return JSON.parse(jsonPayload);
+    }
+    catch (e) {
+        return null;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "curtain-web-api",
-  "version": "1.0.76",
+  "version": "1.0.78",
   "description": "",
   "type": "module",
   "main": "./build/index.js",

package/src/classes/curtain-api.ts

@@ -3,6 +3,7 @@ import axios, {AxiosHeaders} from "axios";
 import {
     arrayBufferToBase64String, base64ToArrayBuffer,
     CurtainEncryption,
+    decodeJWTPayload,
     encryptAESData, encryptAESKey,
     encryptDataRSA, exportAESKey,
     generateAESKey
@@ -357,6 +358,12 @@ export class CurtainWebAPI {
     }
 
     checkIfRefreshTokenExpired() {
+        if (this.user.refresh_token) {
+            const payload = decodeJWTPayload(this.user.refresh_token);
+            if (payload && payload.exp) {
+                return Date.now() >= payload.exp * 1000;
+            }
+        }
         let now = new Date();
         let diff = (now.getTime() - this.user.lastRefreshTokenUpdate.getTime()) / 1000;
         diff = diff/60/60;
@@ -610,10 +617,14 @@ export class CurtainWebAPI {
         });
     }
 
-    getSiteProperties() {
+    getSiteProperties(appType?: string) {
         let headers = new AxiosHeaders();
         headers["Accept"] = "application/json";
-        return this.axiosInstance.get<SiteProperties>(this.baseURL + "site-properties/", {headers: headers, responseType:"json"});
+        let params = new URLSearchParams();
+        if (appType) {
+            params.append("app", appType);
+        }
+        return this.axiosInstance.get<SiteProperties>(this.baseURL + "site-properties/", {headers: headers, params: params, responseType:"json"});
     }
 
     saveDataFilterList(name: string, data: string, category: string = "") {

package/src/classes/curtain-encryption.ts

@@ -1,176 +1,198 @@
-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",
-    } as RsaHashedKeyGenParams,
-    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): ArrayBuffer {
-  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.buffer;
-}
-
-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);
-}
-
-// a function to generate to encrypt an aes key arraybuffer with a public key
-export async function encryptAESKey(publicKey: CryptoKey, aesKey: ArrayBuffer) {
-  return await crypto.subtle.encrypt({name: "RSA-OAEP"}, publicKey, aesKey)
-}
-
-// a function to generate an aes key in GCM mode with a length of 256 bits
-export async function generateAESKey() {
-  return await crypto.subtle.generateKey(
-    {
-      name: "AES-GCM",
-      length: 256,
-    },
-    true,
-    ["encrypt", "decrypt"],
-  )
-}
-
-// a function to encrypt a string with an aes key
-export async function encryptAESData(aesKey: CryptoKey, data: string) {
-  const iv = crypto.getRandomValues(new Uint8Array(12))
-  const enc = new TextEncoder()
-  const encoded = enc.encode(data)
-  const encrypted = await crypto.subtle.encrypt({name: "AES-GCM", iv: iv}, aesKey, encoded)
-  return {encrypted: arrayBufferToBase64String(encrypted), iv: arrayBufferToBase64String(iv.buffer)}
-}
-
-// a function to decrypt a string with an aes key
-export async function decryptAESData(aesKey: CryptoKey, data: string, iv: string) {
-  const dec = new TextDecoder()
-  const decrypted = await crypto.subtle.decrypt({name: "AES-GCM", iv: base64ToArrayBuffer(iv)}, aesKey, base64ToArrayBuffer(data))
-  return dec.decode(decrypted)
-}
-
-// a function to decrypt an aes key with a private key
-export async function decryptAESKey(privateKey: CryptoKey, encryptedKey: ArrayBuffer) {
-  return await crypto.subtle.decrypt({name: "RSA-OAEP"}, privateKey, encryptedKey)
-}
-
-// a function to export an aes key to a string
-export async function exportAESKey(key: CryptoKey) {
-  return await crypto.subtle.exportKey("raw", key)
-}
-// a function to import an aes key from a string
-export async function importAESKey(key: ArrayBuffer) {
-  return await crypto.subtle.importKey("raw", key, "AES-GCM", true, ["encrypt", "decrypt"])
-}
-
-// a function to encrypt aes key with a public key and also use the aes key to encrypt a large string then return the encrypted aes key and the encrypted string
-export async function encryptDataAES(data: string, publicKey: CryptoKey) {
-  const aesKey = await generateAESKey()
-  const encryptedKey = await encryptAESKey(publicKey, await exportAESKey(aesKey))
-  const encryptedData = await encryptAESData(aesKey, data)
-  return {encryptedKey: arrayBufferToBase64String(encryptedKey), encryptedData: encryptedData}
-}
-
-// a function to decrypt an aes key with a private key and use the aes key to decrypt a large string
-export async function decryptDataAES(encryptedKey: ArrayBuffer, encryptedData: string, iv: string, privateKey: CryptoKey) {
-  const aesKey = await decryptAESKey(privateKey, encryptedKey)
-  //import aes key
-  return await decryptAESData(await importAESKey(aesKey), encryptedData, iv)
-}
-
-// a function to calculate sha-256 hash of a large string
-export async function hashData(data: string) {
-  const enc = new TextEncoder()
-  const encoded = enc.encode(data)
-  const hash = await crypto.subtle.digest("SHA-256", encoded)
-  return arrayBufferToBase64String(hash)
-}
+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",
+    } as RsaHashedKeyGenParams,
+    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): ArrayBuffer {
+  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.buffer;
+}
+
+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);
+}
+
+// a function to generate to encrypt an aes key arraybuffer with a public key
+export async function encryptAESKey(publicKey: CryptoKey, aesKey: ArrayBuffer) {
+  return await crypto.subtle.encrypt({name: "RSA-OAEP"}, publicKey, aesKey)
+}
+
+// a function to generate an aes key in GCM mode with a length of 256 bits
+export async function generateAESKey() {
+  return await crypto.subtle.generateKey(
+    {
+      name: "AES-GCM",
+      length: 256,
+    },
+    true,
+    ["encrypt", "decrypt"],
+  )
+}
+
+// a function to encrypt a string with an aes key
+export async function encryptAESData(aesKey: CryptoKey, data: string) {
+  const iv = crypto.getRandomValues(new Uint8Array(12))
+  const enc = new TextEncoder()
+  const encoded = enc.encode(data)
+  const encrypted = await crypto.subtle.encrypt({name: "AES-GCM", iv: iv}, aesKey, encoded)
+  return {encrypted: arrayBufferToBase64String(encrypted), iv: arrayBufferToBase64String(iv.buffer)}
+}
+
+// a function to decrypt a string with an aes key
+export async function decryptAESData(aesKey: CryptoKey, data: string, iv: string) {
+  const dec = new TextDecoder()
+  const decrypted = await crypto.subtle.decrypt({name: "AES-GCM", iv: base64ToArrayBuffer(iv)}, aesKey, base64ToArrayBuffer(data))
+  return dec.decode(decrypted)
+}
+
+// a function to decrypt an aes key with a private key
+export async function decryptAESKey(privateKey: CryptoKey, encryptedKey: ArrayBuffer) {
+  return await crypto.subtle.decrypt({name: "RSA-OAEP"}, privateKey, encryptedKey)
+}
+
+// a function to export an aes key to a string
+export async function exportAESKey(key: CryptoKey) {
+  return await crypto.subtle.exportKey ("raw", key)
+}
+// a function to import an aes key from a string
+export async function importAESKey(key: ArrayBuffer) {
+  return await crypto.subtle.importKey("raw", key, "AES-GCM", true, ["encrypt", "decrypt"])
+}
+
+// a function to encrypt aes key with a public key and also use the aes key to encrypt a large string then return the encrypted aes key and the encrypted string
+export async function encryptDataAES(data: string, publicKey: CryptoKey) {
+  const aesKey = await generateAESKey()
+  const encryptedKey = await encryptAESKey(publicKey, await exportAESKey(aesKey))
+  const encryptedData = await encryptAESData(aesKey, data)
+  return {encryptedKey: arrayBufferToBase64String(encryptedKey), encryptedData: encryptedData}
+}
+
+// a function to decrypt an aes key with a private key and use the aes key to decrypt a large string
+export async function decryptDataAES(encryptedKey: ArrayBuffer, encryptedData: string, iv: string, privateKey: CryptoKey) {
+  const aesKey = await decryptAESKey(privateKey, encryptedKey)
+  //import aes key
+  return await decryptAESData(await importAESKey(aesKey), encryptedData, iv)
+}
+
+// a function to calculate sha-256 hash of a large string
+export async function hashData(data: string) {
+  const enc = new TextEncoder()
+  const encoded = enc.encode(data)
+  const hash = await crypto.subtle.digest("SHA-256", encoded)
+  return arrayBufferToBase64String(hash)
+}
+
+export function decodeJWTPayload(token: string) {
+  try {
+    const parts = token.split('.');
+    if (parts.length !== 3) {
+      return null;
+    }
+    const base64Url = parts[1];
+    let base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
+    const pad = base64.length % 4;
+    if (pad) {
+      base64 += new Array(5 - pad).join('=');
+    }
+    const jsonPayload = decodeURIComponent(atob(base64).split('').map(function(c) {
+      return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
+    }).join(''));
+
+    return JSON.parse(jsonPayload);
+  } catch (e) {
+    return null;
+  }
+}