skapi-js 0.0.46 → 0.0.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skapi-js",
-  "version": "0.0.46",
+  "version": "0.0.47",
   "description": "skapi serverless cloud javascript library",
   "main": "./dist/skapi.module.js",
   "scripts": {

package/src/decorators.ts

@@ -1,6 +1,6 @@
 import { Form, FormCallbacks } from './Types';
 import SkapiError from './skapi_error';
-import { sha256 } from './utils';
+import { MD5 } from './utils';
 
 function formResponse() {
     // wraps methods that requires form handling
@@ -29,8 +29,8 @@ function formResponse() {
 
                 // form element action
                 let href = new URL(form.action);
-                // let response_key = sha256(form.action);
-                let response_key = form.action;
+                let response_key = MD5.hash(form.action);
+                // let response_key = form.action;
                 let timestamp = Date.now().toString();
 
                 window.sessionStorage.setItem(response_key, JSON.stringify({ [timestamp]: response }));

package/src/skapi.ts

@@ -34,7 +34,7 @@ import {
     validateUrl,
     normalize_record_data,
     checkWhiteSpaceAndSpecialChars,
-    sha256
+    MD5
 } from './utils';
 
 type StartKeys = {
@@ -1157,10 +1157,10 @@ export default class Skapi {
                     return _obj;
                 }
 
-                return url + '/' + JSON.stringify(orderObjectKeys(params));
+                return MD5.hash(url + '/' + JSON.stringify(orderObjectKeys(params)));
             }
 
-            return url + '/' + this.service;
+            return MD5.hash(url + '/' + this.service);
 
         })();
 
@@ -1175,8 +1175,8 @@ export default class Skapi {
             if (Array.isArray(this.__startKey_keys[url][hashedParams]) && this.__startKey_keys[url][hashedParams].length) {
                 // delete cache of all startkeys
                 for (let p of this.__startKey_keys[url][hashedParams]) {
-                    // let hashedParams_cached = hashedParams + '/' + sha256(JSON.stringify(p));
-                    let hashedParams_cached = hashedParams + '/' + JSON.stringify(p);
+                    let hashedParams_cached = hashedParams + '/' + MD5.hash(JSON.stringify(p));
+                    // let hashedParams_cached = hashedParams + '/' + JSON.stringify(p);
                     // let hashedParams_cached = hashedParams + createHash('sha256').update(JSON.stringify(p)).digest('hex');
 
                     if (this.__cached_requests?.[url] && this.__cached_requests?.[url]?.[hashedParams_cached]) {
@@ -1214,8 +1214,8 @@ export default class Skapi {
 
             else {
                 // cache_hashedParams += createHash('sha256').update(last_startKey_key).digest('hex');
-                // cache_hashedParams += sha256(last_startKey_key);
-                cache_hashedParams += ('/' + last_startKey_key);
+                cache_hashedParams += MD5.hash(last_startKey_key);
+                // cache_hashedParams += ('/' + last_startKey_key);
                 params.startKey = JSON.parse(last_startKey_key);
             }
         }
@@ -1437,7 +1437,7 @@ export default class Skapi {
         if (!option) {
             throw new SkapiError(['INVALID_PARAMETER', '"option" argument is required.']);
         }
-        
+
         let { formData } = option;
         let fetchOptions: Record<string, any> = {};
 

package/src/utils.ts

@@ -1,105 +1,163 @@
 import SkapiError from "./skapi_error";
 import { RecordData, Form } from "./Types";
 
-const sha256: any = function sha256(ascii) {
-    function rightRotate(value, amount) {
-        return (value >>> amount) | (value << (32 - amount));
-    };
+class MD5 {
+    private static readonly alphabet = '0123456789abcdef';
+
+    public static hash(str?: string): string {
+        if (typeof str !== 'string') {
+            console.warn('coercing non-string value to empty string');
+            str = '';
+        }
+
+        const x = MD5.sb(str);
+        let a = 1732584193;
+        let b = -271733879;
+        let c = -1732584194;
+        let d = 271733878;
+        let lastA;
+        let lastB;
+        let lastC;
+        let lastD;
+        for (let i = 0; i < x.length; i += 16) {
+            lastA = a;
+            lastB = b;
+            lastC = c;
+            lastD = d;
+
+            a = MD5.ff(a, b, c, d, x[i], 7, -680876936);
+            d = MD5.ff(d, a, b, c, x[i + 1], 12, -389564586);
+            c = MD5.ff(c, d, a, b, x[i + 2], 17, 606105819);
+            b = MD5.ff(b, c, d, a, x[i + 3], 22, -1044525330);
+            a = MD5.ff(a, b, c, d, x[i + 4], 7, -176418897);
+            d = MD5.ff(d, a, b, c, x[i + 5], 12, 1200080426);
+            c = MD5.ff(c, d, a, b, x[i + 6], 17, -1473231341);
+            b = MD5.ff(b, c, d, a, x[i + 7], 22, -45705983);
+            a = MD5.ff(a, b, c, d, x[i + 8], 7, 1770035416);
+            d = MD5.ff(d, a, b, c, x[i + 9], 12, -1958414417);
+            c = MD5.ff(c, d, a, b, x[i + 10], 17, -42063);
+            b = MD5.ff(b, c, d, a, x[i + 11], 22, -1990404162);
+            a = MD5.ff(a, b, c, d, x[i + 12], 7, 1804603682);
+            d = MD5.ff(d, a, b, c, x[i + 13], 12, -40341101);
+            c = MD5.ff(c, d, a, b, x[i + 14], 17, -1502002290);
+            b = MD5.ff(b, c, d, a, x[i + 15], 22, 1236535329);
+            a = MD5.gg(a, b, c, d, x[i + 1], 5, -165796510);
+            d = MD5.gg(d, a, b, c, x[i + 6], 9, -1069501632);
+            c = MD5.gg(c, d, a, b, x[i + 11], 14, 643717713);
+            b = MD5.gg(b, c, d, a, x[i], 20, -373897302);
+            a = MD5.gg(a, b, c, d, x[i + 5], 5, -701558691);
+            d = MD5.gg(d, a, b, c, x[i + 10], 9, 38016083);
+            c = MD5.gg(c, d, a, b, x[i + 15], 14, -660478335);
+            b = MD5.gg(b, c, d, a, x[i + 4], 20, -405537848);
+            a = MD5.gg(a, b, c, d, x[i + 9], 5, 568446438);
+            d = MD5.gg(d, a, b, c, x[i + 14], 9, -1019803690);
+            c = MD5.gg(c, d, a, b, x[i + 3], 14, -187363961);
+            b = MD5.gg(b, c, d, a, x[i + 8], 20, 1163531501);
+            a = MD5.gg(a, b, c, d, x[i + 13], 5, -1444681467);
+            d = MD5.gg(d, a, b, c, x[i + 2], 9, -51403784);
+            c = MD5.gg(c, d, a, b, x[i + 7], 14, 1735328473);
+            b = MD5.gg(b, c, d, a, x[i + 12], 20, -1926607734);
+            a = MD5.hh(a, b, c, d, x[i + 5], 4, -378558);
+            d = MD5.hh(d, a, b, c, x[i + 8], 11, -2022574463);
+            c = MD5.hh(c, d, a, b, x[i + 11], 16, 1839030562);
+            b = MD5.hh(b, c, d, a, x[i + 14], 23, -35309556);
+            a = MD5.hh(a, b, c, d, x[i + 1], 4, -1530992060);
+            d = MD5.hh(d, a, b, c, x[i + 4], 11, 1272893353);
+            c = MD5.hh(c, d, a, b, x[i + 7], 16, -155497632);
+            b = MD5.hh(b, c, d, a, x[i + 10], 23, -1094730640);
+            a = MD5.hh(a, b, c, d, x[i + 13], 4, 681279174);
+            d = MD5.hh(d, a, b, c, x[i], 11, -358537222);
+            c = MD5.hh(c, d, a, b, x[i + 3], 16, -722521979);
+            b = MD5.hh(b, c, d, a, x[i + 6], 23, 76029189);
+            a = MD5.hh(a, b, c, d, x[i + 9], 4, -640364487);
+            d = MD5.hh(d, a, b, c, x[i + 12], 11, -421815835);
+            c = MD5.hh(c, d, a, b, x[i + 15], 16, 530742520);
+            b = MD5.hh(b, c, d, a, x[i + 2], 23, -995338651);
+            a = MD5.ii(a, b, c, d, x[i], 6, -198630844);
+            d = MD5.ii(d, a, b, c, x[i + 7], 10, 1126891415);
+            c = MD5.ii(c, d, a, b, x[i + 14], 15, -1416354905);
+            b = MD5.ii(b, c, d, a, x[i + 5], 21, -57434055);
+            a = MD5.ii(a, b, c, d, x[i + 12], 6, 1700485571);
+            d = MD5.ii(d, a, b, c, x[i + 3], 10, -1894986606);
+            c = MD5.ii(c, d, a, b, x[i + 10], 15, -1051523);
+            b = MD5.ii(b, c, d, a, x[i + 1], 21, -2054922799);
+            a = MD5.ii(a, b, c, d, x[i + 8], 6, 1873313359);
+            d = MD5.ii(d, a, b, c, x[i + 15], 10, -30611744);
+            c = MD5.ii(c, d, a, b, x[i + 6], 15, -1560198380);
+            b = MD5.ii(b, c, d, a, x[i + 13], 21, 1309151649);
+            a = MD5.ii(a, b, c, d, x[i + 4], 6, -145523070);
+            d = MD5.ii(d, a, b, c, x[i + 11], 10, -1120210379);
+            c = MD5.ii(c, d, a, b, x[i + 2], 15, 718787259);
+            b = MD5.ii(b, c, d, a, x[i + 9], 21, -343485551);
+
+            a = MD5.ad(a, lastA);
+            b = MD5.ad(b, lastB);
+            c = MD5.ad(c, lastC);
+            d = MD5.ad(d, lastD);
+        }
+
+        return MD5.rh(a) + MD5.rh(b) + MD5.rh(c) + MD5.rh(d);
+    }
+
+    private static rh(n: number): string {
+        let s = '';
+        for (let j = 0; j <= 3; j++) {
+            s += MD5.alphabet.charAt((n >> (j * 8 + 4)) & 0x0F) + MD5.alphabet.charAt((n >> (j * 8)) & 0x0F);
+        }
+
+        return s;
+    }
+
+    private static ad(x: number, y: number): number {
+        const l = (x & 0xFFFF) + (y & 0xFFFF);
+        const m = (x >> 16) + (y >> 16) + (l >> 16);
+
+        return (m << 16) | (l & 0xFFFF);
+    }
+
+    private static rl(n: number, c: number): number {
+        return (n << c) | (n >>> (32 - c));
+    }
+
+    private static cm(q: number, a: number, b: number, x: number, s: number, t: number): number {
+        return MD5.ad(MD5.rl(MD5.ad(MD5.ad(a, q), MD5.ad(x, t)), s), b);
+    }
+
+    private static ff(a: number, b: number, c: number, d: number, x: number, s: number, t: number): number {
+        return MD5.cm(b & c | ~b & d, a, b, x, s, t);
+    }
+
+    private static gg(a: number, b: number, c: number, d: number, x: number, s: number, t: number): number {
+        return MD5.cm(b & d | c & ~d, a, b, x, s, t);
+    }
 
-    let mathPow = Math.pow;
-    let maxWord = mathPow(2, 32);
-    let lengthProperty = 'length';
-    let i, j; // Used as a counter across the whole file
-    let result = '';
-
-    let words = [];
-    let asciiBitLength = ascii[lengthProperty] * 8;
-
-    //* caching results is optional - remove/add slash from front of this line to toggle
-    // Initial hash value: first 32 bits of the fractional parts of the square roots of the first 8 primes
-    // (we actually calculate the first 64, but extra values are just ignored)
-    let hash = (sha256 as any).h = (sha256 as any).h || [];
-    // Round constants: first 32 bits of the fractional parts of the cube roots of the first 64 primes
-    let k = (sha256 as any).k = (sha256 as any).k || [];
-    let primeCounter = k[lengthProperty];
-    /*/
-    let hash = [], k = [];
-    let primeCounter = 0;
-    //*/
-
-    let isComposite = {};
-    for (let candidate = 2; primeCounter < 64; candidate++) {
-        if (!isComposite[candidate]) {
-            for (i = 0; i < 313; i += candidate) {
-                isComposite[i] = candidate;
-            }
-            hash[primeCounter] = (mathPow(candidate, .5) * maxWord) | 0;
-            k[primeCounter++] = (mathPow(candidate, 1 / 3) * maxWord) | 0;
-        }
+    private static hh(a: number, b: number, c: number, d: number, x: number, s: number, t: number): number {
+        return MD5.cm(b ^ c ^ d, a, b, x, s, t);
     }
 
-    ascii += '\x80'; // Append Ƈ' bit (plus zero padding)
-    while (ascii[lengthProperty] % 64 - 56) ascii += '\x00'; // More zero padding
-    for (i = 0; i < ascii[lengthProperty]; i++) {
-        j = ascii.charCodeAt(i);
-        if (j >> 8) {
-            return; // ASCII check: only accept characters in range 0-255
-        }
-        words[i >> 2] |= j << ((3 - i) % 4) * 8;
+    private static ii(a: number, b: number, c: number, d: number, x: number, s: number, t: number): number {
+        return MD5.cm(c ^ (b | ~d), a, b, x, s, t);
     }
-    words[words[lengthProperty]] = ((asciiBitLength / maxWord) | 0);
-    words[words[lengthProperty]] = (asciiBitLength);
-
-    // process each chunk
-    for (j = 0; j < words[lengthProperty];) {
-        let w = words.slice(j, j += 16); // The message is expanded into 64 words as part of the iteration
-        let oldHash = hash;
-        // This is now the undefinedworking hash", often labelled as variables a...g
-        // (we have to truncate as well, otherwise extra entries at the end accumulate
-        hash = hash.slice(0, 8);
-
-        for (i = 0; i < 64; i++) {
-            let i2 = i + j;
-            // Expand the message into 64 words
-            // Used below if 
-            let w15 = w[i - 15], w2 = w[i - 2];
 
-            // Iterate
-            let a = hash[0], e = hash[4];
-            let temp1 = hash[7]
-                + (rightRotate(e, 6) ^ rightRotate(e, 11) ^ rightRotate(e, 25)) // S1
-                + ((e & hash[5]) ^ ((~e) & hash[6])) // ch
-                + k[i]
-                // Expand the message schedule if needed
-                + (w[i] = (i < 16) ? w[i] : (
-                    w[i - 16]
-                    + (rightRotate(w15, 7) ^ rightRotate(w15, 18) ^ (w15 >>> 3)) // s0
-                    + w[i - 7]
-                    + (rightRotate(w2, 17) ^ rightRotate(w2, 19) ^ (w2 >>> 10)) // s1
-                ) | 0
-                );
-            // This is only used once, so *could* be moved below, but it only saves 4 bytes and makes things unreadble
-            let temp2 = (rightRotate(a, 2) ^ rightRotate(a, 13) ^ rightRotate(a, 22)) // S0
-                + ((a & hash[1]) ^ (a & hash[2]) ^ (hash[1] & hash[2])); // maj
+    private static sb(x: string): number[] {
+        let i;
+        const numBlocks = ((x.length + 8) >> 6) + 1;
 
-            hash = [(temp1 + temp2) | 0].concat(hash); // We don't bother trimming off the extra ones, they're harmless as long as we're truncating when we do the slice()
-            hash[4] = (hash[4] + temp1) | 0;
+        const blocks = new Array(numBlocks * 16);
+        for (i = 0; i < numBlocks * 16; i++) {
+            blocks[i] = 0;
         }
 
-        for (i = 0; i < 8; i++) {
-            hash[i] = (hash[i] + oldHash[i]) | 0;
+        for (i = 0; i < x.length; i++) {
+            blocks[i >> 2] |= x.charCodeAt(i) << ((i % 4) * 8);
         }
-    }
 
-    for (i = 0; i < 8; i++) {
-        for (j = 3; j + 1; j--) {
-            let b = (hash[i] >> (j * 8)) & 255;
-            result += ((b < 16) ? 0 : '') + b.toString(16);
-        }
-    }
+        blocks[i >> 2] |= 0x80 << ((i % 4) * 8);
+        blocks[numBlocks * 16 - 2] = x.length * 8;
 
-    return result;
-};
+        return blocks;
+    }
+}
 
 function checkParams(
     params: any,
@@ -566,14 +624,20 @@ function validateUrl(url: string | string[]) {
 }
 
 function normalize_record_data<T extends RecordData>(record: T): RecordData {
+    function base_decode(chars) {
+        let charset = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+        return chars.split('').reverse().reduce((prev, curr, i) =>
+            prev + (charset.indexOf(curr) * (62 ** i)), 0);
+    }
     const output: Record<any, any> = {};
 
     const keys = {
         'rec': (r) => {
             if (!r) return;
             output.record_id = r;
-            let base36timestamp = r.substring(0, 8);
-            output.uploaded = parseInt(base36timestamp, 36);
+            let base62timestamp = r.substring(0, r.length - 9); // id: [base62 timestamp][random 5 char][suid]
+            let uploaded = base_decode(base62timestamp);
+            output.uploaded = uploaded;
         },
         'usr': (r) => {
             if (!r) return;
@@ -735,5 +799,5 @@ export {
     validatePassword,
     validatePhoneNumber,
     validateUrl,
-    sha256
+    MD5
 };