对称加密算法

最新推荐文章于 2025-08-22 11:12:38 发布
最新推荐文章于 2025-08-22 11:12:38 发布
阅读量1.2k 收藏 8
点赞数 3
CC 4.0 BY-SA版权
分类专栏： Android逆向 文章标签： 密码学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42403632/article/details/142928372
  1. 加密/解密的过程可逆的算法，叫做加密算法
  2. 加密/解密使用相同的密钥，叫做对称加密算法
  3. 对称加密算法的密钥可以随机给，但是有位数要求
  4. 对称加密算法的输入数据没有长度要求，加密速度快
  5. 各算法的密钥长度

RC4 密钥长度1-256字节

DES 密钥长度8字节

3DES/DESede/TripleDES 密钥长度24字节

AES 密钥长度16、24、32字节

根据密钥长度不同AES又分为AES-128、AES-192、AES-256

  1. 对称加密分类

  • 序列加密/流加密: 以字节流的方式，依次加密(解密)明文(密文)中的每一个字节

    RC4

  • 分组加密: 将明文消息分组(每组有多个字节)，逐组进行加密

    DES、3DES、AES

DES

SecretKeySpec desKey = new SecretKeySpec("12345678".getBytes(), "DES");
// IvParameterSpec ivParameterSpec = new IvParameterSpec("12345678".getBytes());
Cipher des = Cipher.getInstance("DES/CBC/PKCS5Padding");
des.init(Cipher.ENCRYPT_MODE, desKey)
byte[] result3 = des.doFinal("123456".getBytes());

//解密
des.init(Cipher.DECRYPT_MODE, desKey);
byte[] result4 = des.doFinal(result3);

CBC需要Iv向量

SecretKeySpec desKey = new SecretKeySpec("12345678".getBytes(), "DES");
IvParameterSpec ivParameterSpec = new IvParameterSpec("12345678".getBytes());
Cipher des = Cipher.getInstance("DES/CBC/PKCS5Padding");
des.init(Cipher.ENCRYPT_MODE, desKey, ivParameterSpec);
des.doFinal("123456".getBytes());

  1. 对称加密算法里，使用NOPadding，加密的明文必须等于分组长度倍数，否则报错

  2. 没有指明加密模式和填充方式，表示使用默认的DES/ECB/PKCS5Padding

  3. 加密后的字节数组可以编码成Hex、Base64

  4. 要复现一个对称加密算法，需要得到明文、key、iv、mode、padding

  5. 明文、key、iv需要注意解析方式，而且不一定是字符串形式

  6. 如果加密模式是ECB，则不需要加iv，加了的话会报错

  7. ECB模式和CBC模式的区别

  8. 如果使用PKCS5Padding，会对加密的明文填充1字节-1个分组的长度

  9. DES算法明文按64位进行分组加密

  10. 如果明文中有两个分组的内容相同，ECB会得到完全一样的密文，CBC不会

  11. 加密算法的结果通常与明文等长或者更长，如果变短了，那可能是gzip、protobuf、消息摘要算法

DESede

SecretKeySpec secretKeySpec = new SecretKeySpec("123456781234567812345678".getBytes(), "DESede");
IvParameterSpec ivParameterSpec = new IvParameterSpec("12345678".getBytes());
Cipher desede = Cipher.getInstance("DESede/CBC/PKCS5Padding");
desede.init(Cipher.ENCRYPT_MODE, desedeKey, ivParameterSpec);
desede.doFinal("xxxx".getBytes());

  1. DESede实际上是先进行DES加密，再进行DES解密，再进行DES加密

  2. DESede的密钥24个字节，第1个8字节密钥用于DES加密，之后类推

  3. 如果DESede的3个8字节密钥相同，则加密结果与DES一致

  4. 为了保证DESede的安全性，一般前2个或者3个8字节密钥都不一致

  5. DESede的其他特征与DES一致

AES

根据密钥长度不同，分为AES128、AES192、AES256

AES加解密的Java实现

SecretKeySpec key = new SecretKeySpec("1234567890abcdef".getBytes(),"AES");
AlgorithmParameterSpec iv = new IvParameterSpec("1234567890abcdef".getBytes());
Cipher aes = Cipher.getInstance("AES/CBC/PKCS5Padding");
aes.init(Cipher.ENCRYPT_MODE, key, iv);
aes.doFinal("xxxxbbbbcccc1234xxxxbbbbcccc1234".getBytes());

AES算法明文按128位进行分组加密，其余特征与DES一致

DES、3DES、AES算法通杀hook

Java.perform(function () {

    function showStacks() {
        console.log(
            Java.use("android.util.Log")
                .getStackTraceString(
                    Java.use("java.lang.Throwable").$new()
                )
        );
    }

    var ByteString = Java.use("com.android.okhttp.okio.ByteString");
    function toBase64(tag, data) {
        console.log(tag + " Base64: " + ByteString.of(data).base64());
    }
    function toHex(tag, data) {
        console.log(tag + " Hex: " + ByteString.of(data).hex());
    }
    function toUtf8(tag, data) {
        console.log(tag + " Utf8: " + ByteString.of(data).utf8());
    }

    // toUtf8("xiaojianbang",[48, 49, 50, 51, 52]);
    // toBase64("xiaojianbang",[48, 49, 50, 51, 52]);
    // toHex("xiaojianbang",[48, 49, 50, 51, 52]);

    var messageDigest = Java.use("java.security.MessageDigest");
    messageDigest.update.overload('byte').implementation = function (data) {
        console.log("MessageDigest.update('byte') is called!");
        console.log("=======================================================");
        return this.update(data);
    }
    messageDigest.update.overload('java.nio.ByteBuffer').implementation = function (data) {
        console.log("MessageDigest.update('java.nio.ByteBuffer') is called!");
        console.log("=======================================================");
        return this.update(data);
    }
    messageDigest.update.overload('[B').implementation = function (data) {
        console.log("MessageDigest.update('[B') is called!");
        showStacks();
        var algorithm = this.getAlgorithm();
        var tag = algorithm + " update data";
        toUtf8(tag, data);
        toHex(tag, data);
        toBase64(tag, data);
        console.log("=======================================================");
        return this.update(data);
    }
    messageDigest.update.overload('[B', 'int', 'int').implementation = function (data, start, length) {
        console.log("MessageDigest.update('[B', 'int', 'int') is called!");
        showStacks();
        var algorithm = this.getAlgorithm();
        var tag = algorithm + " update data";
        toUtf8(tag, data);
        toHex(tag, data);
        toBase64(tag, data);
        console.log("=======================================================", start, length);
        return this.update(data, start, length);
    }

    messageDigest.digest.overload().implementation = function () {
        console.log("MessageDigest.digest() is called!");
        showStacks();
        var result = this.digest();
        var algorithm = this.getAlgorithm();
        var tag = algorithm + " digest result";
        toUtf8(tag, result);
        toHex(tag, result);
        toBase64(tag, result);
        console.log("=======================================================");
        return result;
    }
    messageDigest.digest.overload('[B').implementation = function (data) {
        console.log("MessageDigest.digest('[B') is called!");
        showStacks();
        var algorithm = this.getAlgorithm();
        var tag = algorithm + " digest data";
        toUtf8(tag, data);
        toHex(tag, data);
        toBase64(tag, data);
        var result = this.digest(data);
        var tags = algorithm + " digest result";
        toUtf8(tag, result);
        toHex(tags, result);
        toBase64(tags, result);
        console.log("=======================================================");
        return result;
    }
    messageDigest.digest.overload('[B', 'int', 'int').implementation = function (data, start, length) {
        console.log("MessageDigest.digest('[B', 'int', 'int') is called!");
        showStacks();
        var algorithm = this.getAlgorithm();
        var tag = algorithm + " digest data";
        toUtf8(tag, data);
        toHex(tag, data);
        toBase64(tag, data);
        var result = this.digest(data, start, length);
        var tags = algorithm + " digest result";
        toHex(tags, result);
        toBase64(tags, result);
        console.log("=======================================================", start, length);
        return result;
    }

    var mac = Java.use("javax.crypto.Mac");
    mac.init.overload('java.security.Key', 'java.security.spec.AlgorithmParameterSpec').implementation = function (key, AlgorithmParameterSpec) {
        console.log("Mac.init('java.security.Key', 'java.security.spec.AlgorithmParameterSpec') is called!");
        console.log("=======================================================");
        return this.init(key, AlgorithmParameterSpec);
    }
    mac.init.overload('java.security.Key').implementation = function (key) {
        console.log("Mac.init('java.security.Key') is called!");
        var algorithm = this.getAlgorithm();
        var tag = algorithm + " init Key";
        var keyBytes = key.getEncoded();
        toUtf8(tag, keyBytes);
        toHex(tag, keyBytes);
        toBase64(tag, keyBytes);
        console.log("=======================================================");
        return this.init(key);
    }
    mac.update.overload('byte').implementation = function (data) {
        console.log("Mac.update('byte') is called!");
        return this.update(data);
    }
    mac.update.overload('java.nio.ByteBuffer').implementation = function (data) {
        console.log("Mac.update('java.nio.ByteBuffer') is called!");
        console.log("=======================================================");
        return this.update(data);
    }
    mac.update.overload('[B').implementation = function (data) {
        console.log("Mac.update('[B') is called!");
        var algorithm = this.getAlgorithm();
        var tag = algorithm + " update data";
        toUtf8(tag, data);
        toHex(tag, data);
        toBase64(tag, data);
        console.log("=======================================================");
        return this.update(data);
    }
    mac.update.overload('[B', 'int', 'int').implementation = function (data, start, length) {
        console.log("Mac.update('[B', 'int', 'int') is called!");
        var algorithm = this.getAlgorithm();
        var tag = algorithm + " update data";
        toUtf8(tag, data);
        toHex(tag, data);
        toBase64(tag, data);
        console.log("=======================================================", start, length);
        return this.update(data, start, length);
    }
    mac.doFinal.overload().implementation = function () {
        console.log("Mac.doFinal() is called!");
        var result = this.doFinal();
        var algorithm = this.getAlgorithm();
        var tag = algorithm + " doFinal result";
        toUtf8(tag, result);
        toHex(tag, result);
        toBase64(tag, result);
        console.log("=======================================================");
        return result;
    }
    mac.doFinal.overload('[B').implementation = function (data) {
        console.log("Mac.doFinal.overload('[B') is called!");
        return this.doFinal(data);
    }
    mac.doFinal.overload('[B', 'int').implementation = function (output, outOffset) {
        console.log("Mac.doFinal.overload('[B', 'int') is called!");
        console.log("=======================================================");
        return this.doFinal(output, outOffset);
    }

    var cipher = Java.use("javax.crypto.Cipher");
    cipher.init.overload('int', 'java.security.cert.Certificate').implementation = function () {
        console.log("Cipher.init('int', 'java.security.cert.Certificate') is called!");
        console.log("=======================================================");
        return this.init.apply(this, arguments);
    }
    cipher.init.overload('int', 'java.security.Key', 'java.security.SecureRandom').implementation = function () {
        console.log("Cipher.init('int', 'java.security.Key', 'java.security.SecureRandom') is called!");
        console.log("=======================================================");
        return this.init.apply(this, arguments);
    }
    cipher.init.overload('int', 'java.security.cert.Certificate', 'java.security.SecureRandom').implementation = function () {
        console.log("Cipher.init('int', 'java.security.cert.Certificate', 'java.security.SecureRandom') is called!");
        console.log("=======================================================");
        return this.init.apply(this, arguments);
    }
    cipher.init.overload('int', 'java.security.Key', 'java.security.AlgorithmParameters', 'java.security.SecureRandom').implementation = function () {
        console.log("Cipher.init('int', 'java.security.Key', 'java.security.AlgorithmParameters', 'java.security.SecureRandom') is called!");
        console.log("=======================================================");
        return this.init.apply(this, arguments);
    }
    cipher.init.overload('int', 'java.security.Key', 'java.security.spec.AlgorithmParameterSpec', 'java.security.SecureRandom').implementation = function () {
        console.log("Cipher.init('int', 'java.security.Key', 'java.security.spec.AlgorithmParameterSpec', 'java.security.SecureRandom') is called!");
        console.log("=======================================================");
        return this.init.apply(this, arguments);
    }
    cipher.init.overload('int', 'java.security.Key', 'java.security.AlgorithmParameters').implementation = function () {
        console.log("Cipher.init('int', 'java.security.Key', 'java.security.AlgorithmParameters') is called!");
        console.log("=======================================================");
        return this.init.apply(this, arguments);
    }

    cipher.init.overload('int', 'java.security.Key').implementation = function () {
        console.log("Cipher.init('int', 'java.security.Key') is called!");
        var algorithm = this.getAlgorithm();
        var tag = algorithm + " init Key";
        var className = JSON.stringify(arguments[1]);
        if(className.indexOf("OpenSSLRSAPrivateKey") === -1){
            var keyBytes = arguments[1].getEncoded();
            toUtf8(tag, keyBytes);
            toHex(tag, keyBytes);
            toBase64(tag, keyBytes);
        }
        console.log("=======================================================");
        return this.init.apply(this, arguments);
    }
    cipher.init.overload('int', 'java.security.Key', 'java.security.spec.AlgorithmParameterSpec').implementation = function () {
        console.log("Cipher.init('int', 'java.security.Key', 'java.security.spec.AlgorithmParameterSpec') is called!");
        var algorithm = this.getAlgorithm();
        var tag = algorithm + " init Key";
        var keyBytes = arguments[1].getEncoded();
        toUtf8(tag, keyBytes);
        toHex(tag, keyBytes);
        toBase64(tag, keyBytes);
        var tags = algorithm + " init iv";
        var iv = Java.cast(arguments[2], Java.use("javax.crypto.spec.IvParameterSpec"));
        var ivBytes = iv.getIV();
        toUtf8(tags, ivBytes);
        toHex(tags, ivBytes);
        toBase64(tags, ivBytes);
        console.log("=======================================================");
        return this.init.apply(this, arguments);
    }

    cipher.doFinal.overload('java.nio.ByteBuffer', 'java.nio.ByteBuffer').implementation = function () {
        console.log("Cipher.doFinal('java.nio.ByteBuffer', 'java.nio.ByteBuffer') is called!");
        console.log("=======================================================");
        return this.doFinal.apply(this, arguments);
    }
    cipher.doFinal.overload('[B', 'int').implementation = function () {
        console.log("Cipher.doFinal('[B', 'int') is called!");
        console.log("=======================================================");
        return this.doFinal.apply(this, arguments);
    }
    cipher.doFinal.overload('[B', 'int', 'int', '[B').implementation = function () {
        console.log("Cipher.doFinal('[B', 'int', 'int', '[B') is called!");
        console.log("=======================================================");
        return this.doFinal.apply(this, arguments);
    }
    cipher.doFinal.overload('[B', 'int', 'int', '[B', 'int').implementation = function () {
        console.log("Cipher.doFinal('[B', 'int', 'int', '[B', 'int') is called!");
        console.log("=======================================================");
        return this.doFinal.apply(this, arguments);
    }
    cipher.doFinal.overload().implementation = function () {
        console.log("Cipher.doFinal() is called!");
        console.log("=======================================================");
        return this.doFinal.apply(this, arguments);
    }

    cipher.doFinal.overload('[B').implementation = function () {
        console.log("Cipher.doFinal('[B') is called!");
        showStacks();
        var algorithm = this.getAlgorithm();
        var tag = algorithm + " doFinal data";
        var data = arguments[0];
        toUtf8(tag, data);
        toHex(tag, data);
        toBase64(tag, data);
        var result = this.doFinal.apply(this, arguments);
        var tags = algorithm + " doFinal result";
        toUtf8(tags, result);
        toHex(tags, result);
        toBase64(tags, result);
        console.log("=======================================================");
        return result;
    }
    cipher.doFinal.overload('[B', 'int', 'int').implementation = function () {
        console.log("Cipher.doFinal('[B', 'int', 'int') is called!");
        showStacks();
        var algorithm = this.getAlgorithm();
        var tag = algorithm + " doFinal data";
        var data = arguments[0];
        toUtf8(tag, data);
        toHex(tag, data);
        toBase64(tag, data);
        var result = this.doFinal.apply(this, arguments);
        var tags = algorithm + " doFinal result";
        toUtf8(tags, result);
        toHex(tags, result);
        toBase64(tags, result);
        console.log("=======================================================", arguments[1], arguments[2]);
        return result;
    }

});
TreeSize-Pro-9.0.1磁盘占用分析工具
11-09
TreeSize-Pro-9.0.1磁盘占用分析工具是一个热门的 精品软件 网站&程序、归属于八千导航中的 软件工具 导航。八千导航网小编已经测试过该程序，TreeSize-Pro-9.0.1磁盘占用分析工具感觉非常不错所以上架了，您可以实际体验！
TreeSize Professional
12-30
总是磁盘空间不足？看看是谁占的地方大。绿色软件TreeSize Professional
TreeSize工具
07-07
TreeSize 不错的工具
TreeSize 绿色版
02-19
查看硬盘被哪些文件占用了空间，TreeSize 绿色版绿色版，非常稳定
sourcetree key
09-21
sourcetree license ,sourcetree 过期只要导入这个lisence就可以解决.证书过期问题.很完美.
磁盘分析工具TreeSize.rar
09-19
磁盘分析工具。用于分析硬盘文件占用情况，便于清理。
密码学实验_对称加密算法DES_非对称加密算法RSA.pdf
02-20
本实验报告主要涉及两种加密算法：对称加密算法DES（Data Encryption Standard）和非对称加密算法RSA。实验旨在帮助学生深入理解这两种算法的基本原理，并通过Python编程实现加密和解密过程。 ### **对称加密算法...
php中简单的对称加密算法实现
12-19
在网上找到了一个不错的PHP方面的对称加密算法；在PHP的语法环境里，有urlencode与urldecode,base64_encode和base64_decode自带的对称算法，不过这些自带的算法不能称之为加密算法，只能说是编码方式而已。可是我们...
Python3非对称加密算法RSA实例详解
01-20
本文实例讲述了Python3非对称加密算法RSA。分享给大家供大家参考，具体如下： python3 可以使用 Crypto.PublicKey.RSA 和 rsa 生成公钥、私钥。 其中 python3.6 Crypto 库的安装方式请参考前面一篇《Python3对称加密...
RSA非对称加密算法
02-14
RSA非对称加密算法是由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）三位科学家在1977年提出的，这是他们在麻省理工学院共同研究的成果。RSA算法之所以重要，是...
TreeSizeFreeSetup.exe 4.3.1 硬盘空间管理工具
07-26
TreeSize Professional 4.3.1 是一个强大灵活的硬盘空间管理工具，可以帮你找出硬盘上最大的目录与它占用的空间，支持空间大小显示、分配空间与占用空间、文件数、3D工具条与分配图、最近使用数据、文件作者、NTFS压缩率等信息，并支持搜索文件。这款软件类似浏览器界面，快速多线程，可以导入导出 Excel、HTML或ASCII文件。
TreeSize硬盘空间管理器
11-22
TreeSize 是一个硬盘空间管理器，它能够显示文件大小和实际占空间数及其浪费的空间等，让你做出相应的删除决定。可以使你对你的硬盘资源占用了如指掌，这个工具相当不错。
C#实现简单的RSA非对称加密算法示例
08-29
C#实现简单的RSA非对称加密算法示例 本文主要介绍了C#实现简单的RSA非对称加密算法，结合实例形式分析了C#实现RSA加密的具体步骤与相关操作技巧。 RSA非对称加密算法是公钥密码体制中的一种，使用了一对密钥，一个...
密码学工具1——对称加密算法(AES总结最全版)
WillsonZ的博客
09-02 5850
AES 数据加密是一种在数学上更高效、更优雅的加密算法，由美国国家标准与技术研究院于 2001 年推出，用于替代DES算法。作为高级加密标准，AES提供三种密钥长度，分别是128 位、192 位和 256 位，密钥长度越高，破解系统或破解系统所需的时间就越多。ECB，电码本模式(Electronic Codebook Book Mode)CBC，密码分组链接模式(Cipher Block Chaining Mode)
信息安全领域对称加密算法详解
weixin_42736657的博客
12-05 1307
AES是目前最常用和推荐的对称加密算法，特别是在需要高强度安全性和高性能的应用中。3DES和Blowfish仍然在某些 legacy 系统中使用，但逐渐被淘汰。适用于实时加密和资源受限的环境，如 IoT 设备和移动设备。RC4由于存在安全漏洞，已经不再推荐使用。选择哪种对称加密算法取决于你的具体需求，包括安全性要求、性能考虑、平台支持等因素。
对称加密DES（ECB/CBC/CFB/OFB/CTR）
BlockchainY的博客
04-10 7791
对称加密 DES(Data Encryption Standard) DES密钥长度是56bit，从规格上来说，DES的密钥长度是64bit，但由于每隔7bit会设置一个错误检查的bit，因此实质上其密钥长度是56bit。 DES是以64bit的明文为一个单位进行加密，以64个bit进行分组，因此DES每次加密只能加密64bit的数据，当加密明文比较长，则进行迭代。所以当进行加密时对明文拆分每8个字节（64bit）一组，通过加密算法进行加密。 3DES加密 加密 -> 解密 -> 加密 可以兼
TreeSize v9crack
q2315702359的博客
06-02 3799
　　TreeSize now supports the scanning and searching of mailboxes that are included in a locally installed Microsoft Outlook. This includes IMAP as well as Microsoft Exchange and Exchange-Online mailboxes.　　SQLite has been added as a new export format for sc
中国SM系列密码算法的入门教程
最新发布
m0_71071763的博客
08-22 744
SM系列密码算法是中国国家密码管理局（简称“国密局”）制定和发布的一系列商用密码算法标准，旨在保障国家信息安全，构建自主可控的安全体系。相比RSA，在相同安全强度下，ECC所需的密钥长度更短（例如256位SM2约等于3072位RSA），计算更快，带宽占用更小。两方（A和B）可以通过交换一些信息，并结合自己的私钥和对方的公钥，协商出一个只有双方才知道的共享密钥（Session Key），用于后续的对称加密通信。SM3是一种密码学哈希函数，可将任意长度的输入消息压缩成固定长度（256位）的摘要（哈希值）。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小旺不正经

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

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

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

打赏作者

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

抵扣说明：

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

余额充值