base64加密解密_base64 解密

base64加密解密过程

Base64会使用一串固定编码: ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/

• 加密过程

想要使用Base64加密，原文长度必须是3的倍数。如果原文不是3的倍数就填充其他符号来凑足成3的倍数;

• 1，将明文对照以ACSSI码表转换成一个8位二进制数；
• 2，将转换后的数据每次取出六位依次取出转换成十进制；
• 3，将转换出来的十进制数对照Base64对应表转换成字符；（Base64对应表可搜索）
• 解密过程：
  • 1，将密文按照对照表获得十进制数；
  • 2，将十进制转换成二进制取低六位整合在一起；
  • 3，将转换出来的二进制数依次取8位进行解密；

base64加密解密实现

主要是对字符串的处理，所以对字符串相关的方法和属性一定要熟练；

javascript原生方法

• 方法：

  • atob()：解码一个Base64字符串;
  • btoa()：从一个字符串或者二进制数据编码一个Base64字符串;

• 使用

  • 默认转换ASCII字母和数字，不支持中文；

  let encodeRes = btoa("hello")
  let decodeRes = atob(encodeRes)
  1
  2

  • 转换中文的方法

  //中文转URL再转为Base64
  let encodeRes = btoa(encodeURIComponent("你好"))
  //解码先解为URL，再转成中文
  let decodeRes = decodeURIComponent(atob(encodeRes))
  1
  2
  3
  4

手写封装

• 封装:我们假设在项目中要使用这个功能，自己封装函数并导出；

//在封装公共方法的文件夹下新建base.js文件
//我习惯写类(函数也可以)
export class Base64{

  constructor() {

    //固定编码

    this.keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";

  }

  //加密

  encode(str) {

    //先将字符串UTF-8编码

    str = this._utf8_encode(str)

    let res = ""

    let i = 0

    let char1, char2, char3, enc1, enc2, enc3, enc4;

    while (i < str.length) {

      char1 = str.charCodeAt(i++);

      char2 = str.charCodeAt(i++);

      char3 = str.charCodeAt(i++);

      enc1 = char1 >> 2;

      enc2 = ((char1 & 3) << 4) | (char2 >> 4);

      enc3 = ((char2 & 15) << 2) | (char3 >> 6);

      enc4 = char3 & 63;

      if (isNaN(char2)) {

        enc3 = enc4 = 64;

      } else if (isNaN(char3)) {

        enc4 = 64;

      }

      res = res +

        this.keyStr.charAt(enc1) + this.keyStr.charAt(enc2) +

        this.keyStr.charAt(enc3) + this.keyStr.charAt(enc4);

    }

    return res;

  }

  //解密

  decode(str) {

    str = str.replace(/[^A-Za-z0-9\+\/\=]/g, "");

    let res = ""

    let i = 0

    let char1, char2, char3, enc1, enc2, enc3, enc4;

    while (i < str.length) {

      enc1 = this.keyStr.indexOf(str.charAt(i++));

      enc2 = this.keyStr.indexOf(str.charAt(i++));

      enc3 = this.keyStr.indexOf(str.charAt(i++));

      enc4 = this.keyStr.indexOf(str.charAt(i++));

      char1 = (enc1 << 2) | (enc2 >> 4);

      char2 = ((enc2 & 15) << 4) | (enc3 >> 2);

      char3 = ((enc3 & 3) << 6) | enc4;

      res = res + String.fromCharCode(char1);

      if (enc3 != 64) {

        res = res + String.fromCharCode(char2);

      }

      if (enc4 != 64) {

        res = res + String.fromCharCode(char3);

      }

    }

    //最后将字符串UTF-8解码

    res = this._utf8_decode(res)

    return res;

  }

  //UTF-8编码

  _utf8_encode(str) {

    //回车换行符替换为换行符

    str = str.replace(/\r\n/g, "\n")

    //加密后的返回结果是一个字符串

    let res = ""

    for (let i = 0; i < str.length; i++){

      //字符串方法 charCodeAt() 用于检索字符串中特定位置的字符的Unicode值,返回一个UTF-16值（一个介于 0-65535之间的16位整数;

      //字符串方法fromCharCode() 用于从给定的Unicode获取字符;

      //位运算

      // >> :(左移)各二进位全部左移若干位，高位丢弃，低位补0;

      // & :(与)两个位都为1时，结果才为1;

      // | :(或)两个位都为0时，结果才为0;

      let char = string.charCodeAt(i);

      switch (char) {

        case char < 128:

          res += String.fromCharCode(char)

          break;

        case ((char > 127) && (char <2048)) :

          res += String.fromCharCode((char >> 6) | 192)

          res += String.fromCharCode((char & 63) | 128)

          break;

        default:

          res += String.fromCharCode((char >> 12) | 224)

          res += String.fromCharCode(((char >> 6) & 63) | 128)

          res += String.fromCharCode((char & 63) | 128)

          break;

      }

    }

    return res

  }

  //UTF-8解码

  _utf8_decode(str) {

    //解密后的返回结果是一个字符串

    let res = ""

    let i = 0;

    let char = 0;

    let char1 = 0;

    let char2 = 0;

    while (i < str.length) {

      char = str.charCodeAt(i);

      switch (char) {

        case char < 128:

          res += String.fromCharCode(char);

          i++;

          break;

        case  ((char > 191) && (char < 224)):

          char1 = str.charCodeAt(i + 1);

          res += String.fromCharCode(((char & 31) << 6) | (char1 & 63));

          i += 2;

          break;

        default:

          char1 = str.charCodeAt(i + 1);

          char2 = str.charCodeAt(i + 2);

          res += String.fromCharCode(((char & 15) << 12) | ((char1 & 63) << 6) | (char2 & 63));

          i += 3;

          break;

      }

    }

    return res

  }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240

• 使用：

//在使用的地方引入
import { Base64 } from '../../utils/base.js'
//使用
let str = '是你好不是hello'
let base64 = new Base64()
let encodeRes = base64.encode(str);
let decodeRes = base64.decode(encodeRes);

1
2
3
4
5
6
7
8