JS_Resolvers with MD5 hash functions

[ebisbe]

I'm using the Flickr API and needs HMAC-SHA1 to sign requests when dealing with user specific data. Right to make a simple call I have to invoke a lambda function. If we had hash functions I could generate the payload from the JS resolver. In a previous step I could get the SSM parameters for each user and then properly generate the hash without having to invoke a single lambda function.

I mentioned here but got lost #147 (comment)

[ansgarS]

I think I was able to write a md5 hash function in a JS resolver. First you need to have a mapping table for char codes in one file (please note that I am using TypeScript that is parsed into JS before it is deployed as JS resolver):

// charCodeTable.ts
const charCodeMappingDict: { [key: string]: number } = {
    A: 65,
    B: 66,
    C: 67,
    D: 68,
    E: 69,
    F: 70,
    G: 71,
    H: 72,
    // ...
    // map all you char codes you need in here  (dont forget to also add stuff like  "\n": 10 etc.
}

function charCodeAt(string: string, index: number) {
    return charCodeMappingDict[string[index]];
}

Then you need to have a replacement for the bitwise not operator and avoid any simple for loops:

// handler.ts
import { charCodeAt } from "./charCodeTable";

const arrayWith4Numbers = [0, 1, 2, 3];
const arrayWith15Numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
const arrayIncrementByFour = [0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60];

function bitwiseNot(num: number): number {
    return -(num + 1);
}

function md5cycle(x, k) {
    let a = x[0],
        b = x[1],
        c = x[2],
        d = x[3];

    a = ff(a, b, c, d, k[0], 7, -680876936);
    d = ff(d, a, b, c, k[1], 12, -389564586);
    c = ff(c, d, a, b, k[2], 17, 606105819);
    b = ff(b, c, d, a, k[3], 22, -1044525330);
    a = ff(a, b, c, d, k[4], 7, -176418897);
    d = ff(d, a, b, c, k[5], 12, 1200080426);
    c = ff(c, d, a, b, k[6], 17, -1473231341);
    b = ff(b, c, d, a, k[7], 22, -45705983);
    a = ff(a, b, c, d, k[8], 7, 1770035416);
    d = ff(d, a, b, c, k[9], 12, -1958414417);
    c = ff(c, d, a, b, k[10], 17, -42063);
    b = ff(b, c, d, a, k[11], 22, -1990404162);
    a = ff(a, b, c, d, k[12], 7, 1804603682);
    d = ff(d, a, b, c, k[13], 12, -40341101);
    c = ff(c, d, a, b, k[14], 17, -1502002290);
    b = ff(b, c, d, a, k[15], 22, 1236535329);

    a = gg(a, b, c, d, k[1], 5, -165796510);
    d = gg(d, a, b, c, k[6], 9, -1069501632);
    c = gg(c, d, a, b, k[11], 14, 643717713);
    b = gg(b, c, d, a, k[0], 20, -373897302);
    a = gg(a, b, c, d, k[5], 5, -701558691);
    d = gg(d, a, b, c, k[10], 9, 38016083);
    c = gg(c, d, a, b, k[15], 14, -660478335);
    b = gg(b, c, d, a, k[4], 20, -405537848);
    a = gg(a, b, c, d, k[9], 5, 568446438);
    d = gg(d, a, b, c, k[14], 9, -1019803690);
    c = gg(c, d, a, b, k[3], 14, -187363961);
    b = gg(b, c, d, a, k[8], 20, 1163531501);
    a = gg(a, b, c, d, k[13], 5, -1444681467);
    d = gg(d, a, b, c, k[2], 9, -51403784);
    c = gg(c, d, a, b, k[7], 14, 1735328473);
    b = gg(b, c, d, a, k[12], 20, -1926607734);

    a = hh(a, b, c, d, k[5], 4, -378558);
    d = hh(d, a, b, c, k[8], 11, -2022574463);
    c = hh(c, d, a, b, k[11], 16, 1839030562);
    b = hh(b, c, d, a, k[14], 23, -35309556);
    a = hh(a, b, c, d, k[1], 4, -1530992060);
    d = hh(d, a, b, c, k[4], 11, 1272893353);
    c = hh(c, d, a, b, k[7], 16, -155497632);
    b = hh(b, c, d, a, k[10], 23, -1094730640);
    a = hh(a, b, c, d, k[13], 4, 681279174);
    d = hh(d, a, b, c, k[0], 11, -358537222);
    c = hh(c, d, a, b, k[3], 16, -722521979);
    b = hh(b, c, d, a, k[6], 23, 76029189);
    a = hh(a, b, c, d, k[9], 4, -640364487);
    d = hh(d, a, b, c, k[12], 11, -421815835);
    c = hh(c, d, a, b, k[15], 16, 530742520);
    b = hh(b, c, d, a, k[2], 23, -995338651);

    a = ii(a, b, c, d, k[0], 6, -198630844);
    d = ii(d, a, b, c, k[7], 10, 1126891415);
    c = ii(c, d, a, b, k[14], 15, -1416354905);
    b = ii(b, c, d, a, k[5], 21, -57434055);
    a = ii(a, b, c, d, k[12], 6, 1700485571);
    d = ii(d, a, b, c, k[3], 10, -1894986606);
    c = ii(c, d, a, b, k[10], 15, -1051523);
    b = ii(b, c, d, a, k[1], 21, -2054922799);
    a = ii(a, b, c, d, k[8], 6, 1873313359);
    d = ii(d, a, b, c, k[15], 10, -30611744);
    c = ii(c, d, a, b, k[6], 15, -1560198380);
    b = ii(b, c, d, a, k[13], 21, 1309151649);
    a = ii(a, b, c, d, k[4], 6, -145523070);
    d = ii(d, a, b, c, k[11], 10, -1120210379);
    c = ii(c, d, a, b, k[2], 15, 718787259);
    b = ii(b, c, d, a, k[9], 21, -343485551);

    x[0] = add32(a, x[0]);
    x[1] = add32(b, x[1]);
    x[2] = add32(c, x[2]);
    x[3] = add32(d, x[3]);
}

function cmn(q, a, b, x, s, t) {
    a = add32(add32(a, q), add32(x, t));
    return add32((a << s) | (a >>> (32 - s)), b);
}

function ff(a, b, c, d, x, s, t) {
    return cmn((b & c) | (bitwiseNot(b) & d), a, b, x, s, t);
}

function gg(a, b, c, d, x, s, t) {
    return cmn((b & d) | (c & bitwiseNot(d)), a, b, x, s, t);
}

function hh(a, b, c, d, x, s, t) {
    return cmn(b ^ c ^ d, a, b, x, s, t);
}

function ii(a, b, c, d, x, s, t) {
    return cmn(c ^ (b | bitwiseNot(d)), a, b, x, s, t);
}

function md51(s: string) {
    const n = s.length,
        state = [1732584193, -271733879, -1732584194, 271733878];
    let i = 64;

    for (const {} of s) {
        if (i > s.length) break;
        md5cycle(state, md5blk(s.substring(i - 64, i)));
        i = i + 64;
    }

    s = s.substring(i - 64);
    const tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
    i = 0;
    for (const {} of s) {
        tail[i >> 2] |= charCodeAt(s, i) << (i % 4 << 3);
        i = i + 1;
    }

    tail[i >> 2] |= 0x80 << (i % 4 << 3);
    if (i > 55) {
        md5cycle(state, tail);
        for (const bit of arrayWith15Numbers) {
            tail[bit] = 0;
        }
    }
    tail[14] = n * 8;
    md5cycle(state, tail);
    return state;
}

function md5blk(s) {
    const md5blks = [];
    for (const i of arrayIncrementByFour) {
        md5blks[i >> 2] =
            charCodeAt(s, i) +
            (charCodeAt(s, i + 1) << 8) +
            (charCodeAt(s, i + 2) << 16) +
            (charCodeAt(s, i + 3) << 24);
    }
    return md5blks;
}

const hex_chr = "0123456789abcdef".split("");

function rhex(n) {
    let s = "";

    for (const j of arrayWith4Numbers) {
        s += hex_chr[(n >> (j * 8 + 4)) & 0x0f] + hex_chr[(n >> (j * 8)) & 0x0f];
    }

    return s;
}

function hex(x: (number | string)[]) {
    let i = 0;
    for (const {} of x) {
        x[i] = rhex(x[i]);
        i = i + 1;
    }
    return x.join("");
}

export function md5(s: string) {
    return hex(md51(s));
}

function add32(x, y) {
    const lsw = (x & 0xffff) + (y & 0xffff),
        msw = (x >> 16) + (y >> 16) + (lsw >> 16);
    return (msw << 16) | (lsw & 0xffff);
}

export function request(_: unknown): Record<string, unknown> {
    return {
        success: true,
        md5: md5("test"),
        md5Complex: md5(
            JSON.stringify({
                test: "test",
                num: 1,
                someArray: [1, 2, 3],
                someNestedArray: [{ a: 1 }, { b: 2 }],
            })
        ),
    };
}

export function response(ctx: { result: boolean }) {
    return {
        // your response
    };
}

I tested it with the evaluateCode function from AWS and compared against the crypto library md5 function and couldnt find any issues until now.

[ebisbe]

Thanks @ansgarS I will try that!

[ebisbe]

Thanks for the tip @ansgarS ! A few months ago thanks to the IA I could manage to make the hash function and I could remove an unneeded or unnecessary lambda.
I just started refactoring the code I had, which was a copy paste of a md5 hash code.