JAVA实现古典置换密码的加密解密

合集下载

JAVA实现古典置换密码的加密解密

JAVA实现古典置换密码的加密解密

import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.util.Arrays;public class zhihuan {public static void main(String args[]) throws IOException{System.out.println("请您输入需要的服务,1为加密,2为解密");BufferedReader br=new BufferedReader(new InputStreamReader(System.in));int Choice=Integer.parseInt(br.readLine());if(Choice==1){System.out.println("您进入了加密程序");System.out.print("请输入您需要加密的明文:");String MingWen=br.readLine();System.out.print("请输入加密秘钥:");String key=br.readLine();jiami(MingWen,key);Choice=2;}if(Choice==2){System.out.println("您进入了解密程序");System.out.print("请输入您需要解密的密文:");String MiWen=br.readLine();System.out.print("请输入解密秘钥:");String key2=br.readLine();jiemi(MiWen,key2);System.exit(0);}else{System.out.println("输入错误,请重新输入,1为加密,2为解密:\n");System.exit(0);}}static void jiami(String mingwen,String key){int hang=(int)Math.ceil((double)mingwen.length()/(double)key.length());//行数int lie=key.length();//列数char[][] juzhen=new char[hang][lie];//定义矩阵存储明文int temp=0;for(int i=0;i<hang;i++)//嵌套循环将明文存入矩阵{for(int j=0;j<lie;j++){if(temp<mingwen.length()){juzhen[i][j]=mingwen.charAt(temp);temp++;}}}int[] key_xu=new int[key.length()];//此数组存储秘钥字母顺序for(int i=0;i<key.length();i++)//将秘钥转ASCII码{key_xu[i]=(int)key.charAt(i);}Arrays.sort(key_xu); //对秘钥ASCII码进行排序int[] a=new int[key.length()];//此数组用于记录转换映射for(int i=0;i<key.length();i++)//利用嵌套循环在数组a中记录转换映射关系for(int j=0;j<key.length();j++){if( (int)key.charAt(i)==key_xu[j]){a[i]=j;}}char[][] mima=new char[hang][lie];//定义第一次转置后的密码矩阵for(int j=0;j<lie;j++)//开始第一次转置for(int i=0;i<hang;i++){mima[i][j]=juzhen[i][a[j]];}System.out.print("加密后密码:");for(int j=0;j<lie;j++)//第二次转置输出结果{for(int i=0;i<hang;i++){System.out.print(mima[i][a[j]]);}}}static void jiemi(String miwen,String key){int hang=(int)Math.ceil((double)miwen.length()/(double)key.length());//int lie=key.length();//char[][] juzhen=new char[hang][lie];int temp=0;for(int j=0;j<lie;j++)//嵌套循环将明文存入矩阵{for(int i=0;i<hang;i++){if(temp<miwen.length()){juzhen[i][j]=miwen.charAt(temp);temp++;}}}int[] key_xu=new int[key.length()];//此数组存储秘钥字母顺序for(int i=0;i<key.length();i++)//将秘钥转ASCII码{key_xu[i]=(int)key.charAt(i);}Arrays.sort(key_xu); //对秘钥ASCII码进行排序int[] a=new int[key.length()];//此数组用于记录转换映射for(int i=0;i<key.length();i++)//利用嵌套循环在数组a中记录转换映射关系for(int j=0;j<key.length();j++){if( (int)key.charAt(i)==key_xu[j]){a[i]=j;}}char[][] ming=new char[hang][lie];//定义第一次转置后的密码矩阵for(int j=0;j<lie;j++)//开始第一次转置for(int i=0;i<hang;i++){ming[i][a[j]]=juzhen[i][j];}char[][] mingwen=new char[hang][lie];for(int j=0;j<lie;j++)//开始第2次转置for(int i=0;i<hang;i++){mingwen[i][a[j]]=ming[i][j];}System.out.println("解密结果为:");for(int i=0;i<hang;i++){for(int j=0;j<lie;j++){System.out.print(mingwen[i][j]);}}}}。

信息安全实习一--古典加密算法

信息安全实习一--古典加密算法

一、实习名称古典加密算法二、实习目的1.熟悉java平台开发环境;2.理解常见古典加密算法:凯撒密码、多字母替代密码、多表替代密码;3.理解古典加密技术中的替换技术、置换技术。

三、实习内容1.[问题描述]凯撒密码是把字母表中的每个字母用该字母后的某个字母进行代替。

凯撒密码的通用加密算法是:C=E(P)=(P+k) mod 26 0<k<26凯撒密码的通用解密算法是:P=D(C)=(P-k) mod 26 0<k<262.[基本要求]实现凯撒密码的加密、解密算法,能够根据用户选择秘钥(移位数)和明文进行加解密。

3.[实现提示](1) 用户可以通过命令实现密钥和明文的选择;(2) 由于字母表中共有26个字符,因此,移位前应先将移动的位数(key)和26取模。

Java 平台中可以实现字符和整数的自动转换,因此将字符加上一个正整数代表在字母表中右移位数。

如果移动的位数为负值,则代表在字母中左移位数。

(3) 尽管移位前已经将移动的位数和26取模,但是通过这种方式实现的右移和左移仍可能发生超界。

因此,移位后仍要判断是否超界。

四、操作过程(1)设计加密解密算法根据通用的的加密解密算法(凯撒密码的通用加密算法是:C=E(P)=(P+k) mod 26 0<k<26;凯撒密码的通用解密算法是:P=D(C)=(P-k) mod 26,0<k<26)推导更为复杂的算法。

第一步首先扩充加密解密的字符表,从26个英文字母扩充到ASC码所有非控制字符。

为了方便加减字符表,设计了WordTable类,该类为KeyTable类的数组集合,储存所有可识别字符,并在此加入了空格符,因此可以识别多个以空格为分隔符的字符串。

第二步扩充了加密解密的起始位,可以将起始位设置为任意数字。

经过两步的算法升级,新的凯撒密码的加密算法是:C=E(P)=(P-s+k) mod l+s;凯撒密码的解密算法是:C=E(P)=(P-s-k) mod l+s,该算法中,s代表起始位,k代表密钥值,l代表字符表的长度,即可识别的字符个数。

java 密码加密解密方法

java 密码加密解密方法

java 密码加密解密方法在Java中,密码的加密和解密可以通过多种方式实现。

其中,常用的方法包括使用MessageDigest类进行加密,以及使用对称加密和非对称加密算法进行加密和解密。

一种常见的密码加密方法是使用MessageDigest类进行加密。

这可以通过以下步骤实现:首先,将密码转换为字节数组。

然后,使用MessageDigest类的getInstance方法获取特定的加密算法实例,例如SHA-256或MD5。

接下来,使用update方法将密码的字节数组传递给MessageDigest实例。

最后,使用digest方法获得加密后的字节数组,并将其转换为十六进制字符串或其他格式存储在数据库或其他地方。

另一种常见的方法是使用对称加密算法,例如AES或DES。

这些算法使用相同的密钥进行加密和解密。

在Java中,可以使用javax.crypto包中的类来实现对称加密。

通常,需要生成一个密钥并将其存储在安全的地方,然后使用该密钥对密码进行加密和解密。

此外,还可以使用非对称加密算法,例如RSA。

这种方法使用公钥对数据进行加密,然后使用私钥进行解密。

在Java中,可以使用java.security包中的类来实现非对称加密。

无论使用哪种方法,都需要注意密码安全的问题。

例如,密钥的安全存储和管理,以及密码传输过程中的安全性。

另外,还需要考虑密码的哈希加盐等技术来增加密码的安全性。

总之,在Java中实现密码的加密和解密有多种方法,开发人员可以根据实际需求和安全要求选择合适的加密算法和实现方式。

希望这些信息能够帮助你更好地理解Java中密码加密解密的方法。

SpringBoot中_JAVA利用国密算法_实现内容的加密_解密

SpringBoot中_JAVA利用国密算法_实现内容的加密_解密

首先来看一下什么是国密算法:国密即国家密码局认定的国产密码算法,即商用密码。

国密主要有SM1,SM2,SM3,SM4。

密钥长度和分组长度均为128位。

1、SM1 为对称加密。

其加密强度与AES(高级加密标准,Advanced Encryption Standard)相当。

该算法不公开,调用该算法时,需要通过加密芯片的接口进行调用。

2、SM2为非对称加密,基于ECC。

该算法已公开。

由于该算法基于ECC,故其签名速度与秘钥生成速度都快于RSA。

ECC 256位(SM2采用的就是ECC 256位的一种)安全强度比RSA 2048位高,但运算速度快于RSA。

3、SM3为消息摘要。

可以用MD5作为对比理解。

该算法已公开。

校验结果为256位。

4、SM4为无线局域网标准的分组数据算法。

对称加密,密钥长度和分组长度均为128位。

由于SM1、SM4加解密的分组大小为128bit,故对消息进行加解密时,若消息长度过长,需要进行分组,要消息长度不足,则要进行填充。

在很多地方还是会用到的,这里说一下这个:SM21.在pom.xml中引入依赖jar包:<dependency><groupId>org.bouncycastle</groupId><artifactId>bcprov-jdk15on</artifactId><version>1.58</version></dependency>2.然后来写一个工具类,用来生成国密的,公钥和私钥这个密码对.import org.bouncycastle.jce.provider.BouncyCastleProvider;import java.security.*;import java.security.spec.ECGenParameterSpec;import java.security.spec.PKCS8EncodedKeySpec;import java.security.spec.X509EncodedKeySpec;import java.util.Base64;/*** @author hulala* @Description 国密公私钥对工具类public class KeyUtils {/*** 生成国密公私钥对** @return* @throws Exception*/public static String[] generateSmKey() throws Exception {KeyPairGenerator keyPairGenerator = null;SecureRandom secureRandom = new SecureRandom();ECGenParameterSpec sm2Spec = new ECGenParameterSpec("sm2p256v1");keyPairGenerator = KeyPairGenerator.getInstance("EC", new BouncyCastleProvider());keyPairGenerator.initialize(sm2Spec);keyPairGenerator.initialize(sm2Spec, secureRandom);KeyPair keyPair = keyPairGenerator.generateKeyPair();PrivateKey privateKey = keyPair.getPrivate();PublicKey publicKey = keyPair.getPublic();//String[0] 公钥//String[1] 私钥String[] result = {new String(Base64.getEncoder().encode(publicKey.getEncoded())), new String(Base64.getEncoder().encode(privateKey.getEncoded())) };return result;}/*** 将Base64转码的公钥串,转化为公钥对象** @param publicKey* @return*/public static PublicKey createPublicKey(String publicKey) {PublicKey publickey = null;try {X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(Base64.getDecoder().decode(publicKey));KeyFactory keyFactory = KeyFactory.getInstance("EC", new BouncyCastleProvider());publickey = keyFactory.generatePublic(publicKeySpec);} catch (Exception e) {e.printStackTrace();}return publickey;}/*** 将Base64转码的私钥串,转化为私钥对象** @param privateKey* @return*/public static PrivateKey createPrivateKey(String privateKey) {PrivateKey publickey = null;try {PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKey));KeyFactory keyFactory = KeyFactory.getInstance("EC", new BouncyCastleProvider());publickey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);} catch (Exception e) {e.printStackTrace();}return publickey;}}3.根据公钥和私钥工具类,生成的密钥对,对数据,进行加密和解密操作import org.bouncycastle.asn1.gm.GMObjectIdentifiers;import org.bouncycastle.crypto.InvalidCipherTextException;import org.bouncycastle.crypto.engines.SM2Engine;import org.bouncycastle.crypto.params.ECDomainParameters;import org.bouncycastle.crypto.params.ECPrivateKeyParameters;import org.bouncycastle.crypto.params.ECPublicKeyParameters;import org.bouncycastle.crypto.params.ParametersWithRandom;import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;import org.bouncycastle.jce.provider.BouncyCastleProvider;import org.bouncycastle.jce.spec.ECParameterSpec;import java.security.*;/*** @author hulala* @Description SM2实现工具类*/public class Sm2Util {static {Security.addProvider(new BouncyCastleProvider());}/*** 根据publicKey对原始数据data,使用SM2加密** @param data* @param publicKey* @return*/public static byte[] encrypt(byte[] data, PublicKey publicKey) {ECPublicKeyParameters localECPublicKeyParameters = null;if (publicKey instanceof BCECPublicKey) {BCECPublicKey localECPublicKey = (BCECPublicKey) publicKey;ECParameterSpec localECParameterSpec = localECPublicKey.getParameters();ECDomainParameters localECDomainParameters = new ECDomainParameters(localECParameterSpec.getCurve(),localECParameterSpec.getG(), localECParameterSpec.getN());localECPublicKeyParameters = new ECPublicKeyParameters(localECPublicKey.getQ(), localECDomainParameters);}SM2Engine localSM2Engine = new SM2Engine();localSM2Engine.init(true, new ParametersWithRandom(localECPublicKeyParameters, new SecureRandom()));byte[] arrayOfByte2;try {arrayOfByte2 = localSM2Engine.processBlock(data, 0, data.length);return arrayOfByte2;} catch (InvalidCipherTextException e) {e.printStackTrace();return null;}}/*** 根据privateKey对加密数据encodedata,使用SM2解密** @param encodedata* @param privateKey* @return*/public static byte[] decrypt(byte[] encodedata, PrivateKey privateKey) {SM2Engine localSM2Engine = new SM2Engine();BCECPrivateKey sm2PriK = (BCECPrivateKey) privateKey;ECParameterSpec localECParameterSpec = sm2PriK.getParameters();ECDomainParameters localECDomainParameters = new ECDomainParameters(localECParameterSpec.getCurve(),localECParameterSpec.getG(), localECParameterSpec.getN());ECPrivateKeyParameters localECPrivateKeyParameters = new ECPrivateKeyParameters(sm2PriK.getD(),localECDomainParameters);localSM2Engine.init(false, localECPrivateKeyParameters);try {byte[] arrayOfByte3 = localSM2Engine.processBlock(encodedata, 0, encodedata.length);return arrayOfByte3;} catch (InvalidCipherTextException e) {e.printStackTrace();return null;}}/*** 私钥签名** @param data* @param privateKey* @return* @throws Exception*/public static byte[] signByPrivateKey(byte[] data, PrivateKey privateKey) throws Exception { Signature sig = Signature.getInstance(GMObjectIdentifiers.sm2sign_with_sm3.toString(), BouncyCastleProvider.PROVIDER_NAME);sig.initSign(privateKey);sig.update(data);byte[] ret = sig.sign();return ret;}/*** 公钥验签** @param data* @param publicKey* @param signature* @return* @throws Exception*/public static boolean verifyByPublicKey(byte[] data, PublicKey publicKey, byte[] signature) throws Exception {Signature sig = Signature.getInstance(GMObjectIdentifiers.sm2sign_with_sm3.toString(), BouncyCastleProvider.PROVIDER_NAME);sig.initVerify(publicKey);sig.update(data);boolean ret = sig.verify(signature);return ret;}}4.来测试一下,对数据进行加密解密import org.junit.Test;import java.util.Base64;/*** @author hulala* @Description Sm2Util 的测试类*/public class Sm2UtilTest {private String testStr = "wangjing";java.security.PublicKey publicKey = null;java.security.PrivateKey privateKey = null;@Testpublic void test() throws Exception {//生成公私钥对String[] keys = KeyUtils.generateSmKey();System.out.println("原始字符串:" + testStr);System.out.println("公钥:" + keys[0]);publicKey = KeyUtils.createPublicKey(keys[0]);System.out.println("私钥:" + keys[1]);privateKey = KeyUtils.createPrivateKey(keys[1]);System.out.println("");byte[] encrypt = Sm2Util.encrypt(testStr.getBytes(), publicKey);String encryptBase64Str = Base64.getEncoder().encodeToString(encrypt);System.out.println("加密数据:" + encryptBase64Str);byte[] decode = Base64.getDecoder().decode(encryptBase64Str);byte[] decrypt = Sm2Util.decrypt(decode, privateKey);System.out.println("解密数据:" + new String(decrypt));byte[] sign = Sm2Util.signByPrivateKey(testStr.getBytes(), privateKey);System.out.println("数据签名:" + Base64.getEncoder().encodeToString(sign));boolean b = Sm2Util.verifyByPublicKey(testStr.getBytes(), publicKey, sign);System.out.println("数据验签:" + b);}}5.这样就实现了利用国密,SM2进行加密解密了.。

置换密码

置换密码

实验3 置换密码一、实验目的学习常见的古典密码学算法,通过编程实现置换密码算法,加深对古典密码体制的了解,为深入学习密码学奠定基础。

二、实验原理古典密码算法曾被广泛应用,大都比较简单,使用手工和机械操作来实现加密和解密。

它的主要应用对象是文字信息,利用密码算法实现文字信息的加密和解密。

下面介绍另一种常见的具有代表性的古典密码算法----置换密码。

置换密码算法的原理是不改变明文字符,而是按照某一规则重新排列消息中的比特或字符顺序,才而实现明文信息的加密。

置换密码有时又称为换位密码。

矩阵换位法是实现置换密码的一种常用方法。

它将明文中的字母按照给定的顺序安排在一个矩阵中,然后用根据密钥提供的顺序重新组合矩阵中的字母,从而形成密文。

例如,明文为attack begins at five ,密钥为cipher ,将明文按照每行6个字母的形式排在矩阵中,形成如下形式:a t t a c kb e g i n s a t f i v e根据密钥cipher 中各个字母在字母表中出现的先后顺序,给定一个置换:123456145326f ⎡⎤=⎢⎥⎣⎦根据上面的置换,将原有居住中的字母按照第1列、第4列、第5列、第3列、第2列、第6列的顺序排列,则有下面的形式:a a c t t kb i n g e s a i v f t e从而得到密文:abatgftetcnvaiikse其解密过程是根据密钥的字母数作为列数,将密文按照列、行的顺序写出,再根据由密钥给出的矩阵置换产生新的矩阵,从而恢复明文。

三、实验所需仪器、设备运行Windows 操作系统的PC 机,具VC++(Windows )等C 语言编译环境。

四、实验内容和要求1. 根据实验原理部分对置换密码算法的介绍,自己创建明文信息,并选择一个密钥,编写置换密码算法的实现程序,实现加密和解密操作。

2.要求上述密码算法最后的实现程序提供加密和解密两个接口:int encrypt ( )和 int decrypt ( ),当加密或者解密成功时返回 CRYPT_OK,失败时返回 CRYPT_ERROR。

替代密码和置换密码地C语言实现

替代密码和置换密码地C语言实现

实验一一、实验名称:替代密码和置换密码的实现二、实验目的:通过编程实现替代密码算法和置换密码算法,加深对古典密码体系的了解,为以后深入学习密码学奠定基础。

三、实验内容:A:替代密码1、实验原理:使用替代法进行加密,将明文中的字符用其他字符替代后形成密文。

最早的替代密码是由Julius Caesar 发明的Caesar (恺撒)密码,又叫循环移位密码。

它的加密过程可表示为: E(m) = (m+k ) mod n其中,m为明文字母在字母表中的位置数;n为字母表中的字母个数;k为密钥;E(m)为密文字母在字母表中对应的位置数。

解密算法是:m = D(L) =(L-k)mod 26;2、算法设计:使用两个函数分别进行加密和解密的过程,在主程序中通过选择加密还是解密来调用不同函数进行替代密码的加密和解密过程实现;3、函数接口:加密:int encrypt(){printf("输入明文:\n");scanf("%s",a);for(i=0;a[i]!='\0';i++){b[i]=a[i]-64;}printf("输入一位密钥\n");scanf("%d",&k);printf("\n");for(i=0;b[i]!='\0';i++){m[i]=(b[i]+k)%26+64;}printf("%s",&m);return 0;}解密:int decode(){printf("输入密文:\n");scanf("%s",a);for(i=0;a[i]!='\0';i++){b[i]=a[i]-64;}printf("输入一位密钥\n"); scanf("%d",&k);printf("\n");for(i=0;b[i]!='\0';i++){n[i]=(b[i]-k)%26+64;}printf("%s",n);return 0;}4、程序流程图:5、测试结果截图:加密:解密:B:1、实验原理:不改变明文字符,但是把字符在明文中的排列顺序改变,来实现明文信息的加密。

java 加密解密简单实现

java 加密解密简单实现

java 加密解密简单实现加密算法有很多种:这里只大约列举几例:1:消息摘要:(数字指纹):既对一个任意长度的一个数据块进行计算,产生一个唯一指纹。

MD5/SHA1发送给其他人你的信息和摘要,其他人用相同的加密方法得到摘要,最后进行比较摘要是否相同。

2:单匙密码体制:DES:比较简便高效,密钥简短,加解密速度快,破译极其困难,但其安全性依赖于密匙的安全性。

DES(Data Encryption Standard)是发明最早的最广泛使用的分组对称加密算法。

DES算法的入口参数有三个:Key、Data、Mode。

其中Key为8个字节共64位,是DES算法的工作密钥;Data也为8个字节64位,是要被加密或被解密的数据;Mode为DES的工作方式,有两种:加密或解密3:数字签名:就是信息发送者用其私钥对从所传报文中提取出的特征数据(或称数字指纹)进行RSA算法操作,以保证发信人无法抵赖曾发过该信息(即不可抵赖性),同时也确保信息报文在经签名后末被篡改(即完整性)。

当信息接收者收到报文后,就可以用发送者的公钥对数字签名进行验证。

代表:DSA4:非对称密匙密码体制(公匙体系):加密密匙不同于解密密匙,加密密匙公之于众,谁都可以使用,解密密匙只有解密人自己知道。

代表:RSA下面是对上面几个例子进行的简单实现:Java代码1.package test;2.import java.io.FileInputStream;3.import java.io.FileOutputStream;4.import java.io.IOException;5.import java.io.ObjectInputStream;6.import java.io.ObjectOutputStream;7.import java.security.*;8.import javax.crypto.Cipher;9.import javax.crypto.KeyGenerator;10.import javax.crypto.SecretKey;11./**12. * 加密解密13. *14. * @author shy.qiu15. * @since /qiushyfm16. */17.public class CryptTest {18. /**19. * 进行MD5加密20. *21. * @param info22. * 要加密的信息23. * @return String 加密后的字符串24. */25. public String encryptToMD5(String info) {26. byte[] digesta = null;27. try {28. // 得到一个md5的消息摘要29. MessageDigest alga = MessageDigest.getInstance("MD5");30. // 添加要进行计算摘要的信息31. alga.update(info.getBytes());32. // 得到该摘要33. digesta = alga.digest();34. } catch (NoSuchAlgorithmException e) {35. e.printStackTrace();36. }37. // 将摘要转为字符串38. String rs = byte2hex(digesta);39. return rs;40. }41. /**42. * 进行SHA加密43. *44. * @param info45. * 要加密的信息46. * @return String 加密后的字符串47. */48. public String encryptToSHA(String info) {49. byte[] digesta = null;50. try {51. // 得到一个SHA-1的消息摘要52. MessageDigest alga = MessageDigest.getInstance("SHA-1");53. // 添加要进行计算摘要的信息54. alga.update(info.getBytes());55. // 得到该摘要56. digesta = alga.digest();57. } catch (NoSuchAlgorithmException e) {58. e.printStackTrace();59. }60. // 将摘要转为字符串61. String rs = byte2hex(digesta);62. return rs;63. }64. // //////////////////////////////////////////////////////////////////////////65. /**66. * 创建密匙67. *68. * @param algorithm69. * 加密算法,可用 DES,DESede,Blowfish70. * @return SecretKey 秘密(对称)密钥71. */72. public SecretKey createSecretKey(String algorithm) {73. // 声明KeyGenerator对象74. KeyGenerator keygen;75. // 声明密钥对象76. SecretKey deskey = null;77. try {78. // 返回生成指定算法的秘密密钥的 KeyGenerator 对象79. keygen = KeyGenerator.getInstance(algorithm);80. // 生成一个密钥81. deskey = keygen.generateKey();82. } catch (NoSuchAlgorithmException e) {83. e.printStackTrace();84. }85. // 返回密匙86. return deskey;87. }88. /**89. * 根据密匙进行DES加密90. *91. * @param key92. * 密匙93. * @param info94. * 要加密的信息95. * @return String 加密后的信息96. */97. public String encryptToDES(SecretKey key, String info) {98. // 定义加密算法,可用 DES,DESede,Blowfish99. String Algorithm = "DES";100. // 加密随机数生成器 (RNG),(可以不写)101. SecureRandom sr = new SecureRandom();102. // 定义要生成的密文103. byte[] cipherByte = null;104. try {105. // 得到加密/解密器106. Cipher c1 = Cipher.getInstance(Algorithm); 107. // 用指定的密钥和模式初始化Cipher对象108. // 参数:(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE) 109. c1.init(Cipher.ENCRYPT_MODE, key, sr); 110. // 对要加密的内容进行编码处理,111. cipherByte = c1.doFinal(info.getBytes()); 112. } catch (Exception e) {113. e.printStackTrace();114. }115. // 返回密文的十六进制形式116. return byte2hex(cipherByte);117. }118. /**119. * 根据密匙进行DES解密120. *121. * @param key122. * 密匙123. * @param sInfo124. * 要解密的密文125. * @return String 返回解密后信息126. */127. public String decryptByDES(SecretKey key, String sInfo ) {128. // 定义加密算法,129. String Algorithm = "DES";130. // 加密随机数生成器 (RNG)131. SecureRandom sr = new SecureRandom();132. byte[] cipherByte = null;133. try {134. // 得到加密/解密器135. Cipher c1 = Cipher.getInstance(Algorithm); 136. // 用指定的密钥和模式初始化Cipher对象137. c1.init(Cipher.DECRYPT_MODE, key, sr); 138. // 对要解密的内容进行编码处理139. cipherByte = c1.doFinal(hex2byte(sInfo)); 140. } catch (Exception e) {141. e.printStackTrace();142. }143. // return byte2hex(cipherByte);144. return new String(cipherByte);145. }146. // /////////////////////////////////////////////////// //////////////////////////147. /**148. * 创建密匙组,并将公匙,私匙放入到指定文件中149. *150. * 默认放入mykeys.bat文件中151. */152. public void createPairKey() {153. try {154. // 根据特定的算法一个密钥对生成器155. KeyPairGenerator keygen = KeyPairGenerator.get Instance("DSA");156. // 加密随机数生成器 (RNG)157. SecureRandom random = new SecureRandom(); 158. // 重新设置此随机对象的种子159. random.setSeed(1000);160. // 使用给定的随机源(和默认的参数集合)初始化确定密钥大小的密钥对生成器161. keygen.initialize(512, random);// keygen.initi alize(512);162. // 生成密钥组163. KeyPair keys = keygen.generateKeyPair(); 164. // 得到公匙165. PublicKey pubkey = keys.getPublic();166. // 得到私匙167. PrivateKey prikey = keys.getPrivate(); 168. // 将公匙私匙写入到文件当中169. doObjToFile("mykeys.bat", new Object[] { prike y, pubkey });170. } catch (NoSuchAlgorithmException e) {171. e.printStackTrace();172. }173. }174. /**175. * 利用私匙对信息进行签名把签名后的信息放入到指定的文件中176. *177. * @param info178. * 要签名的信息179. * @param signfile180. * 存入的文件181. */182. public void signToInfo(String info, String signfile) {183. // 从文件当中读取私匙184. PrivateKey myprikey = (PrivateKey) getObjFromFile( "mykeys.bat", 1);185. // 从文件中读取公匙186. PublicKey mypubkey = (PublicKey) getObjFromFile("m ykeys.bat", 2);187. try {188. // Signature 对象可用来生成和验证数字签名189. Signature signet = Signature.getInstance("DSA");190. // 初始化签署签名的私钥191. signet.initSign(myprikey);192. // 更新要由字节签名或验证的数据193. signet.update(info.getBytes());194. // 签署或验证所有更新字节的签名,返回签名195. byte[] signed = signet.sign();196. // 将数字签名,公匙,信息放入文件中197. doObjToFile(signfile, new Object[] { signed, m ypubkey, info });198. } catch (Exception e) {199. e.printStackTrace();200. }201. }202. /**203. * 读取数字签名文件根据公匙,签名,信息验证信息的合法性204. *205. * @return true 验证成功 false 验证失败206. */207. public boolean validateSign(String signfile) { 208. // 读取公匙209. PublicKey mypubkey = (PublicKey) getObjFromFile(si gnfile, 2);210. // 读取签名211. byte[] signed = (byte[]) getObjFromFile(signfile,1);212. // 读取信息213. String info = (String) getObjFromFile(signfile, 3) ;214. try {215. // 初始一个Signature对象,并用公钥和签名进行验证216. Signature signetcheck = Signature.getInstance( "DSA");217. // 初始化验证签名的公钥218. signetcheck.initVerify(mypubkey);219. // 使用指定的 byte 数组更新要签名或验证的数据220. signetcheck.update(info.getBytes());221. System.out.println(info);222. // 验证传入的签名223. return signetcheck.verify(signed);224. } catch (Exception e) {225. e.printStackTrace();226. return false;227. }228. }229. /**230. * 将二进制转化为16进制字符串231. *232. * @param b233. * 二进制字节数组234. * @return String235. */236. public String byte2hex(byte[] b) {237. String hs = "";238. String stmp = "";239. for (int n = 0; n < b.length; n++) {240. stmp = (ng.Integer.toHexString(b[n] & 0 XFF));241. if (stmp.length() == 1) {242. hs = hs + "0" + stmp;243. } else {244. hs = hs + stmp;245. }246. }247. return hs.toUpperCase();248. }249. /**250. * 十六进制字符串转化为2进制251. *252. * @param hex253. * @return254. */255. public byte[] hex2byte(String hex) {256. byte[] ret = new byte[8];257. byte[] tmp = hex.getBytes();258. for (int i = 0; i < 8; i++) {259. ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1] );260. }261. return ret;262. }263. /**264. * 将两个ASCII字符合成一个字节;如:"EF"--> 0xEF 265. *266. * @param src0267. * byte268. * @param src1269. * byte270. * @return byte271. */272. public static byte uniteBytes(byte src0, byte src1) {273. byte _b0 = Byte.decode("0x" + new String(new byte[ ] { src0 }))274. .byteValue();275. _b0 = (byte) (_b0 << 4);276. byte _b1 = Byte.decode("0x" + new String(new byte[ ] { src1 }))277. .byteValue();278. byte ret = (byte) (_b0 ^ _b1);279. return ret;280. }281. /**282. * 将指定的对象写入指定的文件283. *284. * @param file285. * 指定写入的文件286. * @param objs287. * 要写入的对象288. */289. public void doObjToFile(String file, Object[] objs) {290. ObjectOutputStream oos = null;291. try {292. FileOutputStream fos = new FileOutputStream(fi le);293. oos = new ObjectOutputStream(fos);294. for (int i = 0; i < objs.length; i++) { 295. oos.writeObject(objs[i]);296. }297. } catch (Exception e) {298. e.printStackTrace();299. } finally {300. try {301. oos.close();302. } catch (IOException e) {303. e.printStackTrace();304. }305. }306. }307. /**308. * 返回在文件中指定位置的对象309. *310. * @param file311. * 指定的文件312. * @param i313. * 从1开始314. * @return315. */316. public Object getObjFromFile(String file, int i) { 317. ObjectInputStream ois = null;318. Object obj = null;319. try {320. FileInputStream fis = new FileInputStream(file );321. ois = new ObjectInputStream(fis);322. for (int j = 0; j < i; j++) {323. obj = ois.readObject();324. }325. } catch (Exception e) {326. e.printStackTrace();327. } finally {328. try {329. ois.close();330. } catch (IOException e) {331. e.printStackTrace();332. }333. }334. return obj;335. }336. /**337. * 测试338. *339. * @param args340. */341. public static void main(String[] args) {342. CryptTest jiami = new CryptTest();343. // 执行MD5加密"Hello world!"344. System.out.println("Hello经过MD5:" + jiami.encryptToMD5("Hello"));345. // 生成一个DES算法的密匙346. SecretKey key = jiami.createSecretKey("DES"); 347. // 用密匙加密信息"Hello world!"348. String str1 = jiami.encryptToDES(key, "Hello"); 349. System.out.println("使用des加密信息Hello 为:" + str1);350. // 使用这个密匙解密351. String str2 = jiami.decryptByDES(key, str1); 352. System.out.println("解密后为:" + str2);353. // 创建公匙和私匙354. jiami.createPairKey();355. // 对Hello world!使用私匙进行签名356. jiami.signToInfo("Hello", "mysign.bat");357. // 利用公匙对签名进行验证。

java常用加密和解密工具类EncryptUtil.java

java常用加密和解密工具类EncryptUtil.java

java常⽤加密和解密⼯具类EncryptUtil.java 1package cn.util;23import java.io.UnsupportedEncodingException;4import java.security.MessageDigest;5import java.security.NoSuchAlgorithmException;6import java.security.SecureRandom;78import javax.crypto.Cipher;9import javax.crypto.SecretKey;10import javax.crypto.SecretKeyFactory;11import javax.crypto.spec.DESKeySpec;1213/**14 * 加密⼯具类15 *16 * md5加密出来的长度是32位17 *18 * sha加密出来的长度是40位19 *20 * @author伍⽟林21 *22*/23public final class EncryptUtil {2425private static final String PASSWORD_CRYPT_KEY = "88444488";2627private final static String DES = "DES";2829/**30 * ⼆次加密先sha-1加密再⽤MD5加密31 *32 * @param src33 * @return34*/35public final static String md5AndSha(String src) {36return md5(sha(src));37 }3839/**40 * ⼆次加密先MD5加密再⽤sha-1加密41 *42 * @param src43 * @return44*/45public final static String shaAndMd5(String src) {46return sha(md5(src));47 }4849/**50 * md5加密51 *52 * @param src53 * @return54*/55public final static String md5(String src) {56return encrypt(src, "md5");57 }5859/**60 * sha-1加密61 *62 * @param src63 * @return64*/65public final static String sha(String src) {66return encrypt(src, "sha-1");67 }6869/**70 * md5或者sha-1加密71 *72 * @param src73 * 要加密的内容74 * @param algorithmName75 * 加密算法名称:md5或者sha-1,不区分⼤⼩写76 * @return77*/78private final static String encrypt(String src, String algorithmName) {79if (src == null || "".equals(src.trim())) {80throw new IllegalArgumentException("请输⼊要加密的内容");81 }82if (algorithmName == null || "".equals(algorithmName.trim())) {83 algorithmName = "md5";84 }85 String encryptText = null;86try {87 MessageDigest m = MessageDigest.getInstance(algorithmName);88 m.update(src.getBytes("UTF8"));89byte s[] = m.digest();90// m.digest(src.getBytes("UTF8"));91return hex(s);92 } catch (NoSuchAlgorithmException e) {93 e.printStackTrace();94 } catch (UnsupportedEncodingException e) {95 e.printStackTrace();96 }97return encryptText;98 }99100/**101 * 密码解密102 *103 * @param data104 * @return105 * @throws Exception106*/107public final static String decrypt(String src) {108try {109return new String(decrypt(hex2byte(src.getBytes()), PASSWORD_CRYPT_KEY.getBytes())); 110 } catch (Exception e) {111 }112return null;113 }114115/**116 * 密码加密117 *118 * @param password119 * @return120 * @throws Exception121*/122public final static String encrypt(String src) {123try {124return byte2hex(encrypt(src.getBytes(), PASSWORD_CRYPT_KEY.getBytes()));125 } catch (Exception e) {126 }127return null;128 }129130/**131 * 加密132 *133 * @param src134 * 数据源135 * @param key136 * 密钥,长度必须是8的倍数137 * @return返回加密后的数据138 * @throws Exception139*/140private static byte[] encrypt(byte[] src, byte[] key) throws Exception {141// DES算法要求有⼀个可信任的随机数源142 SecureRandom sr = new SecureRandom();143// 从原始密匙数据创建DESKeySpec对象144 DESKeySpec dks = new DESKeySpec(key);145// 创建⼀个密匙⼯⼚,然后⽤它把DESKeySpec转换成⼀个SecretKey对象146 SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);147 SecretKey securekey = keyFactory.generateSecret(dks);148// Cipher对象实际完成加密操作149 Cipher cipher = Cipher.getInstance(DES);150// ⽤密匙初始化Cipher对象151 cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);152// 现在,获取数据并加密正式执⾏加密操作153return cipher.doFinal(src);154 }155156/**157 * 解密158 *159 * @param src160 * 数据源161 * @param key162 * 密钥,长度必须是8的倍数163 * @return返回解密后的原始数据164 *165 * @throws Exception166*/167private final static byte[] decrypt(byte[] src, byte[] key) throws Exception {168// DES算法要求有⼀个可信任的随机数源169 SecureRandom sr = new SecureRandom();170// 从原始密匙数据创建⼀个DESKeySpec对象171 DESKeySpec dks = new DESKeySpec(key);172// 创建⼀个密匙⼯⼚,然后⽤它把DESKeySpec对象转换成⼀个SecretKey对象173 SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);174 SecretKey securekey = keyFactory.generateSecret(dks);175// Cipher对象实际完成解密操作176 Cipher cipher = Cipher.getInstance(DES);177// ⽤密匙初始化Cipher对象178 cipher.init(Cipher.DECRYPT_MODE, securekey, sr);179// 现在,获取数据并解密正式执⾏解密操作180return cipher.doFinal(src);181 }182183private final static byte[] hex2byte(byte[] b) {184if ((b.length % 2) != 0)185throw new IllegalArgumentException("长度不是偶数");186byte[] b2 = new byte[b.length / 2];187for (int n = 0; n < b.length; n += 2) {188 String item = new String(b, n, 2);189 b2[n / 2] = (byte) Integer.parseInt(item, 16);190 }191return b2;192 }193194/**195 * ⼆⾏制转字符串196 *197 * @param b198 * @return199*/200private final static String byte2hex(byte[] b) {201 String hs = "";202 String stmp = "";203for (int n = 0; n < b.length; n++) {204 stmp = (ng.Integer.toHexString(b[n] & 0XFF));205if (stmp.length() == 1)206 hs = hs + "0" + stmp;207else208 hs = hs + stmp;209 }210return hs.toUpperCase();211 }212213/**214 * 返回⼗六进制字符串215 *216 * @param arr217 * @return218*/219private final static String hex(byte[] arr) {220 StringBuffer sb = new StringBuffer();221for (int i = 0; i < arr.length; ++i) {222 sb.append(Integer.toHexString((arr[i] & 0xFF) | 0x100).substring(1, 3)); 223 }224return sb.toString();225 }226227 }。

换位加密、解密算法

换位加密、解密算法

换位加密、解密算法换位密码算法⽅案,⼜称为置换加密⽅案,其根据⼀定的规则重新安排明⽂字母,使之成为密⽂。

换位密码是最简单的密码学算法。

1. 换位加密、解密算法换位加密解密的算法有很多种,这⾥介绍基于⼆维数组移位的换位加密、解密算法。

⼆维数组移位的换位加密、解密算法即将明⽂字符串按照⼀个给定的顺序保存在⼆维数组中,然后按照另外⼀个顺序读出,便的到密⽂。

执⾏相反的过程便可以恢复出明⽂。

1)换位加密算法基于⼆维数组移位的加密算法的操作步骤如下:(1)给定⼀个⼆维数组的列数,即该⼆维数组每⾏可以保存的字符个数。

(2)将明⽂字符串按⾏依次排列到该⼆维数组中。

(3)按列读出该⼆维数组中的字符,这样便得到密⽂。

可以根据此思路来编写相应的加密算法,代码⽰例如下:/*** 加密算法* @param str 明⽂* @param n 指定的⼆维数组的列数* @return*/static char[] jiami(char[] str,int n){int len,d,i,j,m;char[] temp,miwen;len=str.length;if((d=len%n)!=0){len = len + n-d;}temp = new char[len];m=len/n;for(i=0;i<m;i++){for(j=0;j<n;j++){if(i*n+j<str.length){temp[i+m*j]=str[i*n+j];}else{temp[i+m*j]=' ';}}}while(temp[len-1]==' '){len--;}miwen = new char[len];for(i=0;i<len;i++){miwen[i]=temp[i];}return miwen;}2)换位解密算法基于⼆维数组移位的解密算法的操作步骤如下:(1)给定⼀个⼆维数组的列数,即该⼆维数组每⾏可以保存的字符个数。

java国密加密与解密流程

java国密加密与解密流程

java国密加密与解密流程下载温馨提示:该文档是我店铺精心编制而成,希望大家下载以后,能够帮助大家解决实际的问题。

文档下载后可定制随意修改,请根据实际需要进行相应的调整和使用,谢谢!并且,本店铺为大家提供各种各样类型的实用资料,如教育随笔、日记赏析、句子摘抄、古诗大全、经典美文、话题作文、工作总结、词语解析、文案摘录、其他资料等等,如想了解不同资料格式和写法,敬请关注!Download tips: This document is carefully compiled by theeditor. I hope that after you download them,they can help yousolve practical problems. The document can be customized andmodified after downloading,please adjust and use it according toactual needs, thank you!In addition, our shop provides you with various types ofpractical materials,such as educational essays, diaryappreciation,sentence excerpts,ancient poems,classic articles,topic composition,work summary,word parsing,copy excerpts,other materials and so on,want to know different data formats andwriting methods,please pay attention!1. 引入国密相关的依赖库在 Java 项目中,需要引入国密相关的依赖库,例如 Bouncy Castle 库。

置换密码的实验报告

置换密码的实验报告

一、实验目的1. 了解置换密码的基本原理和特点。

2. 掌握置换密码的加密和解密方法。

3. 通过实验加深对古典密码体制的理解。

二、实验原理置换密码是一种将明文中的字符按照一定的规则进行重新排列,从而形成密文的加密方法。

在置换密码中,字符本身不发生改变,只是位置发生了变化。

常见的置换密码有矩阵换位法、周期置换密码、列置换密码等。

三、实验内容1. 矩阵换位法(1)选择一个密钥,例如:KEY。

(2)去掉密钥中的重复字母,并按字典顺序给密钥字母一个数字编号,得到数字序列:K=1,E=2,Y=3。

(3)根据数字序列,将明文信息按列排列成一个矩阵,例如:明文:this is a secret矩阵:T H I SI S AS E CR E T(4)根据密钥的数字序列,将矩阵中的字母按照列、行的顺序重新组合,得到密文:密文:TISISECRETS2. 周期置换密码(1)选择一个密钥,例如:KEY。

(2)去掉密钥中的重复字母,并按字典顺序给密钥字母一个数字编号,得到数字序列:K=1,E=2,Y=3。

(3)根据数字序列,将明文信息按列排列成一个矩阵,例如:明文:this is a secret矩阵:T H I SI S AS E CR E T(4)根据密钥的数字序列,将矩阵中的字母按照周期性的顺序重新组合,得到密文:密文:TISECRETSIS3. 列置换密码(1)选择一个密钥,例如:KEY。

(2)去掉密钥中的重复字母,并按字典顺序给密钥字母一个数字编号,得到数字序列:K=1,E=2,Y=3。

(3)根据数字序列,将明文信息按列排列成一个矩阵,例如:明文:this is a secret矩阵:T H I SI S AS E CR E T(4)根据密钥的数字序列,将矩阵中的字母按照列、行的顺序重新组合,得到密文:密文:TISECRETSIS四、实验步骤1. 编写程序实现矩阵换位法加密和解密。

2. 编写程序实现周期置换密码加密和解密。

java enc解密方法

java enc解密方法

java enc解密方法在Java中,可以使用Java内置的加密和解密库来实现加密和解密操作。

以下是一个简单的示例,演示如何使用Java内置的加密和解密库进行加密和解密操作:```javaimport ;import ;import ;import ;public class EncryptionExample {public static void main(String[] args) throws Exception {// 原始字符串String original = "Hello, World!";// 加密密钥String key = "secretkey";// 加密操作Cipher cipher = ("AES/ECB/PKCS5Padding");SecretKeySpec secretKey = new SecretKeySpec((_8), "AES");(_MODE, secretKey);byte[] encrypted = ((_8));String encryptedString = ().encodeToString(encrypted);("加密后的字符串: " + encryptedString);// 解密操作(_MODE, secretKey);byte[] decrypted = (().decode(encryptedString));String decryptedString = new String(decrypted, _8);("解密后的字符串: " + decryptedString);}}```在这个示例中,我们使用AES算法进行加密和解密操作。

我们首先定义了一个原始字符串和加密密钥。

然后,我们使用Cipher类创建一个加密对象,并使用指定的算法和模式进行初始化。

置换密码_实验报告

置换密码_实验报告

一、实验目的1. 了解置换密码的基本原理和特点;2. 掌握置换密码的加密和解密方法;3. 通过编程实现置换密码,加深对密码学知识的理解。

二、实验原理置换密码是一种将明文中的每个字符按照一定的规则进行替换的加密方法。

它将明文中的每个字符按照密钥序列进行重新排列,从而形成密文。

置换密码的特点是加密速度快,安全性较高,但密钥的生成和存储较为复杂。

置换密码的加密和解密过程如下:1. 加密过程:(1)将明文按照密钥序列进行重新排列;(2)将排列后的字符序列转换为密文。

2. 解密过程:(1)将密文按照密钥序列进行逆序排列;(2)将排列后的字符序列转换为明文。

三、实验环境1. 操作系统:Windows 102. 编程语言:Python3.83. 开发工具:PyCharm四、实验步骤1. 设计置换密码算法(1)定义密钥序列,密钥序列可以是任意字符序列;(2)定义加密函数,将明文按照密钥序列进行重新排列;(3)定义解密函数,将密文按照密钥序列进行逆序排列。

2. 编写加密和解密函数```pythondef encrypt(plain_text, key):cipher_text = ""key_length = len(key)key_index = 0for char in plain_text:if char.isalpha():shift = (ord(char.upper()) - ord('A') + ord(key[key_index % key_length].upper()) - ord('A')) % 26cipher_text += chr(ord('A') + shift)key_index += 1else:cipher_text += charreturn cipher_textdef decrypt(cipher_text, key):plain_text = ""key_length = len(key)key_index = 0for char in cipher_text:if char.isalpha():shift = (ord(char.upper()) - ord('A') - (ord(key[key_index % key_length].upper()) - ord('A'))) % 26plain_text += chr(ord('A') + shift)key_index += 1else:plain_text += charreturn plain_text```3. 编写主程序```pythonif __name__ == "__main__":plain_text = input("请输入明文:")key = input("请输入密钥:")cipher_text = encrypt(plain_text, key)print("密文:", cipher_text)decrypted_text = decrypt(cipher_text, key) print("解密后的明文:", decrypted_text)```4. 运行程序,进行加密和解密操作五、实验结果与分析1. 加密过程:输入明文:“Hello World!”输入密钥:“key”输出密文:“Svool Dliow!”2. 解密过程:输入密文:“Svool Dliow!”输入密钥:“key”输出解密后的明文:“Hello World!”实验结果表明,所设计的置换密码算法能够正确地对明文进行加密和解密操作。

java中decrypt和encrypt方法

java中decrypt和encrypt方法

java中decrypt和encrypt方法在Java中,加密(encrypt)和解密(decrypt)是非常常见和重要的操作。

加密是将明文数据转换为密文数据,以保护数据的安全性。

而解密是将密文数据重新转换为明文数据,以便于使用和理解。

本文将介绍Java中的加密和解密方法,包括常见的加密算法和使用示例。

在Java中,加密和解密操作通常使用加密算法来完成。

常用的加密算法包括对称加密和非对称加密。

对称加密是一种使用同一个密钥进行加密和解密的算法。

常见的对称加密算法有DES(Data Encryption Standard)、AES(Advanced Encryption Standard)等。

其中,AES是目前最常用和最安全的对称加密算法。

对称加密的特点是速度快,但密钥的传输和管理相对较复杂。

非对称加密是一种使用两个不同的密钥进行加密和解密的算法,分别为公钥和私钥。

公钥用于加密数据,私钥用于解密数据。

常见的非对称加密算法有RSA(Rivest-Shamir-Adleman)、DSA(DigitalSignature Algorithm)等。

非对称加密的特点是安全性较高,但速度相对较慢。

下面是一些常用的加密和解密方法的示例:1.对称加密:对称加密的示例中,我们使用AES算法和密钥来加密和解密数据。

```javaimport javax.crypto.Cipher;import javax.crypto.KeyGenerator;import javax.crypto.SecretKey;import java.security.SecureRandom;public class SymmetricEncryptionExample {public static void main(String[] args) throws Exception { //生成AES密钥KeyGenerator keyGenerator =KeyGenerator.getInstance("AES");keyGenerator.init(128, new SecureRandom());SecretKey secretKey = keyGenerator.generateKey();//创建加密和解密的实例Cipher cipher = Cipher.getInstance("AES");//加密数据String plainText = "Hello, World!";cipher.init(Cipher.ENCRYPT_MODE, secretKey);byte[] encryptedText =cipher.doFinal(plainText.getBytes());System.out.println("加密后的数据:" + newString(encryptedText));//解密数据cipher.init(Cipher.DECRYPT_MODE, secretKey);byte[] decryptedText = cipher.doFinal(encryptedText);System.out.println("解密后的数据:" + newString(decryptedText));}}```在上面的示例中,我们首先使用AES算法生成一个128位的密钥。

Java登录密码加密解密代码

Java登录密码加密解密代码
}
return new String(output);
}
}
if(bsh.shared.crypt ==void){
// not yet defined, so create it:
bsh.shared.crypt = new CryptUtil();
}
return hasher.hash().toString();
}
public String sha1(String value) {
Hasher hasher = Hashing.sha1().newHasher();
hasher.putString(value, Charset.forName("UTF-8"));
import mon.hash.Hashing;
public class CryptUtil {
public String md5(String value) {
Hasher hasher = Hashing.md5().newHasher();
hasher.putString(value, Charset.forName("UTF-8"));
cipher.init(Cipher.DECRYPT_MODE, skey);
output = cipher.doFinal(Base64.decodeBase64(input));
} catch (Exception e) {
System.out.println(e.toString());
return hasher.hash().toString();
}
public String base64Encode(String value) {

Java使用Hutool实现AES、DES加密解密的方法

Java使用Hutool实现AES、DES加密解密的方法

Java使⽤Hutool实现AES、DES加密解密的⽅法在Java世界中,AES、DES加密解密需要使⽤Cipher对象构建加密解密系统,Hutool中对这⼀对象做再包装,简化了加密解密过程。

介绍AES和DES同属对称加密算法,数据发信⽅将明⽂(原始数据)和加密密钥⼀起经过特殊加密算法处理后,使其变成复杂的加密密⽂发送出去。

收信⽅收到密⽂后,若想解读原⽂,则需要使⽤加密⽤过的密钥及相同算法的逆算法对密⽂进⾏解密,才能使其恢复成可读明⽂。

在对称加密算法中,使⽤的密钥只有⼀个,发收信双⽅都使⽤这个密钥对数据进⾏加密和解密,这就要求解密⽅事先必须知道加密密钥。

在Java世界中,AES、DES加密解密需要使⽤Cipher对象构建加密解密系统,Hutool中对这⼀对象做再包装,简化了加密解密过程。

引⼊Hutool<dependency><groupId>com.xiaoleilu</groupId><artifactId>hutool-all</artifactId><version>3.0.9</version></dependency>使⽤AES加密解密String content = "test中⽂";//随机⽣成密钥byte[] key = SecureUtil.generateKey(SymmetricAlgorithm.AES.getValue()).getEncoded();//构建AES aes = SecureUtil.aes(key);//加密byte[] encrypt = aes.encrypt(content);//解密byte[] decrypt = aes.decrypt(encrypt);//加密为16进制表⽰String encryptHex = des.encryptHex(content);//解密为原字符串String decryptStr = des.decryptStr(encryptHex);DES加密解密DES的使⽤⽅式与AES基本⼀致String content = "test中⽂";//随机⽣成密钥byte[] key = SecureUtil.generateKey(SymmetricAlgorithm.DES.getValue()).getEncoded();//构建DES des = SecureUtil.des(key);//加密解密byte[] encrypt = des.encrypt(content);byte[] decrypt = des.decrypt(encrypt);//加密为16进制,解密为原字符串String encryptHex = des.encryptHex(content);String decryptStr = des.decryptStr(encryptHex);更多Hutool中针对JDK⽀持的所有对称加密算法做了封装,封装为SymmetricCrypto类,AES和DES两个类是此类的简化表⽰。

java密码加密方法

java密码加密方法

java密码加密方法在现今的网络世界中,安全性是非常重要的一个问题,其中密码的安全性就尤为重要。

许多网站和应用程序都需要用户进行登录,需要输入用户名和密码来验证身份。

但是,用户往往习惯使用简单的密码,如生日、常用英文单词等。

这使得密码的安全性降低了很多,给黑客攻击、身份盗窃等带来了很大的风险。

为了提高密码安全性,需要对密码进行加密。

Java是一种非常流行的编程语言之一,有许多加密方法可以用来加密密码。

本文将介绍Java密码加密的几种方法。

1.MD5加密算法MD5是最常见的一种密码加密算法之一。

它可以将一个明文字符串加密成一个128位的哈希值,通常用32位的十六进制数字表示。

MD5被广泛使用,因为它是一个不可逆的算法,使用同样的密码加密出来的哈希值是唯一的,且不可反向推导出原始字符串。

以下是MD5加密的Java代码示例:```import java.security.MessageDigest;import java.security.NoSuchAlgorithmException;StringBuffer sb = new StringBuffer();for (int i = 0; i < b.length; i++) {int v = b[i] & 0xFF;if (v < 16) {sb.append("0");}sb.append(Integer.toHexString(v));}return sb.toString();}在以上代码中,toMD5方法接受一个明文字符串,返回一个MD5哈希串,可以在一个数据库中保存。

在登陆时,将用户输入的密码进行MD5加密,然后和数据库中的加密串比较,若相等则表示输入的密码是正确的。

需要注意的是,MD5算法虽然被广泛使用,但是安全性并不是十分高,因为它在被攻击时容易被破解。

因此,在一些敏感性较高的场合下,建议使用更加复杂的加密算法,如SHA-1、SHA-256等。

java相关加密解密方法

java相关加密解密方法

java相关加密解密方法Java加密解密方法是保护数据安全的重要手段,本文将详细介绍几种常见的Java加密解密方法。

一、对称加密算法对称加密算法是一种使用相同的密钥进行加密和解密的算法。

这种加密方式简单高效,但存在密钥管理的问题,因为所有用户都必须知道密钥。

在Java中,常用的对称加密算法有DES、3DES、AES等。

1. DES:Data Encryption Standard,数据加密标准,是一种使用56位密钥的对称块密码算法。

在Java中,我们可以使用javax.crypto.Cipher类来实现DES 加密解密。

2. 3DES:Triple Data Encryption Algorithm,三重数据加密算法,是DES的增强版本,使用三个不同的56位密钥进行三次加密。

在Java中,我们同样可以使用Cipher类来实现3DES加密解密。

3. AES:Advanced Encryption Standard,高级加密标准,是一种使用128、192或256位密钥的对称块密码算法。

在Java中,我们可以使用Cipher类来实现AES加密解密。

二、非对称加密算法非对称加密算法是一种使用一对密钥(公钥和私钥)进行加密和解密的算法。

公钥可以公开给所有人,而私钥需要保密。

在Java中,常用的非对称加密算法有RSA、DSA等。

1. RSA:Rivest-Shamir-Adleman,一种基于大数因子分解难题的非对称加密算法。

在Java中,我们可以使用java.security.KeyPairGenerator类生成RSA密钥对,然后使用Cipher类进行RSA加密解密。

2. DSA:Digital Signature Algorithm,数字签名算法,是一种基于整数有限域离散对数难题的非对称加密算法。

在Java中,我们可以使用KeyPairGenerator类生成DSA密钥对,然后使用Signature类进行DSA签名和验证。

密码置换密码实验报告

密码置换密码实验报告

一、实验目的通过本次实验,掌握密码置换密码的原理和方法,学会使用置换密码对信息进行加密和解密,加深对古典密码体系的了解,为后续密码学深入学习奠定基础。

二、实验原理密码置换密码是一种将明文中的字符按照一定的规则进行重新排列的加密方法。

在置换密码中,每个明文字符都映射到另一个字符,明文信息中的字符顺序发生改变,但字符本身并未改变。

常见的置换密码有列置换密码、行置换密码等。

三、实验环境1. 操作系统:Windows 102. 编程语言:Python3.83. 软件环境:PyCharm四、实验内容1. 列置换密码(1)加密过程1)将明文按照密钥长度分成密钥个部分,每个部分长度等于密钥长度。

2)将每个部分按照密钥的顺序进行列置换,即将每个部分中的字符按照密钥的顺序进行重新排列。

3)将列置换后的字符按照密钥的顺序连接起来,形成密文。

(2)解密过程1)将密文按照密钥长度分成密钥个部分,每个部分长度等于密钥长度。

2)将每个部分按照密钥的逆序进行列置换,即将每个部分中的字符按照密钥的逆序进行重新排列。

3)将列置换后的字符按照密钥的逆序连接起来,恢复出明文。

2. 行置换密码(1)加密过程1)将明文按照密钥长度分成密钥个部分,每个部分长度等于密钥长度。

2)将每个部分按照密钥的顺序进行行置换,即将每个部分中的字符按照密钥的顺序进行重新排列。

3)将行置换后的字符按照密钥的顺序连接起来,形成密文。

(2)解密过程1)将密文按照密钥长度分成密钥个部分,每个部分长度等于密钥长度。

2)将每个部分按照密钥的逆序进行行置换,即将每个部分中的字符按照密钥的逆序进行重新排列。

3)将行置换后的字符按照密钥的逆序连接起来,恢复出明文。

五、实验步骤1. 编写列置换密码的加密和解密函数。

2. 编写行置换密码的加密和解密函数。

3. 创建一个明文信息,分别使用列置换密码和行置换密码进行加密和解密操作。

4. 比较加密和解密结果,验证加密和解密函数的正确性。

java后台加密解密方法

java后台加密解密方法

java后台加密解密方法Java后台加密解密方法在当今互联网安全领域中具有重要意义。

为了保护数据的安全,各种加密算法应运而生。

本文将介绍几种常见的Java后台加密解密方法,包括RSA、AES、DES和SM2。

1.RSA加密解密原理及实现RSA是一种非对称加密算法,其公钥和私钥是成对存在的。

使用公钥加密后的数据只能通过私钥进行解密。

在Java中,我们可以使用KeyPairGenerator生成一对公私钥,然后使用RSAPrivateKey对数据进行解密。

2.AES加密解密原理及实现AES是一种对称加密算法,加密和解密过程使用相同的密钥。

在Java中,我们可以使用Java的加密库如Java Cryptography Extension (JCE)实现AES 加密解密。

3.DES加密解密原理及实现DES是一种对称加密算法,其加密过程和解密过程使用不同的密钥。

在Java中,我们可以使用Java Cryptography Extension (JCE)实现DES加密解密。

4.SM2加密解密原理及实现SM2是一种国密算法,具有非对称加密和对称加密的特点。

在前端,我们可以使用SM2加密请求参数,然后在后台使用对应的私钥进行解密。

在Java 中,我们可以使用Hutool库实现SM2加密解密。

5.总结:选择合适的加密解密方法及注意事项在实际应用中,选择合适的加密解密方法至关重要。

需要考虑数据安全性、算法复杂度、性能和兼容性等因素。

此外,还需注意以下几点:- 加密解密算法应根据实际需求进行选择,如对称加密算法适用于加密大量数据,非对称加密算法适用于加密少量数据;- 加密密钥和解密密钥应妥善保管,避免泄露;- 在传输加密数据时,应注意防范中间人攻击,可以使用SSL/TLS等安全协议进行保护;- 定期更新和升级加密算法,以应对潜在的安全威胁。

本文介绍了Java后台加密解密方法,包括RSA、AES、DES和SM2。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
{
int hang=(int)Math.ceil((double)mingwen.length()/(double)key.length());//行数
int lie=key.length();//列数
char[][] juzhen=new char[hang][lie];//定义矩阵存储明文
int temp=0;
for(int j=0;j<lie;j++)//开始第一次转置
for(int i=0;i<hang;i++)
{
mima[i][j]=juzhen[i][a[j]];
}
System.out.print("加密后密码:");
for(int j=0;j<lie;j++)//第二次转置输出结果
{
for(int i=0;i<hang;i++)
{
System.out.print(mima[i][a[j]]);
}
}
}
static void jiemi(String miwen,String key)
{
int hang=(int)Math.ceil((double)miwen.length()/(double)key.length());//
for(int i=0;i<key.length();i++)//将秘钥转ASCII码
{
key_xu[i]=(int)key.charAt(i);
}
Arrays.sort(key_xu); //对秘钥ASCII码进行排序
int[] a=new int[key.length()];//此数组用于记录转换映射
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
public class zhihuan {
public static void main(String args[]) throws IOException{
String key2=br.readLine();
jiemi(MiWen,key2);
System.exit(0);
}
else
{
System.out.println("输入错误,请重新输入,1为加密,2为解密:\n");
System.exit(0);
}
}
static void jiami(String mingwen,String key)
System.out.println("请您输入需要的服务,1为加密,2为解密");
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
int Choice=Integer.parseInt(br.readLine());
{juzhen[i][j]=miwen.charAt(temp);
temp+u=new int[key.length()];//此数组存储秘钥字母顺序
for(int i=0;i<key.length();i++)//将秘钥转ASCII码
{
key_xu[i]=(int)key.charAt(i);
for(int i=0;i<key.length();i++)//利用嵌套循环在数组a中记录转换映射关系
for(int j=0;j<key.length();j++)
{
if( (int)key.charAt(i)==key_xu[j])
{
a[i]=j;
}
}
char[][] mima=new char[hang][lie];//定义第一次转置后的密码矩阵
for(int i=0;i<hang;i++)
{
for(int j=0;j<lie;j++)
{
System.out.print(mingwen[i][j]);
}
}
}
}
{
if( (int)key.charAt(i)==key_xu[j])
{
a[i]=j;
}
}
char[][] ming=new char[hang][lie];//定义第一次转置后的密码矩阵
for(int j=0;j<lie;j++)//开始第一次转置
for(int i=0;i<hang;i++)
{
ming[i][a[j]]=juzhen[i][j];
for(int i=0;i<hang;i++)//嵌套循环将明文存入矩阵
{
for(int j=0;j<lie;j++)
{
if(temp<mingwen.length())
{juzhen[i][j]=mingwen.charAt(temp);
temp++;}
}
}
int[] key_xu=new int[key.length()];//此数组存储秘钥字母顺序
}
char[][] mingwen=new char[hang][lie];
for(int j=0;j<lie;j++)//开始第2次转置
for(int i=0;i<hang;i++)
{
mingwen[i][a[j]]=ming[i][j];
}
System.out.println("解密结果为:");
int lie=key.length();//
char[][] juzhen=new char[hang][lie];
int temp=0;
for(int j=0;j<lie;j++)//嵌套循环将明文存入矩阵
{
for(int i=0;i<hang;i++)
{
if(temp<miwen.length())
if(Choice==1)
{
System.out.println("您进入了加密程序");
System.out.print("请输入您需要加密的明文:");
String MingWen=br.readLine();
System.out.print("请输入加密秘钥:");
String key=br.readLine();
jiami(MingWen,key);
Choice=2;
}
if(Choice==2)
{
System.out.println("您进入了解密程序");
System.out.print("请输入您需要解密的密文:");
String MiWen=br.readLine();
System.out.print("请输入解密秘钥:");
}
Arrays.sort(key_xu); //对秘钥ASCII码进行排序
int[] a=new int[key.length()];//此数组用于记录转换映射
for(int i=0;i<key.length();i++)//利用嵌套循环在数组a中记录转换映射关系
for(int j=0;j<key.length();j++)
相关文档
最新文档