JavaScript中字节数组的base64编码

Question

I'm trying to figure out how to do the reverse encode of a script that I'm using. I have the decode function. I now have to create the encode function, and I'm struggling a bit, where it details

"chr2 = (enc2 >> 2) | ((enc3 & 0x0F) << "

I'm not sure exactly what this means, or how to ensure that the encoded data is padded correctly.

I'm using the decodeAsArray function, to turn into a byte array and that works just fine. Now just trying to do vice-versa, the opposite way to encode the base64, so I'm hoping to create a encodeFromArray function, where I give a byte array as the input to the function.

Base64 = {
        _keyStr: ".ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+=",
        decode: function( input ) {
                    var output = "";
                    var hex = "";
                    var chr1, chr2, chr3 = "";
                    var enc1, enc2, enc3, enc4 = "";
                    var i = 0;
                    var base64test = /[^A-Za-z0-9\+\.\=]/g;

                    do {
                        enc1 = this._keyStr.indexOf(input.charAt(i++)) ;
                        enc2 = this._keyStr.indexOf(input.charAt(i++)) ;
                        enc3 = this._keyStr.indexOf(input.charAt(i++)) ;
                        enc4 = this._keyStr.indexOf(input.charAt(i++)) ;

                        chr1 = (enc1 | ((enc2 & 3) << 6));                                                                                                             
                        chr2 = (enc2 >> 2) | ((enc3 & 0x0F) << 4);                                                                                                     
                        chr3 = (enc3 >> 4) | (enc4 << 2);


                        output = output + String.fromCharCode(chr1);
                        if (enc3 != 64) {
                            output = output + String.fromCharCode(chr2);
                        }
                        if (enc4 != 64) {
                            output = output + String.fromCharCode(chr3);
                        }
                        chr1 = chr2 = chr3 = "";
                        enc1 = enc2 = enc3 = enc4 = "";
                    } while (i < input.length);

                    return (output);
                },

    decodeAsArray: function (b) {
        var d = this.decode(b),
            a = [],
            c;
        for (c = 0; c < d.length; c++) {
            a[c] = d.charCodeAt(c)
        }
        return a
    }

I think it would look something like the following:

    encode : function (input) {
    var output = "";
    var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
    var i = 0;


    while (i < input.length) {


        chr1 = input.charCodeAt(i++);
        chr2 = input.charCodeAt(i++);
        chr3 = input.charCodeAt(i++);


        enc1 = chr1 >> 2;
        enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
        enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
        enc4 = chr3 & 63;

        if (isNaN(chr2)) {
            enc3 = enc4 = 64;
        } else if (isNaN(chr3)) {
            enc4 = 64;
        }

        output = output +
        this._keyStr.charAt(enc1) + this._keyStr.charAt(enc2) +
        this._keyStr.charAt(enc3) + this._keyStr.charAt(enc4);

    }

    return output;
}

However, I'm not sure how the enc2, enc3 and enc4 should be, based on the decode function, and then I'm also not sure how to do it from byte array

Answer 1

Treat the original encodings as these bits. The top 2 bits of each encoding are 00 because there are only 63 characters in base64 encoding, and that only requires 6 bits.

enc1 = 00abcdef
enc2 = 00ghijkl
enc3 = 00mnopqr
enc4 = 00stuvwx

The bit-shifting then produces:

chr1 = (enc1 | ((enc2 & 3) << 6)) = 00abcdef | 000000kl << 6         = klabcdef                                                   
chr2 = (enc2 >> 2) | ((enc3 & 0x0F) << 4) = 0000ghij | 0000opqr << 4 = opqrghij                                                                                                   
chr3 = (enc3 >> 4) | (enc4 << 2) = 000000mn | stuvwx00               = stuvwxmn

So to reverse it, you need to do:

enc1 = chr1 & 0x3F;
enc2 = ((chr2 & 0x0F) << 2) | (chr1 >> 6);
enc3 = ((chr3 & 0x03 << 4) | (chr2 >> 4);
enc4 = chr3 >> 2;

So it looks like you had the correct formulas, but you were doing them backwards -- your enc1 is actually enc4 .