虫术 虫术
首页
目录
  • 国内验证码

    • 顶象 DING XIANG
    • 数美 NEXTDATA
    • 易盾 NETEASE YIDUN
    • 极验 GEETEST
    • 阿里云云盾验证码
    • 腾讯天御 T-Sec
    • 小红书 redCaptcha
    • 小盾 XIAODUN
    • 云片 YUNPIAN
    • 三六零天御
    • 螺丝帽 Luosimao
    • Vaptcha
    • V5 验证
    • 凯格 KYGER
    • 友验 FastYotest
  • 国外验证码

    • Cloudflare Turnstile
    • Google reCAPTCHA
    • hCaptcha
    • Arkose Labs FunCAPTCHA
    • DataDome CAPTCHA
    • PerimeterX丨HUMAN Challenge
    • AWS (Amazon) WAF Captcha
    • MTCaptcha
    • Lemin CAPTCHA丨Capy Puzzle
    • Yandex SmartCaptcha
    • mCaptcha
    • KeyCAPTCHA
    • CyberSiARA
    • Friendly Captcha
    • ARCaptcha
    • CaptchaFox
  • 辅助脚本

    • JS Hook
    • Frida API
    • babel
  • 命令查询

    • Linux 命令
    • ADB 命令
    • ARM 指令集
    • Dalvik 指令集
  • 指纹信息

    • CreepJS
    • Fingerprint2
    • 自动化工具检测
  • 加密算法

    • URL
    • Unicode
    • Base64
    • MD5
    • HMAC
    • SHA
    • RSA
    • AES
    • DES
    • 3DES
    • RC4
    • SM
  • 基本请求

    • Python
  • 异步协程

    • asyncio
    • gevent
  • 多线程

    • threading
    • vthread
  • 多进程

    • multiprocessing
  • 自动化框架

    • selenium
    • pyppeteer
    • playwright
    • splash
    • DrissionPage
    • appium
    • airtest
  • 接口编写

    • FastAPI
    • flask
    • express
  • 爬虫框架

    • scrapy
    • feapder
    • pyspider
  • 数据提取

    • re
    • lxml
    • BeautifulSoup
    • pyquery
    • selectolax
  • 数据分析

    • wordcloud
    • jieba
    • pandas
    • NumPy
    • SciPy
  • 制表绘图

    • matplotlib
    • pyecharts
    • plotly
    • seaborn
  • 数据存储

    • 文件存储
    • MySQL
    • MongoDB
    • Redis
    • SQLite
悟空风控
赞助
GitHub (opens new window)
首页
目录
  • 国内验证码

    • 顶象 DING XIANG
    • 数美 NEXTDATA
    • 易盾 NETEASE YIDUN
    • 极验 GEETEST
    • 阿里云云盾验证码
    • 腾讯天御 T-Sec
    • 小红书 redCaptcha
    • 小盾 XIAODUN
    • 云片 YUNPIAN
    • 三六零天御
    • 螺丝帽 Luosimao
    • Vaptcha
    • V5 验证
    • 凯格 KYGER
    • 友验 FastYotest
  • 国外验证码

    • Cloudflare Turnstile
    • Google reCAPTCHA
    • hCaptcha
    • Arkose Labs FunCAPTCHA
    • DataDome CAPTCHA
    • PerimeterX丨HUMAN Challenge
    • AWS (Amazon) WAF Captcha
    • MTCaptcha
    • Lemin CAPTCHA丨Capy Puzzle
    • Yandex SmartCaptcha
    • mCaptcha
    • KeyCAPTCHA
    • CyberSiARA
    • Friendly Captcha
    • ARCaptcha
    • CaptchaFox
  • 辅助脚本

    • JS Hook
    • Frida API
    • babel
  • 命令查询

    • Linux 命令
    • ADB 命令
    • ARM 指令集
    • Dalvik 指令集
  • 指纹信息

    • CreepJS
    • Fingerprint2
    • 自动化工具检测
  • 加密算法

    • URL
    • Unicode
    • Base64
    • MD5
    • HMAC
    • SHA
    • RSA
    • AES
    • DES
    • 3DES
    • RC4
    • SM
  • 基本请求

    • Python
  • 异步协程

    • asyncio
    • gevent
  • 多线程

    • threading
    • vthread
  • 多进程

    • multiprocessing
  • 自动化框架

    • selenium
    • pyppeteer
    • playwright
    • splash
    • DrissionPage
    • appium
    • airtest
  • 接口编写

    • FastAPI
    • flask
    • express
  • 爬虫框架

    • scrapy
    • feapder
    • pyspider
  • 数据提取

    • re
    • lxml
    • BeautifulSoup
    • pyquery
    • selectolax
  • 数据分析

    • wordcloud
    • jieba
    • pandas
    • NumPy
    • SciPy
  • 制表绘图

    • matplotlib
    • pyecharts
    • plotly
    • seaborn
  • 数据存储

    • 文件存储
    • MySQL
    • MongoDB
    • Redis
    • SQLite
悟空风控
赞助
GitHub (opens new window)
bright data bright data

(进入注册为作者充电)

  • 辅助脚本

    • JS Hook
    • Frida API
    • Babel
  • 命令查询

    • Linux 命令
    • ADB 命令
    • ARM 指令集
    • Dalvik 指令集
  • 指纹信息

    • CreepJS
    • Fingerprint2
    • 自动化工具检测
  • 加密算法

    • URL
    • Unicode
    • Base64
      • Python
      • JavaScript
      • Golang
      • 主要特征
      • 在线工具
    • MD5
    • HMAC
    • SHA
    • RSA
    • AES
    • DES
    • 3DES
    • RC4
    • SM
目录

Base64

关于 Base64 编码

Base64 是网络上最常见的用于传输 8Bit 字节码的编码方式之一,Base64 是一种基于 64 个可打印字符来表示二进制数据的方法。由于 ,所以每 6 个比特为一个单元,对应某个可打印字符,3 个字节相当于 24 个比特,对应于 4 个 Base64 单元,即 3 个字节可由 4 个可打印字符来表示。Base64 包括字母 a-z、A-Z、数字 0-9、符号 +、/ 一共 64 个字符的字符集,任何符号都可以转换成这个字符集中的字符,这个转换过程就叫做 Base64 编码。

Base64 编码是从二进制到字符的过程,可用于在 HTTP 环境下传递较长的标识信息。采用 Base64 编码具有不可读性,需要解码后才能阅读。

Base64 维基百科 (opens new window)

# Python 3.0+

    import base64
    
    
    data = "spiderapi.cn - 虫术"
    
    result_encoded = base64.b64encode(data.encode("utf-8")).decode("utf-8")
    result_decoded = base64.b64decode(result_encoded).decode("utf-8")
    print("Base64 编码值:", result_encoded)  # c3BpZGVyYXBpLmNuIC0g6Jmr5pyv
    print("Base64 解码值:", result_decoded)
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    # 不借助官方或者第三方库,纯源码实现
    
    def base64_encode(input_string):
        base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
        result = ""
        # 将输入字符串转换为字节
        input_bytes = input_string.encode("utf-8")
        for i in range(0, len(input_bytes), 3):
            chunk = input_bytes[i:i + 3]
            # 将每个字符转换为ASCII码
            chunk_bytes = [byte for byte in chunk]
            # 将三个字节合并为一个24位的二进制字符串
            binary_string = "".join(format(byte, "08b") for byte in chunk_bytes)
    
            # 根据需求在二进制字符串末尾补0
            while len(binary_string) % 24 != 0:
                binary_string += "0"
    
            # 将24位的二进制字符串切分为6位的小块
            six_bit_chunks = [binary_string[j:j + 6] for j in range(0, len(binary_string), 6)]
    
            # 将每个6位的二进制字符串转换为相应的Base64字符
            for six_bit_chunk in six_bit_chunks:
                if len(six_bit_chunk) < 6:
                    six_bit_chunk = six_bit_chunk.ljust(6, '0')
                result += base64_chars[int(six_bit_chunk, 2)]
    
        # 对不足3个字符的情况进行Base64填充
        padding = len(input_bytes) % 3
        if padding == 1:
            result += "=="
        elif padding == 2:
            result += "="
    
        return result
    
    
    def base64_decode(encoded_string):
        base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
        result = bytearray()
        # 对于每4个Base64字符,将其解码为3个原始字符
        for i in range(0, len(encoded_string), 4):
            chunk = encoded_string[i:i + 4]
            # 将每个Base64字符转换为其对应的6位二进制字符串
            binary_string = ""
            for char in chunk:
                if char != "=":
                    binary_string += format(base64_chars.index(char), "06b")
    
            # 将24位的二进制字符串切分为8位的字符
            eight_bit_chunks = [binary_string[j:j + 8] for j in range(0, len(binary_string), 8)]
    
            # 将每个8位的二进制字符串转换为相应的字节
            for eight_bit_chunk in eight_bit_chunks:
                result.append(int(eight_bit_chunk, 2))
    
        return result.decode("utf-8")
    
    
    if __name__ == "__main__":
        data = "spiderapi.cn - 虫术"
    
        result_encoded = base64_encode(data)
        result_decoded = base64_decode(result_encoded)
        print("Base64 编码值:", result_encoded)  # c3BpZGVyYXBpLmNuIC0g6Jmr5pyv
        print("Base64 解码值:", result_decoded)
    
    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
    // Make sure to add code blocks to your code group

    # JavaScript Node.js ECMAScript 5.1+

      // 使用内置函数 btoa 和 atob
      // 需要注意的是函数仅支持编码 Latin1 字符集,所以像汉字这样的字符集无法编码,需要将字符串作为 URI 组件进行编码后再进行 Base64 编码。
      
      var dataLatin1 = "spiderapi.cn";
      var dataChinese = "spiderapi.cn - 虫术";
      
      var resultEncodedLatin1 = btoa(dataLatin1);
      var resultDecodedLatin1 = atob(resultEncodedLatin1);
      
      var resultEncodedChinese = btoa(unescape(encodeURIComponent(dataChinese)));
      var resultDecodedChinese = decodeURIComponent(escape(atob(resultEncodedChinese)));
      
      console.log("Base64 英文编码值:", resultEncodedLatin1)   // c3BpZGVyYXBpLmNu
      console.log("Base64 英文解码值:", resultDecodedLatin1)
      console.log("Base64 中文编码值:", resultEncodedChinese)  // c3BpZGVyYXBpLmNuIC0g6Jmr5pyv
      console.log("Base64 中文解码值:", resultDecodedChinese)
      
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      // Node 环境内置方法
      
      var data = "spiderapi.cn - 虫术";
      
      var resultEncoded = new Buffer.from(data).toString("base64");
      var resultDecoded = new Buffer.from(resultEncoded, "base64").toString();
      
      console.log("Base64 编码值:", resultEncoded)  // c3BpZGVyYXBpLmNuIC0g6Jmr5pyv
      console.log("Base64 解码值:", resultDecoded)
      
      1
      2
      3
      4
      5
      6
      7
      8
      9
      // 安装依赖 npm install crypto-js
      
      var CryptoJS = require("crypto-js");
      
      var data = "spiderapi.cn - 虫术";
      var resultEncoded = CryptoJS.enc.Base64.stringify(CryptoJS.enc.Utf8.parse(data));
      var resultDecoded = CryptoJS.enc.Base64.parse(resultEncoded).toString(CryptoJS.enc.Utf8);
      
      console.log("Base64 编码值:", resultEncoded)  // c3BpZGVyYXBpLmNuIC0g6Jmr5pyv
      console.log("Base64 解码值:", resultDecoded)
      
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      // 不借助官方或者第三方库,纯源码实现
      
      var CryptoJS = CryptoJS || (function (Math, undefined) {
          var crypto;
          if (typeof window !== 'undefined' && window.crypto) {
              crypto = window.crypto;
          }
          if (typeof self !== 'undefined' && self.crypto) {
              crypto = self.crypto;
          }
          if (typeof globalThis !== 'undefined' && globalThis.crypto) {
              crypto = globalThis.crypto;
          }
          if (!crypto && typeof window !== 'undefined' && window.msCrypto) {
              crypto = window.msCrypto;
          }
          if (!crypto && typeof global !== 'undefined' && global.crypto) {
              crypto = global.crypto;
          }
          if (!crypto && typeof require === 'function') {
              try {
                  crypto = require('crypto');
              } catch (err) {}
          }
          var cryptoSecureRandomInt = function () {
              if (crypto) {
                  if (typeof crypto.getRandomValues === 'function') {
                      try {
                          return crypto.getRandomValues(new Uint32Array(1))[0];
                      } catch (err) {}
                  }
                  if (typeof crypto.randomBytes === 'function') {
                      try {
                          return crypto.randomBytes(4).readInt32LE();
                      } catch (err) {}
                  }
              }
              throw new Error('Native crypto module could not be used to get secure random number.');
          };
          var create = Object.create || (function () {
              function F() {}
              return function (obj) {
                  var subtype;
                  F.prototype = obj;
                  subtype = new F();
                  F.prototype = null;
                  return subtype;
              };
          }());
          var C = {};
          var C_lib = C.lib = {};
          var Base = C_lib.Base = (function () {
              return {
                  extend: function (overrides) {
                      var subtype = create(this);
                      if (overrides) {
                          subtype.mixIn(overrides);
                      }
                      if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {
                          subtype.init = function () {
                              subtype.$super.init.apply(this, arguments);
                          };
                      }
                      subtype.init.prototype = subtype;
                      subtype.$super = this;
                      return subtype;
                  }, create: function () {
                      var instance = this.extend();
                      instance.init.apply(instance, arguments);
                      return instance;
                  }, init: function () {}, mixIn: function (properties) {
                      for (var propertyName in properties) {
                          if (properties.hasOwnProperty(propertyName)) {
                              this[propertyName] = properties[propertyName];
                          }
                      }
                      if (properties.hasOwnProperty('toString')) {
                          this.toString = properties.toString;
                      }
                  }, clone: function () {
                      return this.init.prototype.extend(this);
                  }
              };
          }());
          var WordArray = C_lib.WordArray = Base.extend({
              init: function (words, sigBytes) {
                  words = this.words = words || [];
                  if (sigBytes != undefined) {
                      this.sigBytes = sigBytes;
                  } else {
                      this.sigBytes = words.length * 4;
                  }
              }, toString: function (encoder) {
                  return (encoder || Hex).stringify(this);
              }, concat: function (wordArray) {
                  var thisWords = this.words;
                  var thatWords = wordArray.words;
                  var thisSigBytes = this.sigBytes;
                  var thatSigBytes = wordArray.sigBytes;
                  this.clamp();
                  if (thisSigBytes % 4) {
                      for (var i = 0; i < thatSigBytes; i++) {
                          var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
                          thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);
                      }
                  } else {
                      for (var j = 0; j < thatSigBytes; j += 4) {
                          thisWords[(thisSigBytes + j) >>> 2] = thatWords[j >>> 2];
                      }
                  }
                  this.sigBytes += thatSigBytes;
                  return this;
              }, clamp: function () {
                  var words = this.words;
                  var sigBytes = this.sigBytes;
                  words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);
                  words.length = Math.ceil(sigBytes / 4);
              }, clone: function () {
                  var clone = Base.clone.call(this);
                  clone.words = this.words.slice(0);
                  return clone;
              }, random: function (nBytes) {
                  var words = [];
                  var r = (function (m_w) {
                      var m_w = m_w;
                      var m_z = 0x3ade68b1;
                      var mask = 0xffffffff;
                      return function () {
                          m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask;
                          m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask;
                          var result = ((m_z << 0x10) + m_w) & mask;
                          result /= 0x100000000;
                          result += 0.5;
                          return result * (Math.random() > .5 ? 1 : -1);
                      }
                  });
                  var RANDOM = false, _r;
                  try {
                      cryptoSecureRandomInt();
                      RANDOM = true;
                  } catch (err) {}
                  for (var i = 0, rcache; i < nBytes; i += 4) {
                      if (!RANDOM) {
                          _r = r((rcache || Math.random()) * 0x100000000);
                          rcache = _r() * 0x3ade67b7;
                          words.push((_r() * 0x100000000) | 0);
                          continue;
                      }
                      words.push(cryptoSecureRandomInt());
                  }
                  return new WordArray.init(words, nBytes);
              }
          });
          var C_enc = C.enc = {};
          var Hex = C_enc.Hex = {
              stringify: function (wordArray) {
                  var words = wordArray.words;
                  var sigBytes = wordArray.sigBytes;
                  var hexChars = [];
                  for (var i = 0; i < sigBytes; i++) {
                      var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
                      hexChars.push((bite >>> 4).toString(16));
                      hexChars.push((bite & 0x0f).toString(16));
                  }
                  return hexChars.join('');
              }, parse: function (hexStr) {
                  var hexStrLength = hexStr.length;
                  var words = [];
                  for (var i = 0; i < hexStrLength; i += 2) {
                      words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);
                  }
                  return new WordArray.init(words, hexStrLength / 2);
              }
          };
          var Latin1 = C_enc.Latin1 = {
              stringify: function (wordArray) {
                  var words = wordArray.words;
                  var sigBytes = wordArray.sigBytes;
                  var latin1Chars = [];
                  for (var i = 0; i < sigBytes; i++) {
                      var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
                      latin1Chars.push(String.fromCharCode(bite));
                  }
                  return latin1Chars.join('');
              }, parse: function (latin1Str) {
                  var latin1StrLength = latin1Str.length;
                  var words = [];
                  for (var i = 0; i < latin1StrLength; i++) {
                      words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);
                  }
                  return new WordArray.init(words, latin1StrLength);
              }
          };
          var Utf8 = C_enc.Utf8 = {
              stringify: function (wordArray) {
                  try {
                      return decodeURIComponent(escape(Latin1.stringify(wordArray)));
                  } catch (e) {
                      throw new Error('Malformed UTF-8 data');
                  }
              }, parse: function (utf8Str) {
                  return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
              }
          };
          var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
              reset: function () {
                  this._data = new WordArray.init();
                  this._nDataBytes = 0;
              }, _append: function (data) {
                  if (typeof data == 'string') {
                      data = Utf8.parse(data);
                  }
                  this._data.concat(data);
                  this._nDataBytes += data.sigBytes;
              }, _process: function (doFlush) {
                  var processedWords;
                  var data = this._data;
                  var dataWords = data.words;
                  var dataSigBytes = data.sigBytes;
                  var blockSize = this.blockSize;
                  var blockSizeBytes = blockSize * 4;
                  var nBlocksReady = dataSigBytes / blockSizeBytes;
                  if (doFlush) {
                      nBlocksReady = Math.ceil(nBlocksReady);
                  } else {
                      nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
                  }
                  var nWordsReady = nBlocksReady * blockSize;
                  var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);
                  if (nWordsReady) {
                      for (var offset = 0; offset < nWordsReady; offset += blockSize) {
                          this._doProcessBlock(dataWords, offset);
                      }
                      processedWords = dataWords.splice(0, nWordsReady);
                      data.sigBytes -= nBytesReady;
                  }
                  return new WordArray.init(processedWords, nBytesReady);
              }, clone: function () {
                  var clone = Base.clone.call(this);
                  clone._data = this._data.clone();
                  return clone;
              }, _minBufferSize: 0
          });
          var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
              cfg: Base.extend(),
              init: function (cfg) {
                  this.cfg = this.cfg.extend(cfg);
                  this.reset();
              }, reset: function () {
                  BufferedBlockAlgorithm.reset.call(this);
                  this._doReset();
              }, update: function (messageUpdate) {
                  this._append(messageUpdate);
                  this._process();
                  return this;
              }, finalize: function (messageUpdate) {
                  if (messageUpdate) {
                      this._append(messageUpdate);
                  }
                  var hash = this._doFinalize();
                  return hash;
              }, blockSize: 512 / 32,
              _createHelper: function (hasher) {
                  return function (message, cfg) {
                      return new hasher.init(cfg).finalize(message);
                  };
              }, _createHmacHelper: function (hasher) {
                  return function (message, key) {
                      return new C_algo.HMAC.init(hasher, key).finalize(message);
                  };
              }
          });
          var C_algo = C.algo = {};
          return C;
      }(Math));
      
      (function () {
          var C = CryptoJS;
          var C_lib = C.lib;
          var WordArray = C_lib.WordArray;
          var C_enc = C.enc;
          var Base64 = C_enc.Base64 = {
              stringify: function (wordArray) {
                  var words = wordArray.words;
                  var sigBytes = wordArray.sigBytes;
                  var map = this._map;
                  wordArray.clamp();
                  var base64Chars = [];
                  for (var i = 0; i < sigBytes; i += 3) {
                      var byte1 = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
                      var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff;
                      var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff;
                      var triplet = (byte1 << 16) | (byte2 << 8) | byte3;
                      for (var j = 0;
                           (j < 4) && (i + j * 0.75 < sigBytes); j++) {
                          base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f));
                      }
                  }
                  var paddingChar = map.charAt(64);
                  if (paddingChar) {
                      while (base64Chars.length % 4) {
                          base64Chars.push(paddingChar);
                      }
                  }
                  return base64Chars.join('');
              }, parse: function (base64Str) {
                  var base64StrLength = base64Str.length;
                  var map = this._map;
                  var reverseMap = this._reverseMap;
                  if (!reverseMap) {
                      reverseMap = this._reverseMap = [];
                      for (var j = 0; j < map.length; j++) {
                          reverseMap[map.charCodeAt(j)] = j;
                      }
                  }
                  var paddingChar = map.charAt(64);
                  if (paddingChar) {
                      var paddingIndex = base64Str.indexOf(paddingChar);
                      if (paddingIndex !== -1) {
                          base64StrLength = paddingIndex;
                      }
                  }
                  return parseLoop(base64Str, base64StrLength, reverseMap);
              }, _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
          };
          function parseLoop(base64Str, base64StrLength, reverseMap) {
              var words = [];
              var nBytes = 0;
              for (var i = 0; i < base64StrLength; i++) {
                  if (i % 4) {
                      var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2);
                      var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2);
                      words[nBytes >>> 2] |= (bits1 | bits2) << (24 - (nBytes % 4) * 8);
                      nBytes++;
                  }
              }
              return WordArray.create(words, nBytes);
          }
      }());
      
      
      var data = "spiderapi.cn - 虫术";
      var resultEncoded = CryptoJS.enc.Base64.stringify(CryptoJS.enc.Utf8.parse(data));
      var resultDecoded = CryptoJS.enc.Base64.parse(resultEncoded).toString(CryptoJS.enc.Utf8);
      
      console.log("Base64 编码值:", resultEncoded)  // c3BpZGVyYXBpLmNuIC0g6Jmr5pyv
      console.log("Base64 解码值:", resultDecoded)
      
      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
      241
      242
      243
      244
      245
      246
      247
      248
      249
      250
      251
      252
      253
      254
      255
      256
      257
      258
      259
      260
      261
      262
      263
      264
      265
      266
      267
      268
      269
      270
      271
      272
      273
      274
      275
      276
      277
      278
      279
      280
      281
      282
      283
      284
      285
      286
      287
      288
      289
      290
      291
      292
      293
      294
      295
      296
      297
      298
      299
      300
      301
      302
      303
      304
      305
      306
      307
      308
      309
      310
      311
      312
      313
      314
      315
      316
      317
      318
      319
      320
      321
      322
      323
      324
      325
      326
      327
      328
      329
      330
      331
      332
      333
      334
      335
      336
      337
      338
      339
      340
      341
      342
      343
      344
      345
      346
      347
      // 不借助官方或者第三方库,纯源码实现
      
      var Base64 = {
          _keyStr: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
      
          encode: function(input) {
              var output = "";
              var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
              var i = 0;
              input = Base64.utf8Encode(input);
              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 += Base64._keyStr.charAt(enc1) + Base64._keyStr.charAt(enc2) +
                      Base64._keyStr.charAt(enc3) + Base64._keyStr.charAt(enc4);
              }
              return output;
          },
      
          decode: function(input) {
              var output = "";
              var chr1, chr2, chr3;
              var enc1, enc2, enc3, enc4;
              var i = 0;
              input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
              while (i < input.length) {
                  enc1 = Base64._keyStr.indexOf(input.charAt(i++));
                  enc2 = Base64._keyStr.indexOf(input.charAt(i++));
                  enc3 = Base64._keyStr.indexOf(input.charAt(i++));
                  enc4 = Base64._keyStr.indexOf(input.charAt(i++));
                  chr1 = (enc1 << 2) | (enc2 >> 4);
                  chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
                  chr3 = ((enc3 & 3) << 6) | enc4;
                  output += String.fromCharCode(chr1);
                  if (enc3 !== 64) {
                      output += String.fromCharCode(chr2);
                  }
                  if (enc4 !== 64) {
                      output += String.fromCharCode(chr3);
                  }
              }
              output = Base64.utf8Decode(output);
              return output;
          },
      
          utf8Encode: function(string) {
              string = string.replace(/\r\n/g, "\n");
              var utfText = "";
              for (var n = 0; n < string.length; n++) {
                  var c = string.charCodeAt(n);
                  if (c < 128) {
                      utfText += String.fromCharCode(c);
                  } else if ((c > 127) && (c < 2048)) {
                      utfText += String.fromCharCode((c >> 6) | 192);
                      utfText += String.fromCharCode((c & 63) | 128);
                  } else {
                      utfText += String.fromCharCode((c >> 12) | 224);
                      utfText += String.fromCharCode(((c >> 6) & 63) | 128);
                      utfText += String.fromCharCode((c & 63) | 128);
                  }
              }
              return utfText;
          },
      
          utf8Decode: function(utfText) {
              var string = "";
              var i = 0;
              var c, c1, c2;
              while (i < utfText.length) {
                  c = utfText.charCodeAt(i);
                  if (c < 128) {
                      string += String.fromCharCode(c);
                      i++;
                  } else if ((c > 191) && (c < 224)) {
                      c2 = utfText.charCodeAt(i + 1);
                      string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
                      i += 2;
                  } else {
                      c2 = utfText.charCodeAt(i + 1);
                      var c3 = utfText.charCodeAt(i + 2);
                      string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
                      i += 3;
                  }
              }
              return string;
          }
      };
      
      
      var data = "spiderapi.cn - 虫术";
      var resultEncoded = Base64.encode(data);
      var resultDecoded = Base64.decode(resultEncoded);
      
      console.log("Base64 编码值:", resultEncoded)  // c3BpZGVyYXBpLmNuIC0g6Jmr5pyv
      console.log("Base64 解码值:", resultDecoded)
      
      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
      // Make sure to add code blocks to your code group

      # Golang 1.0+

        package main
        
        import (
            "encoding/base64"
            "fmt"
        )
        
        func main() {
            data := "spiderapi.cn - 虫术"
            
            resultEncoded := base64.StdEncoding.EncodeToString([]byte(data))
            resultDecoded, err := base64.StdEncoding.DecodeString(resultEncoded)
            if err != nil {
                fmt.Println("Base64 decode error:", err)
                return
            }
            fmt.Println("Base64 编码值:", resultEncoded) // c3BpZGVyYXBpLmNuIC0g6Jmr5pyv
            fmt.Println("Base64 解码值:", string(resultDecoded))
        }
        
        1
        2
        3
        4
        5
        6
        7
        8
        9
        10
        11
        12
        13
        14
        15
        16
        17
        18
        19
        // 不借助官方或者第三方库,纯源码实现
        
        package main
        
        import "fmt"
        
        const (
            base64Table = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
        )
        
        func base64Encode(data []byte) []byte {
            var result []byte
            pad := len(data) % 3
            for i := 0; i < len(data); i += 3 {
            threeBytes := (int(data[i]) << 16) | (int(data[i+1]) << 8) | int(data[i+2])
                result = append(result, base64Table[(threeBytes>>18)&0x3F])
                result = append(result, base64Table[(threeBytes>>12)&0x3F])
                result = append(result, base64Table[(threeBytes>>6)&0x3F])
                result = append(result, base64Table[threeBytes&0x3F])
            }
            if pad > 0 {
                result[len(result)-1] = '='
                if pad == 1 {
                    result[len(result)-2] = '='
                }
            }
            return result
        }
        
        func base64Decode(input string) ([]byte, error) {
            var result []byte
            pad := 0
            if input[len(input)-1] == '=' {
                pad++
            }
            if input[len(input)-2] == '=' {
                pad++
            }
            for i := 0; i < len(input); i += 4 {
                oneBytes := (index(input[i]) << 18) | (index(input[i+1]) << 12) | (index(input[i+2]) << 6) | index(input[i+3])
                result = append(result, byte((oneBytes>>16)&0xFF))
                result = append(result, byte((oneBytes>>8)&0xFF))
                result = append(result, byte(oneBytes&0xFF))
            }
            return result[:len(result)-pad], nil
        }
        
        func index(char byte) int {
            for i := 0; i < len(base64Table); i++ {
                if base64Table[i] == char {
                    return i
                }
            }
            return -1
        }
        
        func main() {
            data := "spiderapi.cn - 虫术"
          
            resultEncoded := base64Encode([]byte(data))
            resultDecoded, err := base64Decode(string(resultEncoded))
            if err != nil {
              fmt.Println("Base64 decode error:", err)
              return
            }
            fmt.Println("Base64 编码值:", string(resultEncoded)) // c3BpZGVyYXBpLmNuIC0g6Jmr5pyv
            fmt.Println("Base64 解码值:", string(resultDecoded))
        }
        
        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
        // Make sure to add code blocks to your code group

        # 主要特征

        Base64 是我们最常见的编码,除此之外,其实还有 Base16、Base32、Base58、Base85、Base100 等,Base 系列主要特征如下:

        • Base16:结尾没有等号,数字要多于字母;
        • Base32:字母要多于数字,明文数量超过10个,结尾可能会有很多等号;
        • Base58:结尾没有等号,字母要多于数字;
        • Base64:一般情况下结尾都会有1个或者2个等号,明文很少的时候可能没有,由 a-z、A-Z、0-9、+、/ 组成;
        • Base85:等号一般出现在字符串中间,含有一些奇怪的字符;
        • Base100:密文由 Emoji 表情组成。

        示例:

        编码类型 示例一 示例二
        明文 01234567890 administrators
        Base16 3031323334353637383930 61646D696E6973747261746F7273
        Base32 GAYTEMZUGU3DOOBZGA====== MFSG22LONFZXI4TBORXXE4Y=
        Base58 cX8j8pvGzppMKVb BNF5dFLUTN5XwM1yLoF
        Base64 MDEyMzQ1Njc4OTA= YWRtaW5pc3RyYXRvcnM=
        Base85 0JP==1c70M3&rY @:X4hDJ=06Eaa'.EcV
        Base100 🐧🐨🐩🐪🐫🐬🐭🐮🐯🐰🐧 👘👛👤👠👥👠👪👫👩👘👫👦👩👪

        # 在线工具

        • https://base64.us/ (opens new window)
        • https://tool.chinaz.com/tools/base64.aspx (opens new window)
        帮助我们改善此页 (opens new window)
        上次更新: 2025/04/22, 14:38:07
        Unicode
        MD5

        ← Unicode MD5→

        ICP 备案 鄂ICP备19003281号-9丨 MPS 公网安备 鄂公网安备42280202422959丨 Theme by Vdoing Theme Vdoing丨 Tencent EdgeOne Tencent EdgeOne丨 51la 网站统计

        Copyright © 2023 - 2025 WuKong Security.丨 正在载入网站运行时间...丨
        • 跟随系统
        • 浅色模式
        • 深色模式
        • 阅读模式