初学密码学

最新推荐文章于 2024-08-13 20:27:31 发布
最新推荐文章于 2024-08-13 20:27:31 发布
阅读量162 收藏 1
点赞数
文章标签： 密码学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feige012/article/details/115357486
版权

初学密码学


初学密码学要学那些呢,个人分成这些
本篇文章主要是加密的代码,大家可以通过代码一点点查有什么用 

熟悉凯撒密码类似的密码加密破解
什么是对称加密,
什么是非对称加密,
什么是不可逆加密,()
信息摘要技术,
数字证书工作原理,
https,open ssl,ssl,tls协议,

对称加密

个人总结笔记：

加密秘钥 = 解密秘钥 完成对称的行为
初等
常用的对称加密			DES
                        3DES
                        ASE
                        PEB
                        IDEA
DES:数据加密标准
        秘钥长度 56,64
AES:DES的进阶
PBE(Password Based Encryption):基于口令的加密  加盐
        对已有算法的包装
        JDK,BC
        盐
        PBEWithMD5AndDES

DES

注意这个Hex是 org.apache.commons.codec.binary.Hex
可以导包

 <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
            <version>1.11</version>
        </dependency>

他有jdkDES还有bcDES，代码差距都不大
DESTest

package symmetricPackage.DES;

import org.apache.commons.codec.binary.Hex;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import java.security.Key;
import java.security.Security;

public class DESTest {
    private static String src="feige011 is back";
    public static void main(String[] args) {
//        jdkDES();
        test();
    }
    public static void jdkDES(){
//        生成KEY
        try {
            KeyGenerator keyGenerator=KeyGenerator.getInstance("DES");
            keyGenerator.init(56);
            SecretKey secretKey= keyGenerator.generateKey();
            byte[] bytesKey = secretKey.getEncoded();
            System.out.println(Hex.encodeHexString(bytesKey));
//            KEY的转换
            DESKeySpec desKeySpec=new DESKeySpec(bytesKey);
            //加密方式
            SecretKeyFactory factory=SecretKeyFactory.getInstance("DES");
            Key convertSecretKey=factory.generateSecret(desKeySpec);

            //加密  加密方式/工作方式/填充方式
            Cipher cipher=Cipher.getInstance("DES/ECB/PKCS5Padding");
            //模式+key
            cipher.init(Cipher.ENCRYPT_MODE,convertSecretKey);
            byte[] result=cipher.doFinal(src.getBytes());
            System.out.println("jdk des encrypt: "+ Hex.encodeHexString(result));
//            Key convertSecretKey=factory.generateSecret()

            //解密
            cipher.init(Cipher.DECRYPT_MODE,convertSecretKey);
            result=cipher.doFinal(result);
            System.out.println("jdk des decrypt: "+new String(result));
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
    public static void test(){
        String s="6130617661feeb1697dd4c248e59fdf6569afb639ae3dc51";
        String s2="4575dcefabfed35b";
//       =s.getBytes();

        try {
            byte[] b= Hex.decodeHex(s);
            System.out.println("jdk des encrypt: "+ Hex.encodeHexString(b));
            KeyGenerator keyGenerator=KeyGenerator.getInstance("DES");
            keyGenerator.init(56);

            byte[] bytesKey =Hex.decodeHex(s2);

//            KEY的转换
            DESKeySpec desKeySpec=new DESKeySpec(bytesKey);
            //加密方式
            SecretKeyFactory factory=SecretKeyFactory.getInstance("DES");
            Key convertSecretKey=factory.generateSecret(desKeySpec);
            Cipher cipher=Cipher.getInstance("DES/ECB/PKCS5Padding");
            cipher.init(Cipher.DECRYPT_MODE,convertSecretKey);
            byte[] result=cipher.doFinal(b);
            System.out.println("jdk des decrypt: "+new String(result));
        }catch (Exception e){
            e.printStackTrace();
        }

    }

    public static void bcDES(){
        try {
            Security.addProvider(new BouncyCastleProvider());

            KeyGenerator keyGenerator=KeyGenerator.getInstance("symmetricPackage/DES","BC");
            keyGenerator.init(56);
            SecretKey secretKey= keyGenerator.generateKey();
            byte[] bytesKey = secretKey.getEncoded();
            System.out.println(Hex.encodeHexString(bytesKey));
//            KEY的转换
            DESKeySpec desKeySpec=new DESKeySpec(bytesKey);
            //加密方式
            SecretKeyFactory factory=SecretKeyFactory.getInstance("symmetricPackage/DES");
            Key convertSecretKey=factory.generateSecret(desKeySpec);

            //加密  加密方式/工作方式/填充方式
            Cipher cipher=Cipher.getInstance("symmetricPackage/DES/ECB/PKCS5Padding");
            //模式+key
            cipher.init(Cipher.ENCRYPT_MODE,convertSecretKey);
            byte[] result=cipher.doFinal(src.getBytes());
            System.out.println("bc des encrypt: "+ Hex.encodeHexString(result));
//            Key convertSecretKey=factory.generateSecret()

            //解密
            cipher.init(Cipher.DECRYPT_MODE,convertSecretKey);
            result=cipher.doFinal(result);
            System.out.println("bc des decrypt: "+new String(result));
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

3DES

和DES差距不大,就是key转换,加密方式,填充方式内个地方有点改变

package symmetricPackage.DES;

import org.apache.commons.codec.binary.Hex;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESedeKeySpec;
import java.security.Key;
import java.security.SecureRandom;

public class DES3Test {
    private static String src="feige011 is back";
    public static void main(String[] args) {
        jdk3DES();
    }
    static public void jdk3DES(){
//        生成KEY
        try {
            KeyGenerator keyGenerator=KeyGenerator.getInstance("DESede");
//            keyGenerator.init(168);
            keyGenerator.init(new SecureRandom());
            SecretKey secretKey= keyGenerator.generateKey();
            byte[] bytesKey = secretKey.getEncoded();
            System.out.println(Hex.encodeHexString(bytesKey));
//            KEY的转换
            DESedeKeySpec desKeySpec=new DESedeKeySpec(bytesKey);
            //加密方式
            SecretKeyFactory factory=SecretKeyFactory.getInstance("DESede");
            Key convertSecretKey=factory.generateSecret(desKeySpec);

            //加密  加密方式/工作方式/填充方式
            Cipher cipher=Cipher.getInstance("DESede/ECB/PKCS5Padding");
            //模式+key
            cipher.init(Cipher.ENCRYPT_MODE,convertSecretKey);
            byte[] result=cipher.doFinal(src.getBytes());
            System.out.println("jdk des encrypt: "+ Hex.encodeHexString(result));
//            Key convertSecretKey=factory.generateSecret()

            //解密
            cipher.init(Cipher.DECRYPT_MODE,convertSecretKey);
            result=cipher.doFinal(result);
            System.out.println("jdk des decrypt: "+new String(result));
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

AES

差距也不大，就是原来DES的地方改成AES

package symmetricPackage.AES;

import org.apache.commons.codec.binary.Base64;
import org.bouncycastle.jce.provider.BouncyCastleProvider;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.Key;
import java.security.Security;


public class AESTest {
    private static String src = "feige011 is back";
    public static String myKey="QCfdszi2t2B5amt8jysutA==";
    public static void main(String[] args) {
        jdkAES();
//        bcAES();
    }


    public static void jdkAES() {
        try {
            //生成KEY
            KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
            keyGenerator.init(128);
            SecretKey secretKey=keyGenerator.generateKey();
//            byte[] keyBytes=secretKey.getEncoded();
            byte[] keyBytes=Base64.decodeBase64(myKey.getBytes());

            System.out.println("jdk aes encrypt: "+ Base64.encodeBase64String(keyBytes));
            //KEY的转换
            Key key=new SecretKeySpec(keyBytes, "AES");

            //加密
            Cipher cipher=Cipher.getInstance("AES/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE,key);
            byte[] bytes=cipher.doFinal(src.getBytes());
            System.out.println("jdk aes encrypt: "+ Base64.encodeBase64String(bytes));

            //解密
            cipher.init(Cipher.DECRYPT_MODE,key);
            bytes=cipher.doFinal(bytes);
            System.out.println("jdk aes desrypt: "+new String(bytes));
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public  static void bcAES(){
        try {
            Security.addProvider(new BouncyCastleProvider());
            //生成KEY
            KeyGenerator keyGenerator = KeyGenerator.getInstance("symmetricPackage/AES","BC");
            keyGenerator.init(128);
            SecretKey secretKey=keyGenerator.generateKey();
            byte[] keyBytes=secretKey.getEncoded();

            //KEY的转换
            Key key=new SecretKeySpec(keyBytes, "symmetricPackage/AES");

            //加密
            Cipher cipher=Cipher.getInstance("symmetricPackage/AES/ECB/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE,key);
            byte[] bytes=cipher.doFinal(src.getBytes());
            System.out.println("jdk aes encrypt: "+ Base64.encodeBase64String(bytes));

            //解密
            cipher.init(Cipher.DECRYPT_MODE,key);
            bytes=cipher.doFinal(bytes);
            System.out.println("jdk aes desrypt: "+new String(bytes));
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

非对称加密

高级
双保险
公钥,私钥
DH()秘钥交换算法
RSA-基于因子分解
ELGamal--基于离散对数
ECC-椭圆曲线加密

DH:
        初始化发送方密钥
                KeyPairGenerator//声称keyPair实例
                KeyPair //能够得到公钥和私钥
                PublicKey //公钥
        初始化接收方密钥
                KeyFactory //声成密钥(还原密钥)
                X509EncodedKeySpec //根据ASN.1标准进行编码
                DHPublicKey
                DHParameterSpec         //在DH算法中参数集合
                KeyPairGenerator
                PrivateKey
        密钥构建
                KeyAgreement            //提供密钥协定协议的功能
                SecretKey               //秘密密钥,存在目的声成分组密钥
                KeyFactory
                X509EncodedKeySpec
                PublicKey
        加密,解密:
                Cipher          //核心内容

DH

package AsymmetricPackage;

import org.apache.commons.codec.binary.Base64;

import javax.crypto.Cipher;
import javax.crypto.KeyAgreement;
import javax.crypto.SecretKey;
import javax.crypto.interfaces.DHPublicKey;
import javax.crypto.spec.DHParameterSpec;
import java.security.*;
import java.security.spec.X509EncodedKeySpec;
import java.util.Objects;

public class DHTest {
    private static String src="feige011 is good";
    public static void main(String[] args) {
        jdkDH();
    }
    public static void jdkDH(){

        try {
            System.getProperties().setProperty("jdk.crypto.KeyAgreement.legacyKDF", "true");
            //1.初始化发送发密钥
            KeyPairGenerator senderKeyPairGenerator=KeyPairGenerator.getInstance("DH");
            senderKeyPairGenerator.initialize(512);
            KeyPair senderKeyPair=senderKeyPairGenerator.generateKeyPair();
            //发送方公钥,需要发送给接受方
            byte[] senderPublicKeyEnc=senderKeyPair.getPublic().getEncoded();
            //2.初始化接收方密钥
            KeyFactory receiverKeyFactory=KeyFactory.getInstance("DH");
            X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec(senderPublicKeyEnc);

            PublicKey receiverPublicKey=receiverKeyFactory.generatePublic(x509EncodedKeySpec);
            DHParameterSpec dhParameterSpec=((DHPublicKey)receiverPublicKey).getParams();
            KeyPairGenerator receiverKeyPairGenerator=KeyPairGenerator.getInstance("DH");
            receiverKeyPairGenerator.initialize(dhParameterSpec);
            KeyPair receiverKeypair=receiverKeyPairGenerator.generateKeyPair();
            PrivateKey receiverPrivateKey=receiverKeypair.getPrivate();
            byte[] receiverPublicKeyEnc=receiverKeypair.getPublic().getEncoded();
            //3.密钥构建
            KeyAgreement receiverKeyAgreement=KeyAgreement.getInstance("DH");
            receiverKeyAgreement.init(receiverPrivateKey);
            receiverKeyAgreement.doPhase(receiverPublicKey,true);
            SecretKey receiverDesKey=receiverKeyAgreement.generateSecret("DES");

            KeyFactory senderKeyFactory= KeyFactory.getInstance("DH");
            x509EncodedKeySpec=new X509EncodedKeySpec(receiverPublicKeyEnc);
            PublicKey senderPublicKey=senderKeyFactory.generatePublic(x509EncodedKeySpec);
            KeyAgreement senderKeyAgreement=KeyAgreement.getInstance("DH");
            senderKeyAgreement.init(senderKeyPair.getPrivate());
            senderKeyAgreement.doPhase(senderPublicKey,true);

            SecretKey senderDesKey=senderKeyAgreement.generateSecret("DES");
            if(Objects.equals(receiverDesKey,senderDesKey)){
                System.out.println("双方密钥相同");
            }

            //4,加密
            Cipher cipher=Cipher.getInstance("DES");
            cipher.init(Cipher.ENCRYPT_MODE,senderDesKey);
            byte[] result=cipher.doFinal(src.getBytes());

            System.out.println("jdk dh eccrypt: "+Base64.encodeBase64String(result));

            //5.解密
            cipher.init(Cipher.DECRYPT_MODE,receiverDesKey);
            result=cipher.doFinal(result);
            System.out.println("jdk dh decrypt: "+new String(result));



        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

不可逆加密

不可逆加密经典就是md5加密

md5

package InformationSummary;



import org.apache.commons.codec.binary.Hex;
import org.apache.commons.codec.digest.DigestUtils;
import org.bouncycastle.crypto.Digest;
import org.bouncycastle.crypto.digests.MD4Digest;
import org.bouncycastle.crypto.digests.MD5Digest;
import org.bouncycastle.jce.provider.BouncyCastleProvider;


import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.Security;

public class MDTest  {
    private static String src="feige011 is back";
    public static void main(String[] args) {
        jdkMD5();
        jdkMD2();
        bcMD4();
        bcMD5();
        ccMD5();
        ccMD2();
    }
    public static void jdkMD5(){
        try {

            MessageDigest md=MessageDigest.getInstance("MD5");
            byte[] md5Bytes=md.digest(src.getBytes());
            System.out.println("JDK MD5: "+ Hex.encodeHexString(md5Bytes));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static void jdkMD2(){
        try {
            MessageDigest md=MessageDigest.getInstance("MD2");
            byte[] md5Bytes=md.digest(src.getBytes());
            System.out.println("JDK MD2: "+ Hex.encodeHexString(md5Bytes));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void bcMD5(){
        Digest digest=new MD5Digest();
        digest.update(src.getBytes(),0,src.getBytes().length);
        byte[] md5Bytes=new byte[digest.getDigestSize()];
        digest.doFinal(md5Bytes,0);
        System.out.println("BC MD4: "+org.bouncycastle.util.encoders.Hex.toHexString(md5Bytes));

    }

    public static void bcMD4(){

        try {
            Security.addProvider(new BouncyCastleProvider());
            MessageDigest md=MessageDigest.getInstance("MD4");
            byte[] md4Bytes=md.digest(src.getBytes());
            System.out.println("BC MD4: "+ Hex.encodeHexString(md4Bytes));

        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }

//        Digest digest=new MD4Digest();
//        digest.update(src.getBytes(),0,src.getBytes().length);
//        byte[] md4Bytes=new byte[digest.getDigestSize()];
//        digest.doFinal(md4Bytes,0);
//        System.out.println("BC MD4: "+org.bouncycastle.util.encoders.Hex.toHexString(md4Bytes));
    }


    public static void ccMD5(){

        System.out.println("ccMD5:" +DigestUtils.md5Hex(src.getBytes()));
    }
    public static void ccMD2(){

        System.out.println("ccMD2:" +DigestUtils.md2Hex(src.getBytes()));
    }
}

数字证书

证明你的公钥属于你,
发证机构
所有人
公钥:   有效期
数字签名:
作用:
        数字签名
        HTTPS
        认证所有人和公钥关系
        避免中间人攻击
        基于第三方的信任


https原理
        安全的http
        ssl证书,用在https下的证书.
王飞宇F
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
初识密码学
Kity_Xu的博客
01-04 355
信息安全 信息安全的三要素 信息安全中需要解决的三个问题： 保密性（Confidentiality）：信息在传输是不被泄露 完整性（Integrity）：信息在传输时不被篡改伪造 有效性（Availability）：信息的来源是合法可信的 这三点统称CIA Triad 公钥密码解决保密性问题，数字签名解决完整性和有效性问题 密码学 1. 对称加密 采用单个秘钥对明文进行加密的方法，同时该秘钥...
密码学基础(初学者)
JasonCian的博客
05-10 431
凯撒加密、base加密、栅栏密码
aes ios 安卓 java_AES加密解密,iOS,Android,Java,.Net通用
weixin_30146085的博客
02-25 133
【实例简介】说明博客：http://www.cnblogs.com/jys509/p/4768120.html本工程可以直接使用，而且与IOS，Android，JAVA,.NET 已调通。主要用于客户端进行通信，数据之间地安全性。对数据进行加密和解密AES加密有多种算法模式，下面提供两套模式的可用源码:一、CBC(Cipher Block Chaining，加密块链)模式二、ECB(Electro...
密码学入门
热门推荐
wjheha的博客
06-24 5万+
密码学入门研究生的第一年就要过完了。有幸在号称中国密码学界的“黄埔军校”学习密码，得以见识老一辈和新一辈密码学大师的风采。虽然学的不好，但感觉也有所收获，主要是自己的基础知识太缺乏了，觉得有必要写一篇建议性的文章，给那些希望从事密码学研究的师弟师妹们一个参考。
如何学好密码学
yangrundong12的博客
07-11 7701
作为一名研究生，学习密码学已经一年有余，这一段学习时间让我感慨颇多，想通过一篇文章跟大家分享自己学习过程中的一点心得和教训，希望对对大家有帮助。 （一）初识密码学 我的本科学习的是通信工程，在进入研究生之前我对密码概念大多来之一些抗战神剧、谍战片、以及对黑客的一些认知。一段很奇妙的缘分让我转投到密码学的怀抱。研究生学校是一所不太好的学校，搞密码的...
Python 密码学编程
05-08
Python是一种高级程序设计语言，因其简洁、易读及可扩展性日渐成为程序设计领域备受推崇的语言。同时，Python语言在算法领域也得到了很好的应用。...本书适合Python初学者和密码学的初学者，也适合信息安全从业人员。
应用密码学：协议、算法与C源程序_.rar_应用密码学
07-14
总的来说，《应用密码学：协议、算法与C源程序》是一本全面而深入的密码学教程，适合对信息安全感兴趣的初学者和专业人士阅读。通过学习本书，读者不仅能够掌握密码学的基本理论，还能提升实际操作能力，为从事相关...
rsa.rar_密码学
09-24
RSA（Rivest-Shamir-Adleman）是一种非对称加密算法，由Ron Rivest、Adi Shamir和Leonard Adleman在1977年提出，是现代密码学的基石之一。该算法基于大整数因子分解的困难性，为数据传输和网络安全提供了强大的安全...
【密码学】密钥管理：②密钥分配
qq_39780701的博客
08-12 955
密钥分配的定义、密钥分配的方法。利用双钥体制建立安全信道传递来实现密钥分配。密码分配的基本模式主要有：点对点密钥分配、密钥分配中心、密钥传递中心三种。
Pairing-Based Cryptography
chengbin20101的博客
08-13 487
Pairing-Based Cryptography（配对密码学）是一种基于双线性配对（bilinear pairing）的密码学方法，它在密码协议和安全服务中具有广泛的应用。
【密码学】网络攻击类型：拒绝服务DoS攻击和中间人MITM攻击
qq_39780701的博客
08-07 1132
网络攻击类型非常多，本文先介绍两个常见的攻击：DoS和MITM。我试着从攻击的定义、攻击原理和举例说明等多角度来将他们讲清楚。
非对称加密算法-ECDHE
z3551906947的博客
08-12 975
密钥交换算法是现代加密通信的基础。它允许两个通信方在不安全的通道上安全地建立一个共享的密钥，而无需事先共享任何秘密信息。这个共享密钥随后可以用于加密和解密双方的通信，确保数据的机密性和完整性。离散对数是一个数论问题，它在密码学中非常重要。具体来说，如果我们有一个整数bb、一个整数gg（通常称为基或生成元），以及一个整数yy，那么离散对数问题就是找到一个整数xx，使得： gx≡y(modp)gx≡y(modp) 这里的pp是一个大素数，而≡≡表示同余。
【密码学】密钥管理：③密钥的保护、存储、备份、撤销、过期、销毁
qq_39780701的博客
08-12 282
本文介绍了密钥的分级保护、存储、备份、撤销、过期和销毁在密钥管理中的概念是什么？如何实现的。
信息技术教师技能大赛基础知识与专业技能试卷.doc
08-16
信息技术教师技能大赛基础知识与专业技能试卷.doc
基于ssm的新生报到系统(有报告) Javaee项目，ssm项目
最新发布
08-16
资源详情：https://blog.csdn.net/2302_78191516/article/details/141269772
奥柯玛DC16A电磁炉原理图.rar
08-16
奥柯玛DC16A电磁炉原理图
麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包
08-16
麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包
椭圆曲线密码学基础指南
《椭圆曲线密码学引论》一书由Darrel Hankerson、Alfred Menezes和Scott Vanstone合著，详细介绍了ECC的基本原理、算法实现和安全性分析，适合初学者和爱好者学习。书中包含38幅插图，帮助读者更好地理解抽象的数学...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值