5、Base64加密算法

最新推荐文章于 2024-03-23 20:20:16 发布
最新推荐文章于 2024-03-23 20:20:16 发布
阅读量3.8k 收藏 3
点赞数 3
分类专栏： Security 文章标签： 加密 base64 编码 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zyhlwzy/article/details/77964763
版权

Base64加密算法编码规则

Base64编码的思想是采用64个基本的ASCII码字符对数据进行重新编码。他将需要编码的数据拆分成字节数组，以三个字节为一组。按顺序排列24位数据，再把这24位数据分成四组，即每组6位。再在每组的最高位前补两个0凑足一个字节。这样就把一个3字节为一组的数据重新编码成了4个字节。当所要编码的数据的字节数不是3的整数倍，也就是说在分组时最后一组不足3个字节。这时在最后一组填充1到2个0字节。并在最后编码完成后在结尾添加1到2个‘=’。

例如：将RON进行Base64编码：

  1. 首先取RON对应的ASCII码值：R(82)O(79)N(78)；
  2. 再取二进制值：R(01010010)O(01001111)N(01001110)；
  3. 然后把这三个字节的二进制码接起来（010100100100111101001110）；
  4. 再以6位为单位分成4个数据块,并在最高位填充两个0后形成4个字节的编码后的值，(00010100)(00100100)(00111101)(00001110)；
  5. 再把这四个字节转换为10进制数据得到：(20)(36)(61)(14)，这里算出来的值实际上是数据在字符表中的索引。
  6. 最后根据BASE64给出的64个基本字符表，查出对应的ASCII码字符：(U)(k)(9)(O)。

注：BASE64字符表：ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=

Base64加密算法解码规则

解码过程就是把4个字节再还原成3个字节再根据不同的数据形式把字节数组重新整理成数据。

例如：将Uk9O解码

  1. 首先取Uk9O在编码表中的索引：U(20)k(36)9(61)O(14)；
  2. 再取二进制值：U(00010100)k(00100100)9(00111101)O(00001110)；
  3. 然后将四个字节的二进制码高位两个0去掉然后拼接起来：（010100100100111101001110）
  4. 再以8位为单位分成3个数据块：(01010010)(01001111)(01001110);
  5. 再把3个字节转换为10进制数据得到：(82)(79)(78)，得到的十进制数据即为字符的ASCII码。
  6. 根据ASCII码查出字符：RON，这里是ASCII码表中的实际字符，并非我们定义的由65个字符组成的编码表。

Base64编码解码java实现

package ron.blog.blog_common.custom;

/**
 * @Comment 自定义实现BASE64编码和解码
 * @Author Ron
 * @Date 2017年9月13日 上午9:53:39
 * @return
 */
public class CustomBase64 {

    /**
     * 编码表
     */
    private static final byte[] encodingTable = { 
            (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) '/', (byte) '=' 
        };

    /**
     * 解码表
     */
    private static final byte[] decodingTable;

    static {
        decodingTable = new byte[128];
        for (int i = 0; i < encodingTable.length; i++) {
            decodingTable[encodingTable[i]] = (byte) i;
        }
    }

    /**
     * @Comment BASE64编码
     * @Author Ron
     * @Date 2017年9月13日 上午9:56:02
     * @return
     */
    public static byte[] encode(byte[] data) {
        byte[] bytes;
        int modulus = data.length % 3;
        if (modulus == 0) {
            bytes = new byte[(4 * data.length) / 3];
        } else {
            bytes = new byte[4 * ((data.length / 3) + 1)];
        }
        int dataLength = (data.length - modulus);
        int a1;
        int a2;
        int a3;
        for (int i = 0, j = 0; i < dataLength; i += 3, j += 4) {
            a1 = data[i] & 0xff;
            a2 = data[i + 1] & 0xff;
            a3 = data[i + 2] & 0xff;
            bytes[j] = encodingTable[(a1 >>> 2) & 0x3f];
            bytes[j + 1] = encodingTable[((a1 << 4) | (a2 >>> 4)) & 0x3f];
            bytes[j + 2] = encodingTable[((a2 << 2) | (a3 >>> 6)) & 0x3f];
            bytes[j + 3] = encodingTable[a3 & 0x3f];
        }
        int b1;
        int b2;
        int b3;
        int d1;
        int d2;
        switch (modulus) {
        case 0: /* nothing left to do */
            break;
        case 1:
            d1 = data[data.length - 1] & 0xff;
            b1 = (d1 >>> 2) & 0x3f;
            b2 = (d1 << 4) & 0x3f;
            bytes[bytes.length - 4] = encodingTable[b1];
            bytes[bytes.length - 3] = encodingTable[b2];
            bytes[bytes.length - 2] = (byte) '=';
            bytes[bytes.length - 1] = (byte) '=';
            break;
        case 2:
            d1 = data[data.length - 2] & 0xff;
            d2 = data[data.length - 1] & 0xff;
            b1 = (d1 >>> 2) & 0x3f;
            b2 = ((d1 << 4) | (d2 >>> 4)) & 0x3f;
            b3 = (d2 << 2) & 0x3f;
            bytes[bytes.length - 4] = encodingTable[b1];
            bytes[bytes.length - 3] = encodingTable[b2];
            bytes[bytes.length - 2] = encodingTable[b3];
            bytes[bytes.length - 1] = (byte) '=';
            break;
        }
        return bytes;
    }

    public static byte[] decode(byte[] data) {
        byte[] bytes;
        byte b1;
        byte b2;
        byte b3;
        byte b4;
        data = discardNonBase64Bytes(data);
        if (data[data.length - 2] == '=') {
            bytes = new byte[(((data.length / 4) - 1) * 3) + 1];
        } else if (data[data.length - 1] == '=') {
            bytes = new byte[(((data.length / 4) - 1) * 3) + 2];
        } else {
            bytes = new byte[((data.length / 4) * 3)];
        }
        for (int i = 0, j = 0; i < (data.length - 4); i += 4, j += 3) {
            b1 = decodingTable[data[i]];
            b2 = decodingTable[data[i + 1]];
            b3 = decodingTable[data[i + 2]];
            b4 = decodingTable[data[i + 3]];
            bytes[j] = (byte) ((b1 << 2) | (b2 >> 4));
            bytes[j + 1] = (byte) ((b2 << 4) | (b3 >> 2));
            bytes[j + 2] = (byte) ((b3 << 6) | b4);
        }
        if (data[data.length - 2] == '=') {
            b1 = decodingTable[data[data.length - 4]];
            b2 = decodingTable[data[data.length - 3]];
            bytes[bytes.length - 1] = (byte) ((b1 << 2) | (b2 >> 4));
        } else if (data[data.length - 1] == '=') {
            b1 = decodingTable[data[data.length - 4]];
            b2 = decodingTable[data[data.length - 3]];
            b3 = decodingTable[data[data.length - 2]];
            bytes[bytes.length - 2] = (byte) ((b1 << 2) | (b2 >> 4));
            bytes[bytes.length - 1] = (byte) ((b2 << 4) | (b3 >> 2));
        } else {
            b1 = decodingTable[data[data.length - 4]];
            b2 = decodingTable[data[data.length - 3]];
            b3 = decodingTable[data[data.length - 2]];
            b4 = decodingTable[data[data.length - 1]];
            bytes[bytes.length - 3] = (byte) ((b1 << 2) | (b2 >> 4));
            bytes[bytes.length - 2] = (byte) ((b2 << 4) | (b3 >> 2));
            bytes[bytes.length - 1] = (byte) ((b3 << 6) | b4);
        }
        return bytes;
    }

    public static byte[] decode(String data) {
        byte[] bytes;
        byte b1;
        byte b2;
        byte b3;
        byte b4;
        data = discardNonBase64Chars(data);
        if (data.charAt(data.length() - 2) == '=') {
            bytes = new byte[(((data.length() / 4) - 1) * 3) + 1];
        } else if (data.charAt(data.length() - 1) == '=') {
            bytes = new byte[(((data.length() / 4) - 1) * 3) + 2];
        } else {
            bytes = new byte[((data.length() / 4) * 3)];
        }
        for (int i = 0, j = 0; i < (data.length() - 4); i += 4, j += 3) {
            b1 = decodingTable[data.charAt(i)];
            b2 = decodingTable[data.charAt(i + 1)];
            b3 = decodingTable[data.charAt(i + 2)];
            b4 = decodingTable[data.charAt(i + 3)];
            bytes[j] = (byte) ((b1 << 2) | (b2 >> 4));
            bytes[j + 1] = (byte) ((b2 << 4) | (b3 >> 2));
            bytes[j + 2] = (byte) ((b3 << 6) | b4);
        }
        if (data.charAt(data.length() - 2) == '=') {
            b1 = decodingTable[data.charAt(data.length() - 4)];
            b2 = decodingTable[data.charAt(data.length() - 3)];
            bytes[bytes.length - 1] = (byte) ((b1 << 2) | (b2 >> 4));
        } else if (data.charAt(data.length() - 1) == '=') {
            b1 = decodingTable[data.charAt(data.length() - 4)];
            b2 = decodingTable[data.charAt(data.length() - 3)];
            b3 = decodingTable[data.charAt(data.length() - 2)];
            bytes[bytes.length - 2] = (byte) ((b1 << 2) | (b2 >> 4));
            bytes[bytes.length - 1] = (byte) ((b2 << 4) | (b3 >> 2));
        } else {
            b1 = decodingTable[data.charAt(data.length() - 4)];
            b2 = decodingTable[data.charAt(data.length() - 3)];
            b3 = decodingTable[data.charAt(data.length() - 2)];
            b4 = decodingTable[data.charAt(data.length() - 1)];
            bytes[bytes.length - 3] = (byte) ((b1 << 2) | (b2 >> 4));
            bytes[bytes.length - 2] = (byte) ((b2 << 4) | (b3 >> 2));
            bytes[bytes.length - 1] = (byte) ((b3 << 6) | b4);
        }
        return bytes;
    }

    private static byte[] discardNonBase64Bytes(byte[] data) {
        byte[] temp = new byte[data.length];
        int bytesCopied = 0;
        for (int i = 0; i < data.length; i++) {
            if (isValidBase64Byte(data[i])) {
                temp[bytesCopied++] = data[i];
            }
        }
        byte[] newData = new byte[bytesCopied];
        System.arraycopy(temp, 0, newData, 0, bytesCopied);
        return newData;
    }

    private static String discardNonBase64Chars(String data) {
        StringBuffer sb = new StringBuffer();
        int length = data.length();
        for (int i = 0; i < length; i++) {
            if (isValidBase64Byte((byte) (data.charAt(i)))) {
                sb.append(data.charAt(i));
            }
        }
        return sb.toString();
    }

    private static boolean isValidBase64Byte(byte b) {
        if (b == '=') {
            return true;
        } else if ((b < 0) || (b >= 128)) {
            return false;
        } else if (decodingTable[b] == -1) {
            return false;
        }
        return true;
    }

    public static void main(String[] args) {
        String codeStr = "RON";
        byte[] codeByteArr = codeStr.getBytes();
        byte[] encodeByteArr = CustomBase64.encode(codeByteArr);
        String encodeStr = new String(encodeByteArr);
        byte[] decodeByteArr = CustomBase64.decode(encodeByteArr);
        String decodeStr = new String(decodeByteArr);
        System.out.println("Source:" + codeStr);
        System.out.println("自己实现编码:" + encodeStr);
        System.out.println("自己实现解码:" + decodeStr);
    }
}

以上仅仅只是根据算法的实现原理，我们对Base64编码解码做了一个简单的实现。但是在实际的应用过程中，我们并不用关心具体的实现方案，我们直接引入org.apache.commons.codec.binary.Base64包，调用已经实现的编码解码方法即可。

/**
* @Comment Base64解码
* @Author Ron
* @Date 2017年9月12日 下午4:45:19
* @return
*/
public static byte[] decryptBASE64(String key) {
    return Base64.decodeBase64(key);
}

/**
* @Comment Base64编码
* @Author Ron
* @Date 2017年9月12日 下午4:47:55
* @return
*/
public static String encryptBASE64(byte[] bytes) {
    return Base64.encodeBase64String(bytes);
}
RonTech
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Base64加密算法C语言代码实现
09-26
配套文章解析：https://blog.csdn.net/u013469753/article/details/108320098 Base64编码的核心原理是将二进制数据进行分组，每24Bit(3字节)为一个大组，再把一个大组的数据分成4个6Bit的小分组。由于6Bit数据只能表示64个不同的字符(2^6=64)，所以这也是Base64的名字由来。
常用字符串压缩方法
不爱运动的跑者
06-11 6330
如果当前字符串加上字符不在字典中，则将当前字符串的编码添加到结果列表中，并将当前字符串加上字符添加到字典中，并为它分配一个新的编码。在`main`函数中，首先指定要压缩的输入字符串，然后通过调用`bwtTransform`函数进行压缩，并打印压缩后的结果。这样可以实现对重复出现的字符串的压缩。首先，我们对原始字符串进行编码并打印编码后的字符串，然后对编码后的字符串进行解码并打印解码后的字符串。它使用变长编码来表示不同的字符，使频率较高的字符使用较短的编码，频率较低的字符使用较长的编码。
利用Base64加密算法将数据加密解密
最新发布
2302_80372340的博客
03-23 1560
Base64准确来说并不像是一种加密算法，而更像是一种编码标准。我们知道现在最为流行的编码标准就是ASCLL，它用八个二进制位（一个char的大小）表示了127个字符，任何二进制序列都可以用这127个字符表示出来。而Base64则是用6个二进制位表示了64个字符，也就是说，任何的二进制序列也都可以用这64个字符表示出来，这也是其名称的来源。我们加密的方法，就是将原来的信息以ACSLL的标准转化为二进制序列（如果不是6的倍数，就用0补齐），然后按照Base64的标准，将其转化为该标准下的字符。
base64位加密,解密方法
zhangjitao的博客
12-27 946
#import #define __BASE64( text )        [CommonFunc base64StringFromText:text] #define __TEXT( base64 )        [CommonFunc textFromBase64String:base64] @interface CommonFunc : NSObject /***
霍夫曼编码/解码
Zllvincent的博客
06-02 1371
一.简介 把信息转换成计算机能够识别的二进制形式，被称为编码。按编码位数长度是否固定分为：定长编码、变长编码。 定长编码容易设计，运行效率高。如果要对数据信息压缩就需要采用变长编码，把出现频率高的用位数少的编码，出现频率低的用更多位编码便可以实现数据压缩。 霍夫曼树是一种WPL(树的带权路径) 最小的二叉树，二叉树刚好有左/右节点，可以方便映射为2进制（如左节点方向表示0，右节点方向表示1）。 霍夫曼编码是一种可变长编码方式，依据字符出现频率作为霍夫曼树节点的权重构建霍夫曼树。 二.实现 三.总结 1.霍夫
Base64编码
toweryangtao的专栏
01-29 405
Base64是网络上最常见的用于传输8Bit字节代码的编码方式之一，大家可以查看RFC2045～RFC2049，上面有MIME的详细规范。Base64编码可用于在HTTP环境下传递较长的标识信息。例如，在Java Persistence系统Hibernate中，就采用了Base64来将一个较长的唯一标识符（一般为128-bit的UUID）编码为一个字符串，用作HTTP表单和HTTP GET U
加密算法-BASE64
MonKee的博客
02-28 1254
基本的单向加密算法： 1.BASE64 ——严格地说，属于编码格式，而非加密算法 2.MD5——Message Digest algorithm 5，信息摘要算法 3.SHA——Secure Hash Algorithm，安全散列算法 4.HMAC——Hash Message Authentication Code，散列消息鉴别码         MD5、SHA、H
Base64加密原理——加密算法(1)
weixin_43742894的博客
04-14 2172
Base64从本质来说，其实并不是加密算法，只是一种编码方式而已，Base64的"加解密"也不叫加密解密，而是编码解码，但是现在一般都把它归为加密算法。 一、Base64简介 Base64编码将二进制数据编码为可现实的字母和数字，用于传送图形、声音和传真等非文本数据，常用于MIME电子邮件格式中。其使用含有65个字符和ASCLL字符集(第65个字符为"=",用于对字符串进行特殊处理)，并用6个进制...
Java8【有与无】【F1】Base64（标准的编码器和解码器）
琴韵悠悠
04-28 460
1.简介 Base64是一种非常常用的二进制编解码方案。编解码方法简单且公开，并不具有加密解密的效用。只作为一种二进制数据的文本存储格式。 包：java.util.Base64静态 64种编码类型： 基本：输出被映射到一组字符A-Za-z0-9+/，编码不添加任何行标，输出的解码仅支持A-Za-z0-9+/。 URL：输出映射到一组字符A-Za-z0-9+_，输出是URL和文件。 ...
什么是Base64算法？——全网最详细讲解
zhangmiaoping23的专栏
11-27 2665
什么是Base64算法？ 一、何为Base64算法 Base64是一种基于64个可打印字符来表示二进制数据的表示方法。由于2的6次方为64，所以每6个比特为一个单元，对应某个可打印字符。3个字节有24个比特，对应于4个Base64单元，即3个字节可由4个可打印字符来表示。它可用来作为电子邮件的传输编码。在Base64中的可打印字符包括字母A-Z、a-z、数字0-9，这样共有62个字符，此外两个可打印符号在不同的系统中而不同。 Bas...
自定义 Base64 加密算法
woxinyijiuw的专栏
05-14 901
自定义Base64加密   一．前言     最近做软件需要一个功能，就是对文件进行加密。本来嘛，加密算法一堆一堆的，但是试了几个成熟的加密算法后发现对文件进行加密需要的时间很长，特别是上G的文件，这样客户是接受不了的。最后没办法了，好坏也要找一个吧，就选定用Base64加密。标准的base64加密很简单，而且编码表也是固定的，所以只要稍加修改，也能成为有效的加密工具，虽然有一点弱，本来嘛这
Base64加密算法的C实现
12-19
Base64加密算法的C语言实现， 比较精简
custom-base-64:CustomBase64 Java 类，提供将字节数组编码解码为具有自定义字符集的 Base64 字符串的功能。 不使用填充字符。 不遵循 RFC 3548 或 RFC 4648
06-07
此 CustomBase64 类提供将字节数组编码/解码为 Base64 字符串的功能。 它不遵循 Base64 的 RFC 3548 或 RFC 4648 规范，因为可以指定使用的字符集并且不使用填充字符。 因此，只有用户通过调用 setBase64Charset(String) 提供的字符才会出现在编码字符串中，而不会出现等号“=”（有时用于 Base64 中的填充）等其他字符。
Java实现的Base64加密算法示例
08-27
主要介绍了Java实现的Base64加密算法,结合实例形式分析了Java实现的base64编码转换相关使用方法及操作注意事项,需要的朋友可以参考下
c++实现base64算法加密解密
06-18
c++实现base64算法加密解密，不需要修改，直接运行即可
Base64加密算法（工具类）
08-06
java代码。支持加密与解密，Base64加密算法
Base64 加密算法
12-27
算法类base64 的操作 字符串的加密技术，算法类base64 的操作 字符串的加密技术 as 版本
7、SHA1加密算法
热门推荐
Ron.Zheng
09-13 1万+
SHA1加密算法SHA是一种数据加密算法，该算法经过加密专家多年来的发展和改进已日益完善，现在已成为公认的最安全的散列算法之一，并被广泛使用。该算法的思想是接收一段明文，然后以一种不可逆的方式将它转换成一段（通常更小）密文，也可以简单的理解为取一串输入码（称为预映射或信息），并把它们转化为长度较短、位数固定的输出序列即散列值（也称为信息摘要或信息认证代码）的过程。散列函数值可以说是对明文的一种“指纹
PGP生成秘钥对及应用
Ron.Zheng
04-09 1万+
PGPDesktop下载链接：https://download.csdn.net/download/hfy19981024/10438982 1、下载安装PGP 安装很简单，根据安装包中的步骤一步一步安装破解之后即可使用。 2、生成秘钥 点击下一步输入名称和邮箱 选择Advanced，可以选择PGP加密时的对称加密算法及非对称加密算法即对应的秘钥长度。 继续往下，根据向导完成秘钥生成即可...
base64加密算法
07-28
Base64是一种常用的加密算法，用于将二进制数据转换为可打印的ASCII字符。它将输入数据分割成固定大小的块，然后将每个块编码为对应的ASCII字符。Base64编码使用了64个字符（A-Z，a-z，0-9和两个额外的字符）来表示...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

RonTech

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值