Base64编码算法（Basic编码）之iharder算法源码解析

最新推荐文章于 2024-08-13 10:21:34 发布
最新推荐文章于 2024-08-13 10:21:34 发布
阅读量1.2k 收藏 1
点赞数 1
分类专栏： Java 文章标签： base64 iharder
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nmgrd/article/details/77990615
版权 


import java.io.UnsupportedEncodingException;

/**
 * Base64编码算法（Basic编码）之iharder算法源码解析
 * （注：本人剔除了非核心方法，并对解码表DECODABET做了微量修改）
 * @author Robert Harder
 * @author rob@iharder.net
 * @version 2.1
 */
public class Base64
{

    private Base64() {}


/* ********  P R I V A T E   F I E L D S  ******** */


    /** The equals sign (=) as a byte. */
    private final static byte EQUALS_SIGN = (byte)'=';

    private final static byte OTHER_BYTE = -1; // Indicates equals sign in encoding

    private final static String ENCODING = "UTF-8";


    /** The 64 valid Base64 values. */
    private final static byte[] ALPHABET;
    private final static byte[] _NATIVE_ALPHABET =
            {
                    (byte)'A', (byte)'B', (byte)'C', (byte)'D', (byte)'E', (byte)'F', (byte)'G',
                    (byte)'H', (byte)'I', (byte)'J', (byte)'K', (byte)'L', (byte)'M', (byte)'N',
                    (byte)'O', (byte)'P', (byte)'Q', (byte)'R', (byte)'S', (byte)'T', (byte)'U',
                    (byte)'V', (byte)'W', (byte)'X', (byte)'Y', (byte)'Z',
                    (byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e', (byte)'f', (byte)'g',
                    (byte)'h', (byte)'i', (byte)'j', (byte)'k', (byte)'l', (byte)'m', (byte)'n',
                    (byte)'o', (byte)'p', (byte)'q', (byte)'r', (byte)'s', (byte)'t', (byte)'u',
                    (byte)'v', (byte)'w', (byte)'x', (byte)'y', (byte)'z',
                    (byte)'0', (byte)'1', (byte)'2', (byte)'3', (byte)'4', (byte)'5',
                    (byte)'6', (byte)'7', (byte)'8', (byte)'9', (byte)'+', (byte)'/'
            };

    /**
     * Translates a Base64 value to either its 6-bit reconstruction value
     * or a negative number indicating some other meaning.
     **/
    private final static byte[] DECODABET =
            {
                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
                    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
                    -1, -1, -1,
                    62,      // 索引 43 对应'+','+'在base64编码表中的索引是62
                    -1, -1, -1,
                    63,     // 索引 47 对应 '/','/'在base64编码表中的索引是63
                    52, 53, 54, 55, 56, 57, 58, 59, 60, 61,   // 索引48- 57对应0-9,这10个数字在base64编码表中的索引是52-61
                    -1, -1, -1,
                    EQUALS_SIGN,  // 索引61 对应 '='
                    -1, -1, -1,
                     0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10,  11, 12, // 索引65 - 77对应字母'A' 到 'M'
                    13, 14, 15, 16, 17, 18, 19, 20, 21, 22,  23,  24, 25, // 索引78 - 90对应字母'N' 到 'Z'
                    -1, -1, -1, -1, -1, -1,
                    26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, // 索引 97 - 109对应字母'a' - 'm'
                    39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51  // 索引110 - 122对应字母'n' - 'z'
            };



    /** Determine which ALPHABET to use. */
    static
    {
        byte[] __bytes;
        try
        {
            __bytes = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".getBytes( ENCODING );
        }
        catch (java.io.UnsupportedEncodingException use)
        {
            __bytes = _NATIVE_ALPHABET; // Fall back to native encoding
        }
        ALPHABET = __bytes;
    }







/* ********  E N C O D I N G   M E T H O D S  ******** */

    /**
     * numSigBytes的值是3、2、1
     *
     * numSigBytes = 3,表示将source[srcOffset]、source[ srcOffset + 1]、source[ srcOffset + 2]这三个字节
     * 转换成Base64的四个字节
     *
     *
     * numSigBytes = 2,表示将source[srcOffset]、source[ srcOffset + 1]这两个字节转换成Base64的四个字节
     *
     *
     * numSigBytes = 1,表示将source[srcOffset]这单个字节转换成Base64的四个字节
     *
     *  转换得到的4个字节依次存储到 destination[destOffset]、destination[destOffset + 1]、
     *  destination[destOffset + 1]、destination[destOffset + 1]
     */
    private static byte[] encode3to4(
            byte[] source, int srcOffset, int numSigBytes,
            byte[] destination, int destOffset) {
        //           1         2         3
        // 01234567890123456789012345678901 Bit position
        // --------000000001111111122222222 Array position from threeBytes
        // --------|    ||    ||    ||    | Six bit groups to index ALPHABET
        //          >>18  >>12  >> 6  >> 0  Right shift necessary
        //                0x3f  0x3f  0x3f  Additional AND

        // Create buffer with zero-padding if there are only one or two
        // significant bytes passed in the array.
        // We have to shift left 24 in order to flush out the 1's that appear
        // when Java treats a value as negative that is cast from a byte to an int.
        int inBuff = (numSigBytes > 0 ? ((source[srcOffset] << 24) >>> 8) : 0)
                | (numSigBytes > 1 ? ((source[srcOffset + 1] << 24) >>> 16) : 0)
                | (numSigBytes > 2 ? ((source[srcOffset + 2] << 24) >>> 24) : 0);

        switch (numSigBytes) {
            case 3:
                destination[destOffset] = ALPHABET[(inBuff >>> 18)];
                destination[destOffset + 1] = ALPHABET[(inBuff >>> 12) & 0x3f];
                destination[destOffset + 2] = ALPHABET[(inBuff >>> 6) & 0x3f];
                destination[destOffset + 3] = ALPHABET[(inBuff) & 0x3f];
                return destination;

            case 2:
                destination[destOffset] = ALPHABET[(inBuff >>> 18)];
                destination[destOffset + 1] = ALPHABET[(inBuff >>> 12) & 0x3f];
                destination[destOffset + 2] = ALPHABET[(inBuff >>> 6) & 0x3f];
                destination[destOffset + 3] = EQUALS_SIGN;
                return destination;

            case 1:
                destination[destOffset] = ALPHABET[(inBuff >>> 18)];
                destination[destOffset + 1] = ALPHABET[(inBuff >>> 12) & 0x3f];
                destination[destOffset + 2] = EQUALS_SIGN;
                destination[destOffset + 3] = EQUALS_SIGN;
                return destination;

            default:
                return destination;
        }
    }

    public static String encodeBytes( byte[] source, int off, int len)
    {
            //在Base64编码规则下，原始字节数 : 编码后的字节数 = 3 : 4，这里求出编码后的字节数总数（不考虑余数）
            int    len43   = len * 4 / 3;
            byte[] outBuff = new byte[
                    ( len43 )
                    + ( (len % 3) > 0 ? 4 : 0 ) // 如果原始字节数不是3的整数倍，多余的字节会被编码成为4个字节，所以还得加4
                    ];
            int d = 0;
            int e = 0;
            int len2 = len - 2;
            for( ; d < len2; d+=3, e+=4 )
            {
                encode3to4( source, d+off, 3, outBuff, e );
            }

            if( d < len )
            {
                encode3to4( source, d+off, len - d, outBuff, e );
                e += 4;
            }

            try
            {
                return new String( outBuff, 0, e, ENCODING );
            }
            catch (java.io.UnsupportedEncodingException uue)
            {
                return new String( outBuff, 0, e );
            }
    }


    public static String encodeBytes( byte[] source )
    {
        return encodeBytes(source, 0, source.length);
    }

    public static String encode(String s)
    {
        byte[] bytes;
        try
        {
            bytes = s.getBytes(ENCODING);
        }
        catch( java.io.UnsupportedEncodingException uee )
        {
            bytes = s.getBytes();
        }

        return encodeBytes(bytes);
    }


/* ********  D E C O D I N G   M E T H O D S  ******** */

    /**
     * 该方法将4个字节还原为三个字节
     * @param source
     * @param srcOffset
     * @param destination
     * @param destOffset
     * @return
     */
    private static int decode4to3( byte[] source, int srcOffset, byte[] destination, int destOffset )
    {
        // Example: Dk==
        if( source[ srcOffset + 2] == EQUALS_SIGN )
        {
            // Two ways to do the same thing. Don't know which way I like best.
            //int outBuff =   ( ( DECODABET[ source[ srcOffset    ] ] << 24 ) >>>  6 )
            //              | ( ( DECODABET[ source[ srcOffset + 1] ] << 24 ) >>> 12 );
            int outBuff =   ( ( DECODABET[ source[ srcOffset    ] ] & 0xFF ) << 18 )
                    | ( ( DECODABET[ source[ srcOffset + 1] ] & 0xFF ) << 12 );

            destination[ destOffset ] = (byte)( outBuff >>> 16 );
            return 1;
        }

        // Example: DkL=
        else if( source[ srcOffset + 3 ] == EQUALS_SIGN )
        {
            // Two ways to do the same thing. Don't know which way I like best.
            //int outBuff =   ( ( DECODABET[ source[ srcOffset     ] ] << 24 ) >>>  6 )
            //              | ( ( DECODABET[ source[ srcOffset + 1 ] ] << 24 ) >>> 12 )
            //              | ( ( DECODABET[ source[ srcOffset + 2 ] ] << 24 ) >>> 18 );
            int outBuff =   ( ( DECODABET[ source[ srcOffset     ] ] & 0xFF ) << 18 )
                    | ( ( DECODABET[ source[ srcOffset + 1 ] ] & 0xFF ) << 12 )
                    | ( ( DECODABET[ source[ srcOffset + 2 ] ] & 0xFF ) <<  6 );

            destination[ destOffset     ] = (byte)( outBuff >>> 16 );
            destination[ destOffset + 1 ] = (byte)( outBuff >>>  8 );
            return 2;
        }

        // Example: DkLE
        else
        {
            try{
                // Two ways to do the same thing. Don't know which way I like best.
                //int outBuff =   ( ( DECODABET[ source[ srcOffset     ] ] << 24 ) >>>  6 )
                //              | ( ( DECODABET[ source[ srcOffset + 1 ] ] << 24 ) >>> 12 )
                //              | ( ( DECODABET[ source[ srcOffset + 2 ] ] << 24 ) >>> 18 )
                //              | ( ( DECODABET[ source[ srcOffset + 3 ] ] << 24 ) >>> 24 );
                int outBuff =   ( ( DECODABET[ source[ srcOffset     ] ] & 0xFF ) << 18 )
                        | ( ( DECODABET[ source[ srcOffset + 1 ] ] & 0xFF ) << 12 )
                        | ( ( DECODABET[ source[ srcOffset + 2 ] ] & 0xFF ) <<  6)
                        | ( ( DECODABET[ source[ srcOffset + 3 ] ] & 0xFF )      );


                destination[ destOffset     ] = (byte)( outBuff >> 16 );
                destination[ destOffset + 1 ] = (byte)( outBuff >>  8 );
                destination[ destOffset + 2 ] = (byte)( outBuff       );

                return 3;
            }catch( Exception e){
                System.out.println(""+source[srcOffset]+ ": " + ( DECODABET[ source[ srcOffset     ] ]  ) );
                System.out.println(""+source[srcOffset+1]+  ": " + ( DECODABET[ source[ srcOffset + 1 ] ]  ) );
                System.out.println(""+source[srcOffset+2]+  ": " + ( DECODABET[ source[ srcOffset + 2 ] ]  ) );
                System.out.println(""+source[srcOffset+3]+  ": " + ( DECODABET[ source[ srcOffset + 3 ] ]  ) );
                return -1;
            }
        }
    }


    public static byte[] decode( byte[] source, int off, int len )
    {
        //在Base64编码规则下，原始字节数 : 编码后的字节数 = 3 : 4，这里估算解码后的字节数总数
        int    len34   = len * 3 / 4;
        byte[] outBuff = new byte[ len34 ]; // Upper limit on size of output, outBuff用于存放解码后的字节
        int    outBuffPosn = 0;

        byte[] b4        = new byte[4];
        int    b4Posn    = 0;
        int    i         = 0;
        byte   sbiCrop   = 0;
        byte   sbiDecode = 0;
        for( i = off; i < off + len; i++ )
        {
            sbiCrop = (byte)(source[i] & 0x7f); // Only the low seven bits
            sbiDecode = DECODABET[sbiCrop ];

            if(sbiDecode != OTHER_BYTE)
            {
                    b4[ b4Posn++ ] = sbiCrop;
                    if( b4Posn > 3 )
                    {
                        outBuffPosn += decode4to3( b4, 0, outBuff, outBuffPosn );
                        b4Posn = 0;

                        // If that was the equals sign, break out of 'for' loop
                        if( sbiCrop == EQUALS_SIGN )
                            break;
                    }
            }
            else
            {
                System.err.println( "Bad Base64 input character at " + i + ": " + source[i] + "(decimal)" );
                return null;
            }
        }

        byte[] out = new byte[ outBuffPosn ];
        System.arraycopy( outBuff, 0, out, 0, outBuffPosn );
        return out;
    }

    public static byte[] decode(String s)
    {
        byte[] bytes;
        try
        {
            bytes = s.getBytes(ENCODING);
        }
        catch( java.io.UnsupportedEncodingException uee )
        {
            bytes = s.getBytes();
        }

        bytes = decode( bytes, 0, bytes.length );

        return bytes;
    }


/* ********  TEST   M E T H O D S  ******** */

    public static void main(String... args) throws UnsupportedEncodingException {

        String str = "我是中国人!@#$%^&*()_+S【】；0987655.、，；‘、】【屏";
        String enstr = encode(str);
        System.out.println(enstr);
        byte[] debytes = decode(enstr);
        String destr = new String( debytes, 0, debytes.length, ENCODING );
        System.out.println(destr);
    }

}
lhever_
关注
专栏目录
调试Http Basic认证，用base64加密解密
南瓜慢说
06-22 3924
我最新最全的文章都在 南瓜慢说 www.pkslow.com ，欢迎大家来喝茶！ 1 HTTP Basic认证 HTTP Basic认证是在HTTP 1.0就引入的认证方案，存在安全缺陷；但由于实现简单，仍有项目在用。 它主要通过请求头Authorization来做认证，格式为： 键：Authorization 值：Basic base64(username:password)，即Basic 加密串，如Basic dXNlcjp1c2Vy。 Spring Security的配置可以为： @EnableW.
Visual Basic Base64编码源码：可实现对字符串（中文）和二进制文件编码
weixin_30372371的博客
05-25 221
虽然网上可以找到很多，不过很多都存在缺陷或者问题，这个经过改进和全面测试，希望可以为有需要的开发人员带来方便。 本模块需要添加Scriping.runtime引用，因为用到了很多FileSystemObject对象。 本模块部分技术基于他人的工作成果在，在此表示感谢。 OptionExplicitPrivateConstBASE64CHRAsString="...
深入理解Base64的用法和原理
威哥爱编程，CSDN 博客专家、全栈领域新星创作者、华为 HDE，愿交天下 IT 技术爱好者
08-13 2122
Base64 编码使用 64 个可打印的 ASCII 字符来表示数据。这些字符包括大写字母A-Z（26 个）、小写字母a-z（26 个，但在标准 Base64 中通常使用大写）、数字0-9（10 个）、加号和斜杠。此外，为了支持 URL 和文件名，还有一个变种使用代替和代替。与编码表一样，解码表依赖于 Base64 字符集，包括大写字母A-Z、小写字母a-z（在标准 Base64 中通常不使用）、数字0-9、加号和斜杠。对于 URL 安全的 Base64，使用代替和代替。Java 的Base64。
basic64
hcmfys2009的专栏
02-09 152
  using System; using System.Collections.Generic; using System.Text; using System.Collections; namespace basic64 { public class Basic64 { private Hashtable hash = new ...
Basic各编码每个字符占用字节个数
思维小刀
09-01 655
ascii码：一个字符占用一个字节 只有字母数字符号等 utf-8：一个汉字三个字节 英文1个字符1个字节 gbk：一个汉字两个字节 英文1字符1个字节 ...
Basic64 编码解码
weixin_30387423的博客
06-20 705
import sun.misc.BASE64Decoder; public class Base64 { /** * 字符串转Base64编码 * @param s * @return */ public static String getBASE64(String s) { ...
Android数据加密之Base64编码算法的简单实现
01-04
Base64是网络上最常见的用于传输8Bit字节代码的编码方式之一，Base64并不是安全领域的加密算法，其实Base64只能算是一个编码算法，对数据内容进行编码来适合传输。标准Base64编码解码无需额外信息即完全可逆，即使你...
通过rust语言实现的base64编码算法
最新发布
08-23
《通过 Rust 语言实现的 Base64 编码算法》是一份面向开发者的技术资源，旨在帮助读者学习如何使用 Rust 语言实现 Base64 编码和解码算法。该资源从基础概念出发，详细介绍了 Base64 编码的原理和用途，并通过逐步...
android自带base64实现BASE64编码和解码程序完整Java源码
11-12
android 开发中有时会需要用到base64加解密，其实base64并不算是一种加密的算法，只是一种基于64个可打印字符来表示二进制数据的表示方法。 google在android.util下提供了一个Base64工具类，可以很方便的用它encode...
Java实现的Base64加密算法示例
08-27
Java实现的Base64加密算法示例 Base64加密算法是指一种常用的数据加密算法，主要用于将二进制数据转换为文本格式，以便于在网络上传输。Java语言提供了多种实现Base64加密算法的方式，本文将详细介绍Java实现的Base...
【数据结构与算法】之深入解析Base64编码的实现原理
╰つ栺尖篴夢ゞ
09-11 2412
一、Base64 编码简介 ① Base64 编码的由来 为什么会有 Base64 编码呢？因为有些网络传送渠道并不支持所有的字节，例如传统的邮件只支持可见字符的传送，像 ASCII 码的控制字符就不能通过邮件传送。这样用途就受到了很大的限制，比如图片二进制流的每个字节不可能全部是可见字符，所以就无法传送。 最好的方法就是在不改变传统协议的情况下，做一种扩展方案来支持二进制文件的传送。把不可打印的字符也能用可打印字符来表示，问题就可以解决。 Base64 编码应运而生，Base64 就是一种基于 64 个
iHarder.net-开源
05-01
主要是Java，XML和Cocoa的开源和公共领域软件的集合。 一些项目：ThreadWorker，Xmlizable，Base64，Tabu Search。
BER: basic encoding rules/基本编码规则
liufeng_cp的专栏
11-19 9065
 BER是basic encoding rules的简称，它是一种简单的编码规则。BER的优点：提供了一套规则，使得任何按该规则编码的一段数据（八位组流）都能够按照此规则被解析，这种规则使得一段数据自包含自身的结构信息。BER的传输格式一直是TLV三元组：可以解释为 ；亦可解释为。见下图：  TLV每个域都是一系列八位组，对于组合结构，其中V还可以是TLV三元组，因而形成嵌
JarvisOJ Basic Base64?
weixin_30667301的博客
01-30 297
GUYDIMZVGQ2DMN3CGRQTONJXGM3TINLGG42DGMZXGM3TINLGGY4DGNBXGYZTGNLGGY3DGNBWMU3WI=== 题目非常具有迷惑性，我一开始以为就是一个base64编码，但是看到了最后的3个=，base64最多有两个，继续观察好像只有大写字母,数字也只有2~7，大胆猜测是base32 解码得到504354467b4a7573745f7...
BASE64Encoder
~~~~~~~~~~~~
12-16 861
Base64是网络上最常见的用于传输8Bit字节代码的编码方式之一，在发送电子邮件时，服务器认证的用户名和密码需要用Base64编码，附件也需要用Base64编码。 Base64要求把每三个8Bit的字节转换为四个6Bit的字节（3*8 = 4*6 = 24），然后把6Bit再添两位高位0，组成四个8Bit的字节，也就是说，转换后的字符串理论上将要比原来的长1/3。 原文的字节最后
Java 8新特性探究（十一）Base64详解
weixin_34221276的博客
05-22 546
2019独角兽企业重金招聘Python工程师标准>>> ...
Base64编码作用及使用详解
OceanSky的专栏
05-21 7989
介绍：Base64是网络上最常见的用于传输8Bit字节码的编码方式之一，Base64就是一种基于64个可打印字符来表示二进制数据的方法； 1.使用场景： Base64一般用于在HTTP协议下传输二进制数据，由于HTTP协议是文本协议，所以在HTTP协议下传输二进制数据需要将二进制数据转换字符数据；然而直接转换是不行的，因为网络传输只能传输可打印字符； 什么是可打印字符？在ASCII码中规定，0-31、127这33个字符属于控制字符，32-126这95个字符属于可打印字符，也就是说网络传输只能传输这95个字
basic专栏 05.文件操作 01.字符编码与解码
Web Python
03-25 352
# ASCII码表 """ 8bit 1Bytes 可存储256个字符 0-255 只支持英文字符 """ # GBK码表 """ 英文 8bit 1Bytes 可存储256个字 中文 16bit 2Bytes 可存储65536个字符 0-65535 可存储大部分中文字符 中国人编制 以GBK格式存入硬盘，其他国家无法使用，不建议存储 """ # Unicode码表 """ 多数字符 16bit 2Bytes [英文多时，2字节占空间，IO延迟长] 个别字符 32/64bit 4/8.
Java Base64 编码与解码----三种实现方式的代码实例
请叫我大师兄
06-28 5699
在Java 8中，Base64编码已经成为Java类库的标准。 Java 8 内置了 Base64 编码的编码器和解码器。 Base64工具类提供了一套静态方法获取下面三种BASE64编解码器： 基本：输出被映射到一组字符A-Za-z0-9+/，编码不添加任何行标，输出的解码仅支持A-Za-z0-9+/。 URL：输出被映射到一组字符A-Za-z0-9+_，输出是URL和文件。 MIME：输出隐...
C++实现Base64编码解码算法详解
"c++如何实现Base64算法" Base64是一种常见的数据编码方法，主要用于将二进制数据转换成可打印的ASCII字符，以便在网络传输或存储时避免特殊字符的问题。它常用于电子邮件系统、网页源代码中的图片和其他二进制数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值