信息计算2019级1班1号原野

1班1号原野 · 发表于 2022-5-30 23:13:55

ECC椭圆曲线加密

1.简介：ECC 是 Elliptic Curves Cryptography 的缩写，属于公开密钥算法,意为椭圆曲线编码编码学。ECC的主要优势是在某些情况下它比其他的方法使用更小的密钥——比如RSA加密算法——提供相当的或更高等级的安全,可以用较少的计算能力提供比RSA加密算法更高的安全强度，有效地解决了“提高安全强度必须增加密钥长度”的工程实现问题。ECC的另一个优势是可以定义群之间的双线性映射，基于Weil对或是Tate对；双线性映射已经在密码学中发现了大量的应用，例如基于身份的加密。不过一个缺点是加密和解密操作的实现比其他机制花费的时间长。

2.原理：椭圆曲线 K=kG，其中K,G为Ep（a,b）上的点，k为小于n的整数，n是点G的阶，设K为公钥，k为私钥，G为基点。
加密过程： A选定一条椭圆曲线Ep（a,b），并取曲线上一点作为基点G ；A选择一个私钥k，并生成公钥K=kG ，A将Ep（a,b）和k，G发送给B，B收到后将明文编码到Ep（a,b）上一点M，并产生一个随机数r ；B计算点C1=M+rK，C2=rG ；B将C1，C2传给A ；A计算C1-kC2=M+rkG-krG=M ；A对M解码得到明文；攻击者只能得到Ep（a,b），G，K，C1，C2，没有k就无法得到M。
3.代码：

package tttt;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Security;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import javax.crypto.Cipher;
import org.bouncycastle.jce.interfaces.ECPrivateKey;
import org.bouncycastle.jce.interfaces.ECPublicKey;
import org.springframework.util.Base64Utils;
public class test {
static {
Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
}
//生成秘钥对
public static KeyPair getKeyPair() throws Exception {
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("EC", "BC");
keyPairGenerator.initialize(256, new SecureRandom());
KeyPair keyPair = keyPairGenerator.generateKeyPair();
return keyPair;
}
//获取公钥(Base64编码)
public static String getPublicKey(KeyPair keyPair){
ECPublicKey publicKey = (ECPublicKey) keyPair.getPublic();
byte[] bytes = publicKey.getEncoded();
return Base64Utils.encodeToString(bytes);
}
//获取私钥(Base64编码)
public static String getPrivateKey(KeyPair keyPair){
ECPrivateKey privateKey = (ECPrivateKey) keyPair.getPrivate();
byte[] bytes = privateKey.getEncoded();
return Base64Utils.encodeToString(bytes);
}
//将Base64编码后的公钥转换成PublicKey对象
public static ECPublicKey string2PublicKey(String pubStr) throws Exception{
byte[] keyBytes = Base64Utils.decodeFromString(pubStr);
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("EC", "BC");
ECPublicKey publicKey = (ECPublicKey) keyFactory.generatePublic(keySpec);
return publicKey;
}
//将Base64编码后的私钥转换成PrivateKey对象
public static ECPrivateKey string2PrivateKey(String priStr) throws Exception{
byte[] keyBytes = Base64Utils.decodeFromString(priStr);
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("EC", "BC");
ECPrivateKey privateKey = (ECPrivateKey) keyFactory.generatePrivate(keySpec);
return privateKey;
}
//公钥加密
public static byte[] publicEncrypt(byte[] content, PublicKey publicKey) throws Exception{
Cipher cipher = Cipher.getInstance("ECIES", "BC");
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
byte[] bytes = cipher.doFinal(content);
return bytes;
}
//私钥解密
public static byte[] privateDecrypt(byte[] content, PrivateKey privateKey) throws Exception{
Cipher cipher = Cipher.getInstance("ECIES", "BC");
cipher.init(Cipher.DECRYPT_MODE, privateKey);
byte[] bytes = cipher.doFinal(content);
return bytes;
}
public static void main(String[] args) throws Exception {
KeyPair keyPair = test.getKeyPair();
String publicKeyStr = test.getPublicKey(keyPair);
String privateKeyStr = test.getPrivateKey(keyPair);
System.out.println("ECC公钥Base64编码:" + publicKeyStr);
System.out.println("ECC私钥Base64编码:" + privateKeyStr);
ECPublicKey publicKey = string2PublicKey(publicKeyStr);
ECPrivateKey privateKey = string2PrivateKey(privateKeyStr);
byte[] publicEncrypt = publicEncrypt("Hello World!".getBytes(), publicKey);
String encodeToString = Base64Utils.encodeToString(publicEncrypt);
System.out.println(encodeToString);
byte[] privateDecrypt = privateDecrypt(publicEncrypt, privateKey);
System.out.println(new String(privateDecrypt));
}
}

复制代码

1班1号原野 · 发表于 2022-5-31 09:49:27

本帖最后由 1班1号原野于 2022-5-31 09:55 编辑

RSA加密算法

1.介绍：RSA算法是非对称加密算法，这种算法非常可靠，密钥越长，它就越难破解（本质上是对大数的质因数分解很难），非对称加密是通过两个密钥（公钥-私钥）来实现对数据的加密和解密的。公钥用于加密，私钥用于解密。
2.原理：
（1）公钥与密钥的产生：假设A想接收B的讯息，先产生公钥和一个私钥：获取N: 随意选择两个大的质数p和q，p不等于q，计算N=pq；获取r: 根据欧拉函数r = φ(N) = φ§φ(q) = (p-1)(q-1)；选择一个小于 r 的整数 e，求得 e 关于模 r 的模反元素，命名为d。（模反元素存在，当且仅当e与r互质，即求 e^(φ®-1) ）。(N,e)是公钥，(N,d)是私钥。A将她的公钥(N,e)传给B，私钥(N,d)自己保存。
（2）加密消息：假设B想给A送一个消息，他知道A产生的公钥（N，e）。于是B先将消息转换为一个小于N的整数m。（如果是字符串可以取ascii值或unicode值；假如信息非常长，可以将分为几段，然后将每一段转换为m）他可以将m加密为c：m^e ≡ c (mod N)，B算出c后就可以将它传递给A。
（3）解密消息：A得到B的消息c后就可以利用她的密钥（N, d）来解码。将c转换为m：c^d ≡ m (mod N)；得到m后，她就可以将原来的信息重新复原。
3.优缺点：
优点：1.不需要进行密钥传递，提高了安全性 2.可以进行数字签名认证。缺点：1.加密解密效率不高，一般只适用于处理小量数据（如：密钥）2.容易遭受小指数攻击
4.代码：
（1）test类

package tttt;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
public class test {
/**
* @param args
*/
private final static BigInteger flag=new BigInteger("1");
private final static BigInteger p=new BigInteger("9183437365667304713151339115533307748437632107328003875473596831166621217151099398895985502248093628101123702365666975004854482171521309873216481517187327");
private final static BigInteger q=new BigInteger("7029820695008441957065724311434977975249823906050830354649892478269625322133288476430275975540723696853422938582813278061763348125218857806738991220864067");
private static BigInteger privatekey;
private static BigInteger publickey;
private BigInteger n; //大素数n
private BigInteger pn; //n的欧拉值
private BigInteger d,temp;
int j;
test()
{
n=p.multiply(q); //n=p*q;
System.out.println("n="+n);
pn=(p.subtract(flag)).multiply(q.subtract(flag)); //pn=(p-1)*(q-1)
temp=pn.subtract(flag); //从pn-1开始向下寻找publickey
do
{
temp=temp.subtract(flag);
d=temp.gcd(pn); //temp与pn的最大公因数
j=d.intValue();
}while(j!=1); //当最大公因数为1时，找到publickey
publickey=temp;
System.out.println("publickey="+publickey);
privatekey=temp.modInverse(pn); //私钥pivatekey*publickey mod pn=1
}
BigInteger modPow(BigInteger base,BigInteger exponent,BigInteger modules) //运算函数
{
BigInteger result=new BigInteger("0");
if(base.compareTo(new BigInteger("0"))==0)
return result;
else
if(exponent.compareTo(new BigInteger("0"))==0)
return flag;
else
if(exponent.compareTo(new BigInteger("1"))==0)
return base.mod(modules);
else
{
result=modPow((base.multiply(base)).mod(modules),exponent.divide(new BigInteger("2")),modules);
if(exponent.mod(new BigInteger("2")).compareTo(flag)!=0)
return result;
else
return result.multiply(base).mod(modules);
}
}
BigInteger encrypt_normal(BigInteger message) //加密过程
{
return modPow(message,publickey, n);
}
BigInteger decrypt_normal(BigInteger message) //解密过程
{
return modPow(message,privatekey,n);
}
BigInteger encrypt_quick(BigInteger message)
{
String pub_key=publickey.toString(2);
BigInteger result;
BigInteger temp=message;
int i,length=pub_key.length();
if((pub_key.charAt(length-1))=='0')
result=flag;
else
result=message;
for(i=length-2;i>=0;i--)
{
temp=(temp.multiply(temp)).mod(n);
if(pub_key.charAt(i)=='1')
result=(result.multiply(temp)).mod(n);
}
return result;
}
BigInteger decrypt_quick(BigInteger message)
{
String pub_key=privatekey.toString(2);
BigInteger result;
BigInteger temp=message;
int i,length=pub_key.length();
if((pub_key.charAt(length-1))=='0')
result=flag;
else
result=message;
for(i=length-2;i>=0;i--)
{
temp=(temp.multiply(temp)).mod(n);
if(pub_key.charAt(i)=='1')
result=(result.multiply(temp)).mod(n);
}
return result;
}
}

复制代码

1班1号原野 · 发表于 2022-5-31 09:52:09

接上一条RSA算法代码
（2）oo类

package tttt;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.IOException;
import java.math.BigInteger;
public class oo extends JFrame
{
test test=new test();
protected JButton button_en=new JButton("加密");
protected JButton button_de=new JButton("解密");
protected JButton button_exit=new JButton("退出");
protected JLabel label1=new JLabel(" 明文 ");
protected JLabel label2=new JLabel("加密结果 ");
protected JLabel label5=new JLabel("解密结果 ");
protected JLabel label3=new JLabel(" 时间开销(秒)");
protected JLabel label4=new JLabel(" 加脱密方式");
protected JLabel label6=new JLabel("注意:实验明文输入不能超过128个字符，否则解密会乱码");
protected JPanel panel1=new JPanel();
protected JPanel panel2=new JPanel();
protected JPanel panel3=new JPanel();
protected JPanel panel4=new JPanel();
protected JPanel panel5=new JPanel();
protected JPanel panel6=new JPanel();
protected GridBagLayout glo1=new GridBagLayout();
protected GridBagConstraints c = new GridBagConstraints();
protected GridLayout glo2=new GridLayout(3,3,3,3);
protected FlowLayout glo3=new FlowLayout();
protected JRadioButton jr_button1=new JRadioButton(" 快速方式");
protected JRadioButton jr_button2=new JRadioButton(" 一般方式");
protected JTextField textfield1=new JTextField(22);
protected JTextField textfield2=new JTextField(22);
protected JTextField textfield3=new JTextField(5);
protected JTextField textfield4=new JTextField(5);
protected JTextField textfield5=new JTextField(22);
protected boolean method=false; //默认加密模式一般方式
String mt,mm,str;
BigInteger en,result,message;
byte[] bc=new byte[10000];
byte[] by=new byte[10000];
Container container=getContentPane();
EventHandler handler=new EventHandler();
EventHandler1 handler1=new EventHandler1();
oo()
{
super("test加脱密系统");
container.add(panel1);
panel1.setLayout(glo3);
panel1.add(panel2);
panel2.setLayout(glo1);
c.fill = GridBagConstraints.BOTH; //在水平方向和垂直方向上同时调整组件大小
c.weightx = 1.0;
panel2.add(label1,c);
panel2.add(textfield1,c);
textfield1.setForeground(Color.RED);
textfield1.setBackground(Color.WHITE);
panel1.add(panel4);
panel4.setLayout(glo1);
panel4.add(label2,c);
panel4.add(textfield2,c);
textfield2.setForeground(Color.RED);
textfield2.setBackground(Color.WHITE);
panel1.add(panel5);
panel5.setLayout(glo1);
panel5.add(label5,c);
panel5.add(textfield5,c);
textfield5.setForeground(Color.RED);
textfield5.setBackground(Color.WHITE);
panel1.add(panel3);
panel3.setLayout(glo2);
panel3.add(label4);
panel3.add(label3);
panel3.add(button_en);
panel3.add(jr_button1);
panel3.add(textfield3);
textfield3.setForeground(Color.BLUE);
textfield3.setBackground(Color.WHITE);
panel3.add(button_de);
panel3.add(jr_button2);
panel3.add(textfield4);
textfield4.setForeground(Color.BLUE);
textfield4.setBackground(Color.WHITE);
panel3.add(button_exit);
panel1.add(panel6);
panel6.add(label6);
button_en.addActionListener(handler); //button调用事件处理类
button_de.addActionListener(handler);
button_exit.addActionListener(handler);
jr_button1.addActionListener(handler1);
jr_button2.addActionListener(handler1);
setSize(330,250);
setVisible(true);
setResizable(false); // 不能用鼠标拉伸窗体
}
class EventHandler1 implements ActionListener
{
public void actionPerformed(ActionEvent event)
{
JRadioButton jcheck=(JRadioButton)event.getSource(); //获取发生event的对象
if(jcheck==jr_button1)
{
method=false; //选择快速加密方式
jr_button1.setSelected(true);
jr_button2.setSelected(false);
}
if(jcheck==jr_button2)
{
method=true; //选择一般加密方式
jr_button2.setSelected(true);
jr_button1.setSelected(false);
}
}
}
class EventHandler implements ActionListener //自建一个事件处理类,内部嵌套类
{
public void actionPerformed(ActionEvent event) //实现接口中的actionPerformed方法
{
JButton check=(JButton)event.getSource();
if(check==button_en)
{
str=textfield1.getText();
System.out.println("需加密信息="+str);
try
{
String str1=java.net.URLEncoder.encode(str,"utf-8"); //对汉字进行处理，避免解密时乱码
by=str1.getBytes(); //将读入信息转化为字节数组
}catch(IOException e)
{
e.printStackTrace();
}
message=new BigInteger(by); //将转化的字节数组变成大数表示
if(method)
{
long t1 = System.nanoTime();
for(int i=0;i<10;i++)
{
en=test.encrypt_normal(message);
}
long t2 = System.nanoTime();
mt=(en.toString(16)).toUpperCase();
textfield2.setText(mt);
long anverage_time=(t2-t1)/10;
Float time=new Float(anverage_time/(float)1000000000); //加密10次的平均时间
textfield4.setText(time.toString());
}
else
{
long t1=System.nanoTime();
for(int i=0;i<10;i++)
{
en=test.encrypt_quick(message);
}
long t2=System.nanoTime();
mm=(en.toString(16)).toUpperCase();
textfield2.setText(mm);
long anverage_time=(t2-t1)/10;
Float time=new Float(anverage_time/(float)1000000000); //加密10次的平均时间
textfield3.setText(time.toString());;
}
}
if(check==button_de)
{
if(method)
{
result=test.decrypt_normal(en);
str=result.toString(); //解密结果由大数转化为数字字符串
bc=result.toByteArray(); //将字符串转化为字节数组
String x=new String(bc); //将字节数组转化为字符串
try{
String y=java.net.URLDecoder.decode(x,"utf-8"); //汉字处理
textfield5.setText(y);
}catch(IOException e)
{
e.printStackTrace();
}
}
else
{
result=test.decrypt_quick(en);
str=result.toString(); //解密结果由大数转化为数字字符串
bc=result.toByteArray(); //将字符串转化为字节数组
String x=new String(bc); //将字节数组转化为字符串
try{
String y=java.net.URLDecoder.decode(x,"utf-8"); //汉字处理
textfield5.setText(y);
}catch(IOException e)
{
e.printStackTrace();
}
}
}
if(check==button_exit)
{
System.exit(0);
}
}
}
public static void main(String[] args)
{
oo oo=new oo();
oo.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}

复制代码

5.截图：

		自动登录	找回密码
密码			立即注册

信息计算2019级1班1号原野

本帖子中包含更多资源

浏览过的版块