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

最新推荐文章于 2022-03-25 13:13:11 发布
最新推荐文章于 2022-03-25 13:13:11 发布
阅读量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_
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android数据加密之Base64编码算法的简单实现
01-04
Base64是网络上最常见的用于传输8Bit字节代码的编码方式之一，Base64并不是安全领域的加密算法，其实Base64只能算是一个编码算法，对数据内容进行编码来适合传输。标准Base64编码解码无需额外信息即完全可逆，即使你...
Basic各编码每个字符占用字节个数
思维小刀
09-01 602
ascii码：一个字符占用一个字节 只有字母数字符号等 utf-8：一个汉字三个字节 英文1个字符1个字节 gbk：一个汉字两个字节 英文1字符1个字节 ...
basic专栏 05.文件操作 01.字符编码与解码
Web Python
03-25 290
# 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 8新特性探究（十一）Base64详解
weixin_34221276的博客
05-22 511
2019独角兽企业重金招聘Python工程师标准>>> ...
调试Http Basic认证，用base64加密解密
南瓜慢说
06-22 3691
我最新最全的文章都在 南瓜慢说 www.pkslow.com ，欢迎大家来喝茶！ 1 HTTP Basic认证 HTTP Basic认证是在HTTP 1.0就引入的认证方案，存在安全缺陷；但由于实现简单，仍有项目在用。 它主要通过请求头Authorization来做认证，格式为： 键：Authorization 值：Basic base64(username:password)，即Basic 加密串，如Basic dXNlcjp1c2Vy。 Spring Security的配置可以为： @EnableW.
Base64编码作用及使用详解
OceanSky的专栏
05-21 7161
介绍：Base64是网络上最常见的用于传输8Bit字节码的编码方式之一，Base64就是一种基于64个可打印字符来表示二进制数据的方法； 1.使用场景： Base64一般用于在HTTP协议下传输二进制数据，由于HTTP协议是文本协议，所以在HTTP协议下传输二进制数据需要将二进制数据转换字符数据；然而直接转换是不行的，因为网络传输只能传输可打印字符； 什么是可打印字符？在ASCII码中规定，0-31、127这33个字符属于控制字符，32-126这95个字符属于可打印字符，也就是说网络传输只能传输这95个字
Http协议的身份认证
swadian2008的博客
02-13 1208
目录 一、Basic基础认证 二、Digest摘要认证 三、SSL Client认证 四、HTTP 表单认证 HTTP提供了一套标准的身份验证框架：服务器可以用来针对客户端的请求发送质询(challenge)，客户端根据质询提供身份验证凭证。质询与应答的工作流程如下：服务器端向客户端返回401（Unauthorized，未授权）状态码，并在WWW-Authenticate头中添加如何进行...
vb 图片转base64编码 程序源码
01-24
【程序老媛出品，必属精品，亲测校正，...资源名：vb 图片转base64编码 程序源码 资源类型：程序源代码 源码说明： 基于vb编写的实现图片转base64编码程序源码 非常适合借鉴学习 适合人群：新手及有一定经验的开发人员
labview 图片缩放 base64编码base64解码
最新发布
08-07
labview 图片缩放 base64编码base64解码
Base64编码解码工具成品+源码
06-03
工作需要，经常使用BASE64网页版编码解码工具来转换，但是又要来回切内网，比较麻烦，所以搜集写了这个工具，压缩包附有易语言源码
HTTP认证之基本认证——Basic（一）
weixin_30492601的博客
06-12 698
导航 HTTP认证之基本认证——Basic（一） HTTP认证之基本认证——Basic（二） HTTP认证之摘要认证——Digest（一） HTTP认证之摘要认证——Digest（二） 一、概述 Basic认证是一种较为简单的HTTP认证方式，客户端通过明文（Base64编码格式）传输用户名和密码到服务端进行认证，通常需要配合HTTPS来保证信息传输的安全。 二、剖析 1.当打开需要认证...
加密算法之Base64初探
jwang的博客
08-21 1782
前言 本章讲解加密算法初探之Base64 方法 1、概念 Base64是网络上最常见的用于传输8Bit字节码的编码方式之一，Base64就是一种基于64个可打印字符来表示二进制数据的方法。可查看RFC2045～RFC2049，上面有MIME的详细规范。 Base64编码是从二进制到字符的过程，可用于在HTTP环境下传递较长的标识信息。采用Base64编码具有不可读性，需要解码后才能阅读。 Base64由于以上优点被广泛应用于计算机的各个...
Base64工具类（加密、解密）
lixinze的博客
05-08 589
package com.yunerp.base.utils.base; import java.io.*; /** * Created by User on 2018/8/9. */ public class Base64Utils { public Base64Utils() { } /** * 功能：编码字符串 * * @author jiangshuai * @date 2016年10月03日 * @param
Java8 Base64加密和解密
热门推荐
Charge8的博客
08-20 1万+
在 Java8中 Base64编码已经成为Java类库的标准，且内置了Base64编码的编码器和解码器。 一、什么是Base64? -- 来自百度百科 Base64是网络上最常见的用于传输 8Bit字节码的编码方式之一， Base64就是一种基于64个可打印字符来表示二进制数据的方法。 1、什么是“可打印字符”呢？为什么要用它来传输 8Bit...
BASE64Encoder
~~~~~~~~~~~~
12-16 792
Base64是网络上最常见的用于传输8Bit字节代码的编码方式之一，在发送电子邮件时，服务器认证的用户名和密码需要用Base64编码，附件也需要用Base64编码。 Base64要求把每三个8Bit的字节转换为四个6Bit的字节（3*8 = 4*6 = 24），然后把6Bit再添两位高位0，组成四个8Bit的字节，也就是说，转换后的字符串理论上将要比原来的长1/3。 原文的字节最后
base64加密——小白用于自身学习-勿喷
dl13889435848的博客
08-01 162
相关的Java包和类 java.security消息摘要 javax.crypto安全消息摘要，消息认证（鉴别）码 java.net.ssl安全套接字 第三方Java扩展（实现方式） JDK —— 自带方式 Bouncy Castle（BC） —— 两种方案：1）配置；2）调用 Commons Codec（CC） —— Apache —— Base64、二进制、十六进
Basic64 编码解码
weixin_30387423的博客
06-20 631
import sun.misc.BASE64Decoder; public class Base64 { /** * 字符串转Base64编码 * @param s * @return */ public static String getBASE64(String s) { ...
BER: basic encoding rules/基本编码规则
liufeng_cp的专栏
11-19 8862
 BER是basic encoding rules的简称，它是一种简单的编码规则。BER的优点：提供了一套规则，使得任何按该规则编码的一段数据（八位组流）都能够按照此规则被解析，这种规则使得一段数据自包含自身的结构信息。BER的传输格式一直是TLV三元组：可以解释为 ；亦可解释为。见下图：  TLV每个域都是一系列八位组，对于组合结构，其中V还可以是TLV三元组，因而形成嵌
接口测试 之 HTTP 1.1 认证之BASIC认证
weixin_39472415的博客
09-22 1641
basic认证介绍认证步骤步骤图解BASIC 认证的的缺点测试：认证失败测试：认证成功 介绍 BASIC 认证（基本认证）是从HTTP/1. 1 就定义的认证方式，是Web服务器与通信客户端之间进行的认证 认证步骤 步骤1：当请求的资源需要 BASIC 认证时，服务器会随状态码 401 Authorization Required，返回 WWW-Authenticate 首部字段（响应头）的响应。该字段内包含认证的方式（BASIC）及Request-URI 安全域字符串（realm）。 步骤2：接收到状
如何通过SubjectPublicKeyInfo获取SM2算法公钥的Base64编码
05-31
可以通过以下步骤获取SM2算法公钥的Base64编码： 1. 解析SubjectPublicKeyInfo，获取SM2算法公钥的DER编码。 2. 将SM2算法公钥的DER编码进行Base64编码，即可得到SM2算法公钥的Base64编码。 具体实现可以参考以下...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值