文章目录
- Pre
- 概述
-
* 什么是非对称加密算法？- 如何工作？
- 示例：RSA算法
- 特点和优势
- ECC：另一种非对称加密算法
- Code
-
* 生成公钥和私钥- 私钥加密
- 私钥加密私钥解密 ( 行不通 )
- 私钥加密公钥解密
- 公钥加密和公钥解密 （行不通）
- 保存公钥和私钥
- 读取私钥
- 读取公钥
- 使用读取的公钥加密，私钥解密
- Source
Pre
概述
在数字化时代，网络通信的安全性是必须关注的重要问题之一。非对称加密算法作为现代密码学的重要组成部分，为保护通信的隐私提供了一种可靠的解决方案。
什么是非对称加密算法？
非对称加密算法，又称为公钥加密算法，是一种密码学中的重要概念。它与传统的对称加密算法不同，需要一对密钥：公钥和私钥。这对密钥之间存在着特殊的数学关系，但无法通过公钥推导出私钥，从而保证了通信的安全性。
如何工作？
当发送方A希望将数据发送给接收方B时，A可以使用B的公钥对数据进行加密，得到密文。只有拥有对应私钥的B才能解密这个密文。同样地，B也可以使用A的公钥加密数据，只有A持有私钥才能解密。这种加密和解密使用不同的密钥的特点，使得非对称加密算法成为了保护通信隐私的重要工具。
示例：RSA算法
RSA算法是非对称加密算法中最常见的一种，它利用了大数分解的数学难题，保证了通信的安全性。在RSA算法中，公钥是公开的，私钥是保密的。发送方使用接收方的公钥对数据进行加密，而接收方使用自己的私钥进行解密，从而实现了安全的通信。
特点和优势
- 加密和解密使用不同的密钥，提高了通信的安全性。
- 如果使用私钥加密，只能使用公钥解密；反之亦然。
- 非对称加密算法安全性高，但处理数据速度较慢。
ECC：另一种非对称加密算法
除了RSA算法，还有一种备受关注的非对称加密算法，即椭圆曲线密码学（ECC）。ECC利用了椭圆曲线上的数学难题，相比RSA算法，它能够以更短的密钥长度实现相当于甚至更高的安全级别，同时在资源受限的环境下拥有更好的性能表现。
Code
生成公钥和私钥
package com.artisan;
import com.sun.org.apache.xml.internal.security.utils.Base64;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
/**
* @author 小工匠
* @version 1.0
*/
public class RsaKeyPair {
public static void main(String[] args) throws Exception {
// 指定加密算法为RSA
String algorithm = "RSA";
// 创建密钥对生成器对象
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// 生成RSA密钥对
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// 获取生成的私钥
PrivateKey privateKey = keyPair.getPrivate();
// 获取生成的公钥
PublicKey publicKey = keyPair.getPublic();
// 获取私钥的编码字节数组
byte[] privateKeyEncoded = privateKey.getEncoded();
// 获取公钥的编码字节数组
byte[] publicKeyEncoded = publicKey.getEncoded();
// 对公私钥的编码字节数组进行Base64编码
String privateKeyString = Base64.encode(privateKeyEncoded);
String publicKeyString = Base64.encode(publicKeyEncoded);
// 打印私钥的Base64编码字符串
System.out.println(privateKeyString);
System.out.println("----------------------------------");
// 打印公钥的Base64编码字符串
System.out.println(publicKeyString);
}
}
使用RSA算法生成一个密钥对，并将私钥和公钥进行Base64编码后打印出来了。
私钥加密
package com.artisan;
import com.sun.org.apache.xml.internal.security.utils.Base64;
import javax.crypto.Cipher;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
/**
* @author 小工匠
* @version 1.0
* @mark: 显示代码，改变世界
*/
public class PrivateKeyEnc {
public static void main(String[] args) throws Exception {
String input = "小工匠的IT生活";
// 指定加密算法为RSA
String algorithm = "RSA";
// 创建密钥对生成器对象
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// 生成RSA密钥对
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// 获取生成的私钥
PrivateKey privateKey = keyPair.getPrivate();
// 获取生成的公钥
PublicKey publicKey = keyPair.getPublic();
// 获取私钥的编码字节数组
byte[] privateKeyEncoded = privateKey.getEncoded();
// 获取公钥的编码字节数组
byte[] publicKeyEncoded = publicKey.getEncoded();
// 对公私钥的编码字节数组进行Base64编码
String privateKeyString = Base64.encode(privateKeyEncoded);
String publicKeyString = Base64.encode(publicKeyEncoded);
// 打印生成的密钥对
System.out.println("私钥(Base64编码): " + privateKeyString);
System.out.println("公钥(Base64编码): " + publicKeyString);
// 创建加密对象，参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 初始化加密对象
// 第一个参数：加密模式
// 第二个参数：使用私钥进行加密
cipher.init(Cipher.ENCRYPT_MODE, privateKey);
// 使用私钥加密输入的字符串
byte[] encryptedBytes = cipher.doFinal(input.getBytes());
// 对加密后的字节数组进行Base64编码，并打印
System.out.println("加密后的字符串(Base64编码): " + Base64.encode(encryptedBytes));
}
}
私钥加密私钥解密 ( 行不通 )
在上面的代码上追加
// 私钥进行解密 (错误的演示)
cipher.init(Cipher.DECRYPT_MODE,privateKey);
// 对密文进行解密，不需要使用base64，因为原文不会乱码
byte[] bytes1 = cipher.doFinal(encryptedBytes);
System.out.println(new String(bytes1));
私钥加密公钥解密
将上述代码的 私钥解密，换成使用公钥解密
// 公钥进行解密
cipher.init(Cipher.DECRYPT_MODE,publicKey);
// 对密文进行解密，不需要使用base64，因为原文不会乱码
byte[] bytes1 = cipher.doFinal(encryptedBytes);
System.out.println("解密后的字符串: " + new String(bytes1));
公钥加密和公钥解密 （行不通）
保存公钥和私钥
生成RSA非对称加密算法的密钥对，并将生成的公钥和私钥保存在本地文件中。
package com.artisan;
import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.nio.charset.Charset;
import java.security.*;
public class KeyPairOperate {
public static void main(String[] args) throws Exception {
// 加密算法
String algorithm = "RSA";
// 生成密钥对并保存在本地文件中
generateKeyToFile(algorithm, "a.pub", "a.pri");
}
/**
* 生成密钥对并保存在本地文件中
*
* @param algorithm : 算法
* @param pubPath : 公钥保存路径
* @param priPath : 私钥保存路径
* @throws Exception
*/
private static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
// 获取密钥对生成器
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// 获取密钥对
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// 获取公钥
PublicKey publicKey = keyPair.getPublic();
// 获取私钥
PrivateKey privateKey = keyPair.getPrivate();
// 获取byte数组
byte[] publicKeyEncoded = publicKey.getEncoded();
byte[] privateKeyEncoded = privateKey.getEncoded();
// 进行Base64编码
String publicKeyString = Base64.encode(publicKeyEncoded);
String privateKeyString = Base64.encode(privateKeyEncoded);
// 保存文件
FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName("UTF-8"));
FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName("UTF-8"));
}
}
读取私钥
// 读取私钥
PrivateKey privateKey = readPrivateKeyFromFile(algorithm, "a.pri");
byte[] encoded = privateKey.getEncoded();
String privateContent = Base64.encode(encoded);
System.out.println("私钥内容:" + privateContent);
/**
* @param algorithm
* @param filePath
* @return
* @throws Exception
*/
private static PrivateKey readPrivateKeyFromFile(String algorithm, String filePath) throws Exception {
// 从文件中读取私钥字符串
String privateKeyString = FileUtils.readFileToString(new File(filePath), StandardCharsets.UTF_8);
// 进行Base64解码
byte[] privateKeyEncoded = Base64.decode(privateKeyString);
// 获取密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
// 构建密钥规范 进行Base64解码
PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.decode(privateKeyString));
return keyFactory.generatePrivate(spec);
}
看下生成的文件中的内容：
读取公钥
// 读取公钥
PublicKey publicKey = readPublicKeyFromFile(algorithm, "a.pub");
byte[] publicKeyEncoded = publicKey.getEncoded();
String publicContent = Base64.encode(publicKeyEncoded);
System.out.println("公钥内容:" + publicContent);
/**
* @param algorithm
* @param filePath
* @return
* @throws Exception
*/
private static PublicKey readPublicKeyFromFile(String algorithm, String filePath) throws Exception {
// 将文件内容转为字符串
String publicKeyString = FileUtils.readFileToString(new File(filePath), StandardCharsets.UTF_8);
// 获取密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
// 构建密钥规范 进行Base64解码
X509EncodedKeySpec spec = new X509EncodedKeySpec(Base64.decode(publicKeyString));
// 生成公钥
return keyFactory.generatePublic(spec);
}
使用读取的公钥加密，私钥解密
// 使用公钥私钥实现加解密
String text = "小工匠的IT生活";
System.out.println("原文:" + text);
String enc = encryptRSA(algorithm, publicKey, text);
System.out.println("公钥加密后的数据:" + enc);
String plainText = decryptRSA(algorithm, privateKey, enc);
System.out.println("私钥解密后的数据:" + plainText);
/**
* 解密数据
*
* @param algorithm : 算法
* @param encrypted : 密文
* @param key : 密钥
* @return : 原文
* @throws Exception
*/
public static String decryptRSA(String algorithm, Key key, String encrypted) throws Exception {
// 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 私钥进行解密
cipher.init(Cipher.DECRYPT_MODE, key);
// 由于密文进行了Base64编码, 在这里需要进行解码
byte[] decode = Base64.decode(encrypted);
// 对密文进行解密，不需要使用base64，因为原文不会乱码
byte[] bytes1 = cipher.doFinal(decode);
return new String(bytes1);
}
/**
* 使用密钥加密数据
*
* @param algorithm : 算法
* @param input : 原文
* @param key : 密钥
* @return : 密文
* @throws Exception
*/
public static String encryptRSA(String algorithm, Key key, String input) throws Exception {
// 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 初始化加密
// 第一个参数:加密的模式
// 第二个参数：使用私钥进行加密
cipher.init(Cipher.ENCRYPT_MODE, key);
// 私钥加密
byte[] bytes = cipher.doFinal(input.getBytes());
// 对密文进行Base64编码
return Base64.encode(bytes);
}
Source
package com.artisan;
import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils;
import javax.crypto.Cipher;
import java.io.File;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
/**
* @author 小工匠
* @version 1.0
* @mark: show me the code , change the world
*/
public class KeyPairOperate {
public static void main(String[] args) throws Exception {
// 加密算法
String algorithm = "RSA";
// 生成密钥对并保存在本地文件中
generateKeyToFile(algorithm, "a.pub", "a.pri");
// 读取私钥
PrivateKey privateKey = readPrivateKeyFromFile(algorithm, "a.pri");
byte[] encoded = privateKey.getEncoded();
String privateContent = Base64.encode(encoded);
System.out.println("私钥内容:" + privateContent);
// 读取公钥
PublicKey publicKey = readPublicKeyFromFile(algorithm, "a.pub");
byte[] publicKeyEncoded = publicKey.getEncoded();
String publicContent = Base64.encode(publicKeyEncoded);
System.out.println("公钥内容:" + publicContent);
// 使用公钥私钥实现加解密
String text = "小工匠的IT生活";
System.out.println("原文:" + text);
String enc = encryptRSA(algorithm, publicKey, text);
System.out.println("公钥加密后的数据:" + enc);
String plainText = decryptRSA(algorithm, privateKey, enc);
System.out.println("私钥解密后的数据:" + plainText);
}
/**
* 解密数据
*
* @param algorithm : 算法
* @param encrypted : 密文
* @param key : 密钥
* @return : 原文
* @throws Exception
*/
public static String decryptRSA(String algorithm, Key key, String encrypted) throws Exception {
// 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 私钥进行解密
cipher.init(Cipher.DECRYPT_MODE, key);
// 由于密文进行了Base64编码, 在这里需要进行解码
byte[] decode = Base64.decode(encrypted);
// 对密文进行解密，不需要使用base64，因为原文不会乱码
byte[] bytes1 = cipher.doFinal(decode);
return new String(bytes1);
}
/**
* 使用密钥加密数据
*
* @param algorithm : 算法
* @param input : 原文
* @param key : 密钥
* @return : 密文
* @throws Exception
*/
public static String encryptRSA(String algorithm, Key key, String input) throws Exception {
// 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 初始化加密
// 第一个参数:加密的模式
// 第二个参数：使用私钥进行加密
cipher.init(Cipher.ENCRYPT_MODE, key);
// 私钥加密
byte[] bytes = cipher.doFinal(input.getBytes());
// 对密文进行Base64编码
return Base64.encode(bytes);
}
/**
* @param algorithm
* @param filePath
* @return
* @throws Exception
*/
private static PublicKey readPublicKeyFromFile(String algorithm, String filePath) throws Exception {
// 将文件内容转为字符串
String publicKeyString = FileUtils.readFileToString(new File(filePath), StandardCharsets.UTF_8);
// 获取密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
// 构建密钥规范 进行Base64解码
X509EncodedKeySpec spec = new X509EncodedKeySpec(Base64.decode(publicKeyString));
// 生成公钥
return keyFactory.generatePublic(spec);
}
/**
* @param algorithm
* @param filePath
* @return
* @throws Exception
*/
private static PrivateKey readPrivateKeyFromFile(String algorithm, String filePath) throws Exception {
// 从文件中读取私钥字符串
String privateKeyString = FileUtils.readFileToString(new File(filePath), StandardCharsets.UTF_8);
// 进行Base64解码
byte[] privateKeyEncoded = Base64.decode(privateKeyString);
// 获取密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
// 构建密钥规范 进行Base64解码
PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.decode(privateKeyString));
return keyFactory.generatePrivate(spec);
}
/**
* 生成密钥对并保存在本地文件中
*
* @param algorithm : 算法
* @param pubPath : 公钥保存路径
* @param priPath : 私钥保存路径
* @throws Exception
*/
private static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
// 获取密钥对生成器
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
// 获取密钥对
KeyPair keyPair = keyPairGenerator.generateKeyPair();
// 获取公钥
PublicKey publicKey = keyPair.getPublic();
// 获取私钥
PrivateKey privateKey = keyPair.getPrivate();
// 获取byte数组
byte[] publicKeyEncoded = publicKey.getEncoded();
byte[] privateKeyEncoded = privateKey.getEncoded();
// 进行Base64编码
String publicKeyString = Base64.encode(publicKeyEncoded);
String privateKeyString = Base64.encode(privateKeyEncoded);
// 保存文件
FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName("UTF-8"));
FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName("UTF-8"));
}
}
接下来我将给各位同学划分一张学习计划表！
学习计划
那么问题又来了，作为萌新小白，我应该先学什么，再学什么？
既然你都问的这么直白了，我就告诉你，零基础应该从什么开始学起：
阶段一：初级网络安全工程师
接下来我将给大家安排一个为期1个月的网络安全初级计划，当你学完后，你基本可以从事一份网络安全相关的工作，比如渗透测试、Web渗透、安全服务、安全分析等岗位；其中，如果你等保模块学的好，还可以从事等保工程师。
综合薪资区间6k~15k
1、网络安全理论知识（2天）
①了解行业相关背景，前景，确定发展方向。
②学习网络安全相关法律法规。
③网络安全运营的概念。
④等保简介、等保规定、流程和规范。（非常重要）
2、渗透测试基础（1周）
①渗透测试的流程、分类、标准
②信息收集技术：主动/被动信息搜集、Nmap工具、Google Hacking
③漏洞扫描、漏洞利用、原理，利用方法、工具（MSF）、绕过IDS和反病毒侦察
④主机攻防演练：MS17-010、MS08-067、MS10-046、MS12-20等
3、操作系统基础（1周）
①Windows系统常见功能和命令
②Kali Linux系统常见功能和命令
③操作系统安全（系统入侵排查/系统加固基础）
4、计算机网络基础（1周）
①计算机网络基础、协议和架构
②网络通信原理、OSI模型、数据转发流程
③常见协议解析（HTTP、TCP/IP、ARP等）
④网络攻击技术与网络安全防御技术
⑤Web漏洞原理与防御：主动/被动攻击、DDOS攻击、CVE漏洞复现
5、数据库基础操作（2天）
①数据库基础
②SQL语言基础
③数据库安全加固
6、Web渗透（1周）
①HTML、CSS和JavaScript简介
②OWASP Top10
③Web漏洞扫描工具
④Web渗透工具：Nmap、BurpSuite、SQLMap、其他（菜刀、漏扫等）
那么，到此为止，已经耗时1个月左右。你已经成功成为了一名“脚本小子”。那么你还想接着往下探索吗？
阶段二：中级or高级网络安全工程师（看自己能力）
综合薪资区间15k~30k
7、脚本编程学习（4周）
在网络安全领域。是否具备编程能力是“脚本小子”和真正网络安全工程师的本质区别。在实际的渗透测试过程中，面对复杂多变的网络环境，当常用工具不能满足实际需求的时候，往往需要对现有工具进行扩展，或者编写符合我们要求的工具、自动化脚本，这个时候就需要具备一定的编程能力。在分秒必争的CTF竞赛中，想要高效地使用自制的脚本工具来实现各种目的，更是需要拥有编程能力。
零基础入门的同学，我建议选择脚本语言Python/PHP/Go/Java中的一种，对常用库进行编程学习
搭建开发环境和选择IDE，PHP环境推荐Wamp和XAMPP，IDE强烈推荐Sublime；
Python编程学习，学习内容包含：语法、正则、文件、 网络、多线程等常用库，推荐《Python核心编程》，没必要看完
用Python编写漏洞的exp,然后写一个简单的网络爬虫
PHP基本语法学习并书写一个简单的博客系统
熟悉MVC架构，并试着学习一个PHP框架或者Python框架 (可选)
了解Bootstrap的布局或者CSS。
阶段三：顶级网络安全工程师
如果你对网络安全入门感兴趣，那么你需要的话可以点击这里👉网络安全重磅福利：入门&进阶全套282G学习资源包免费分享！
学习资料分享
当然，只给予计划不给予学习资料的行为无异于耍流氓，这里给大家整理了一份【282G】的网络安全工程师从入门到精通的学习资料包，可点击下方二维码链接领取哦。
3442
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
