javascript unicode base64 encode

Question

I'm trying to convert a string to unicode and then base64 encode it in javascript but can't seem to find out how. I need it to encode my PowerShell commands so i can use -EncodedCommand command line parameter in my VMware Orchestrator project.

$cmd = 'New-Item -Path "C:\" -Name "Test" -ItemType Directory'
$bytes = [Text.Encoding]::Unicode.GetBytes($cmd)
$encodedCommand = [Convert]::ToBase64String($bytes)

The output looks like this: TgBlAHcALQBJAHQAZQBtACAALQBQAGEAdABoACAAIgBDADoAXAAiACAALQBOAGEAbQBlACAAIgBUAGUAcwB0ACIAIAAtAEkAdABlAG0AVAB5AHAAZQAgAEQAaQByAGUAYwB0AG8AcgB5AA==

How can I do this in javascript?

JavaScript doesn't really let you choose encodings for String.. I can achieve TmV3LUl0ZW0gLVBhdGggIkM6XCIgLU5hbWUgIlRlc3QiIC1JdGVtVHlwZSBEaXJlY3Rvcnk= — Paul S.
– Paul S., Commented Jul 28, 2013 at 22:41

Paul S. · Accepted Answer · 2013-08-02 16:01:22Z

Assuming you can use String.fromCharCode, you can re-build the String to contain the zero-bytes (i.e. use String for binary data) and then encode that as Base64.

var cmd = 'New-Item -Path "C:\\" -Name "Test" -ItemType Directory',
    ar = new Array(cmd.length * 2),
    i, j, s, b64;
// build array of bytes
for (i = 0, j = 0; i < cmd.length; j = 2 * ++i)
    ar[j] = cmd.charCodeAt(i);
// build string from array
s = String.fromCharCode.apply(String, ar);
// to base64
b64 = btoa(s);

This method avoids needing Blob, FileReader or an async method.

Just wrote a library for converting binary data between base64, base16, base8 and base6, and for converting utf8 and utf16 between them, too. These functions all work with Array, ArrayBuffer and Uint?Array, with the exception of Conv86.utfX.toY functions which take String.

var Conv86 = (function () {
    var chars = (
            'ABCDEFGHIJKLMNOPQRSTUVWXYZ' +
            'abcdefghijklmnopqrstuvwxyz' +
            '0123456789+/'
        ),
        inver = {}, i;
    for (i = 0; i < chars.length; ++i) {
        inver[chars[i]] = i;
    }
    function base8To6(arr8) {
        var arr6 = [], i,
            e1, e2, e3,
            s1, s2, s3, s4,
            d1, d2, d3;
        for (i = 0; i < arr8.length; i += 3) {
            e1 = (d1 = arr8[i]    ) & 255;
            e2 = (d2 = arr8[i + 1]) & 255;
            e3 = (d3 = arr8[i + 2]) & 255;
            // wwwwwwxx xxxxyyyy yyzzzzzz
            s1 =                     e1 >>> 2 ;
            s2 = ((e1 &  3) << 4) + (e2 >>> 4);
            s3 = ((e2 & 15) << 2) + (e3 >>> 6);
            s4 =   e3 & 63                    ;
            arr6.push(s1, s2);
            if (d3 !== undefined)
                arr6.push(s3, s4);
            else if (d2 !== undefined)
                arr6.push(s3);
        }
        arr6.byteLength = arr8.length;
        return arr6;
    }
    function base6To8(arr6) {
        var arr8 = [], i,
            e1, e2, e3,
            s1, s2, s3, s4,
            d1, d2, d3, d4;
        for (i = 0; i < arr6.length; i += 4) {
            s1 = (d1 = arr6[i]    ) & 63;
            s2 = (d2 = arr6[i + 1]) & 63;
            s3 = (d3 = arr6[i + 2]) & 63;
            s4 = (d4 = arr6[i + 3]) & 63;
            // xxxxxx xxyyyy yyyyzz zzzzzz
            e1 = ( s1       << 2) + (s2 >>> 4);
            e2 = ((s2 & 15) << 4) + (s3 >>> 2);
            e3 = ((s3 &  3) << 6) +  s4       ;
            arr8.push(e1);
            if (d3 !== undefined)
                arr8.push(e2, e3);
            else if (d2 !== undefined )
                arr8.push(e2);
        }
        if (arr6.byteLength !== undefined)
            arr8.length = +arr6.byteLength;
        return arr8;
    }
    function base6To64(arr6) {
        var i, b64 = '';
        for (i = 0; i < arr6.length; ++i) b64 += chars.charAt(arr6[i]);
        /*if (arr6.bytesLength) {
            i = arr6.bytesLength % 3;
            if (i) ++i;
        } else */
        i = b64.length % 4;
        b64 += ['', '==', '==', '='][i];
        return b64;
    }
    function base8To64(arr8) {
        return base6To64(base8To6(arr8));
    }
    function base64To6(b64) {
        var arr6 = [],
            i = b64.length, lenMod = 0;
        while (b64.charAt(--i) === '=')
            ++lenMod;
        for (i = 0; i < b64.length - lenMod; ++i)
            arr6.push(inver[b64.charAt(i)]);
        i = b64.length & 3;
        if (i) i = 4 - i;
        i = i + b64.length;
        arr6.byteLength = 3 * i / 4 - lenMod;
        return arr6;
    }
    function base64To8(b64) {
        return base6To8(base64To6(b64));
    }
    // base16
    function base8To16(arr8) {
        var i, arr16 = [];
        for (i = 0; i < arr8.length; i = i + 2)
            arr16.push((arr8[i] << 8) + arr8[i + 1]);
        return arr16;
    }
    function base16To8(arr16) {
        var i, arr8 = [];
        for (i = 0; i < arr16.length; ++i)
            arr8.push(arr16[i] >>> 8, arr16[i] & 255);
        return arr8;
    }
    function base6To16(arr6) {
        return base8To16(base6To8(arr6));
    }
    function base16To6(arr16) {
        return base8To6(base16To8(arr16));
    }
    function base16To64(arr16) {
        return base8To64(base16To8(arr16));
    }
    function base64To16(b64) {
        return base8To16(base64To8(b64));
    }
    // from UTF8 to X
    function utf8To8(str) {
        var arr8 = [], i;
        for (i = 0; i < str.length; ++i)
            arr8.push(str.charCodeAt(i) & 255);
        return arr8;
    }
    function utf8To6(str) {
        return base8To6(utf8To8(str));
    }
    function utf8To16(str) {
        return base8To16(utf8To8(str));
    }
    function utf8To64(str) {
        return base8To64(utf8To8(str));
    }
    // from X to UTF8
    function utf8From8(arr8) {
        var utf8arr = [];
        for (i = 0; i < arr8.length; ++i)
            utf8arr.push(arr8[i]);
        return String.fromCharCode.apply(String, utf8arr);
    }
    function utf8From6(arr6) {
        return utf8From8(base6To8(arr6));
    }
    function utf8From16(arr16) {
        return utf8From8(base16To8(arr16));
    }
    function utf8From64(b64) {
        return utf8From8(base64To8(b64));
    }
    // from UTF16 to X
    function utf16To16(str) {
        var arr16 = [], i, c;
        for (i = 0; i < str.length; ++i) {
            c = str.charCodeAt(i) & 65535;
            arr16.push(((c & 255) << 8) + (c >>> 8));
        }
        return arr16;
    }
    function utf16To8(str) {
        return base16To8(utf16To16(str));
    }
    function utf16To6(str) {
        return base16To6(utf16To16(str));
    }
    function utf16To64(str) {
        return base16To64(utf16To16(str));
    }
    // from X to UTF16
    function utf16From16(arr16) {
        var utf16arr = [];
        for (i = 0; i < arr16.length; ++i)
            utf16arr.push(((arr16[i] & 255) << 8) + (arr16[i] >>> 8));
        return String.fromCharCode.apply(String, utf16arr);
    }
    function utf16From8(arr8) {
        return utf16From16(base8To16(arr8));
    }
    function utf16From6(arr6) {
        return utf16From16(base6To16(arr6));
    }
    function utf16From64(b64) {
        return utf16From16(base64To16(b64));
    }
    return {
        base6: {
            to8: base6To8,
            to16: base6To16,
            to64: base6To64,
        },
        base8: {
            to6: base8To6,
            to16: base8To16,
            to64: base8To64
        },
        base16: {
            to6: base16To6,
            to8: base16To8,
            to64: base16To64
        },
        base64: {
            to6: base64To6,
            to8: base64To8,
            to16: base64To16
        },
        utf8: {
            to8: utf8To8,
            to6: utf8To6,
            to16: utf8To16,
            to64: utf8To64,
            from8: utf8From8,
            from6: utf8From6,
            from16: utf8From16,
            from64: utf8From64
        },
        utf16: {
            to8: utf16To8,
            to6: utf16To6,
            to16: utf16To16,
            to64: utf16To64,
            from8: utf16From8,
            from6: utf16From6,
            from16: utf16From16,
            from64: utf16From64
        }
    };
}());

An example usage

Conv86.utf16.from64(
    Conv86.utf16.to64('New-Item -Path "C:\\" -Name "Test" -ItemType Directory')
        // "TgBlAHcALQBJAHQAZQBtACAALQBQAGEAdABoACAAIgBDADoAXAAiACAALQBOAGEAbQBlACAAIgBUAGUAcwB0ACIAIAAtAEkAdABlAG0AVAB5AHAAZQAgAEQAaQByAGUAYwB0AG8AcgB5AA=="
); // "New-Item -Path "C:\" -Name "Test" -ItemType Directory"

Confirming that this works with the library you posted instead of btoa, as well.
I just tried it with the library but i get this error "TypeError: Cannot read property "length" from undefined". Did you get it to work with the library?
Now i got it to work - i replaced b64 = btoa(s); with return b64 but as it said this was undefined. So i replaced b64 with s and now it work. Thanks a lot for the help Poul S.
There should be a warning that btoa is not part of any standard and is not supported by many browsers in use (e.g. IE before version 10).
@RobG I only put it there because I used it to test with; was expecting OP to replace it with their library's Base64.encode call.

Paul S. · Accepted Answer · 2013-07-28 22:52:07Z

If you construct a Blob to have the encoding you want, you can then make use of FileReader's readAsDataURL to build your desired output.

var cmd = 'New-Item -Path "C:\\" -Name "Test" -ItemType Directory',
    pad = new Uint8Array(1), // to help change to UTF-16 (?)
    ar = [],
    i,
    blob,
    fr = new FileReader();
fr.onload = function () {
    var i = this.result.indexOf(','); // trim off starting dataURI part
    console.log(this.result.slice(i + 1));
};
for (i = 0; i < cmd.length; ++i) ar.push(cmd.charAt(i)), ar.push(pad);
blob = new Blob(ar); // now contains the bytes you want
fr.readAsDataURL(blob); // async warning!

Will give you your desired

TgBlAHcALQBJAHQAZQBtACAALQBQAGEAdABoACAAIgBDADoAXAAiACAALQBOAGEAbQBlACAAIgBUAGUAcwB0ACIAIAAtAEkAdABlAG0AVAB5AHAAZQAgAEQAaQByAGUAYwB0AG8AcgB5AA==

It's not possible to use any browser related objects so the code you posted doesn't work. I have been trying the code from webtoolkit.info/javascript-base64.html but i'm not smart enough to replace the UTF8 with UTF16/Unicode instead.
I've posted a different way to tackle the same problem which doesn't need FileReader, Blob, etc :)

Collectives™ on Stack Overflow

javascript unicode base64 encode

2 Answers 2

10 Comments

2 Comments

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

10 Comments

2 Comments

Related