java加解密_java加密解密 - CSDN
精华内容
参与话题
  • java中安全加密/解密

    2019-02-03 20:54:49
    //常见的加密协议 1,base64加密,从现在的加密技术来看,这种加密技术都不好意思说算是加密技术。 2,对称加密(DES):全称:Data Encryption Standard。...优点:计算量小,加密速度快,加密效率高。缺点:很容易被暴力...

    //常见的加密协议
    1,base64加密,从现在的加密技术来看,这种加密技术都不好意思说算是加密技术。

    2,对称加密(DES):全称:Data Encryption Standard。采用单钥密码系统的加密方法,同一个密码可以同时作用信息的加密和解密。解密和解密都是同一个密码,因此传输这个
    密码的过程必须相当安全。优点:计算量小,加密速度快,加密效率高。缺点:很容易被暴力破解

    3,3DES3DES,也就是"triple DES",中文名“三重数据加密算法”,对每一个数据模块应用三次DES加密算法。只是增加了DES的长度来避免暴力破解。并不是全新的算法。

    4,AESAES,全称:Advanced Encryption Standard,中文高级加密标准。非常的强大,是美国的一种区块加密标准。强安全性,高性能,高效率,易用,灵活等

    5,非对称加密。非对称加密方式需要两个密钥来进行加密和解密。分别是公钥和私钥,并且公钥和私钥必须是一对的才能解密,反之,亦然。这是已经是非常安全的加密方式了
    5.1,RSA加密。
    5.2, DH算法。
    5.3, 数字签名证书(更加高级的加密方式)

    实例:
    实现过程:
    生成密钥对->获取公玥->转成PublicKey对象->公玥加密->转成base64码
    生成密钥对->获取私玥->PrivateKey对象->私玥解密->转成bytes

    //RSA加密类RSAUtil
    public class RSAUtil{
    //生成密钥对
    public static KeyPair getKeyPair() throws Exception {
    	KeyPairGenerater keyPairGenerater = new KeyPairGenterater();
    	keyPairGenerater.initialize(2048);
    	KeyPair keyPair = keyPairGenerater.generateKeyPair();
    	return keyPair;
    }
    //获取公钥(base64编码)
    public static String getPublicKey(KeyPair keyPair){
    	PublicKey publicKey =keyPair.getPublic();
    	byte[] bytes = new publicKey.getEncoded();
    	return byte2Base64(bytes);
    }
    //获取私钥(base64编码)
    public static String getPrivateKey(KeyPair keyPair){
    	PrivateKey publicKey =keyPair.getPrivate();
    	byte[] bytes = new publicKey.getEncoded();
    	return byte2Base64(bytes);		
    }
    //将Base64编码后的公钥转换成PublicKey对象
    Public static PublicKey string2PublicKey(String pubstr) throws Exception{
    	byte[] keyBytes = base642Byte(pubstr);
    	X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
    	KeyFactory keyFactory = keyFactory.getInstance("RSA");
    	PublicKey publicKey = keyFacTory.generatePublic(keySpec);
    	return publicKey;
    }
    //将Base64编码后的私钥转换成PrivateKey对象
    Public static PublicKey string2PublicKey(String pubstr) throws Exception{
    	byte[] keyBytes = base642Byte(pubstr);
    	PKCS8EncodeKeySpec keySpec = new PKCS8EncodeKeySpec(keyBytes);
    	KeyFactory keyFactory = keyFactory.getInstance("RSA");
    	PrivateKey privateKey = keyFacTory.generatePrivate(keySpec);
    	return privateKey;
    }
    //公钥加密
    public static byte[] publicEncrypt(byte[] content,PublicKey publicKey) throws Exception{
    	Ciper ciper = Ciper.getInstance("RSA");
    	ciper.init(Ciper.ENCRYPT_MODE,publicKey);
    	byte[] bytes =ciper.doFinal(content);
    	return bytes;
    }
    //私钥解密
    public static byte[] privateEncrypt(byte[] content,PrivateKey privateKey) throws Exception{
    	Ciper ciper = Ciper.getInstance("RSA");
    	ciper.init(Ciper.ENCRYPT_MODE,privateKey);
    	byte[] bytes =ciper.doFinal(content);
    	return bytes;
    }
    //字节数组转Base64编码	
    public static String byte2Base64(byte[] bytes){
    	BASE64Encoder encoder=new BASE64Encoder();
    	return encoder.encode(bytes);
    }
    //Base64编码转字节数组
    public static String Base642byte(String base64Key) throws IOExcption{
    	BASE64Decoder decoder=new BASE64Decoder();
    	return decoder.encode(base64Key);
    }
    

    }

    展开全文
  • Java加解密

    2019-04-18 21:30:56
    概念 当我们传输一些需要保密性的东西的时候往往需要把数据进行加密以增加它的安全性 ...明文:待加密的信息 ...解密密钥:通过解密算法进行解密操作用的密钥 密码分析:截获密文者试图通过分析截获的密文从而推断...

    概念

    当我们传输一些需要保密性的东西的时候往往需要把数据进行加密以增加它的安全性

    密码的常用术语

    明文:待加密的信息
    密文:经过加密后的明文
    加密:明文转换成密文的过程
    加密算法:明文转为密文的转换算法
    加密密钥:通过加密算法进行加密操作用的密钥
    解密:将密文转为明文的过程
    解密算法:密文转为明文的算法
    解密密钥:通过解密算法进行解密操作用的密钥
    密码分析:截获密文者试图通过分析截获的密文从而推断出原来的明文或密钥的过程
    主动攻击:攻击者非法入侵密码系统,采用伪造、修改、删除等手段向系统注入假消息进行欺骗。(对密文具有破坏作用)
    被动攻击:对一个保密系统采取截获密文并对其进行分析和攻击(对密文没有破坏作用)
    密码体制:用明文空间、密文空间、密钥空间、加密算法和解密算法五部分构成。
    密码协议:也称安全协议,指以密码学为基础的消息交换的通信协议,目的是在网络环境中提供安全的服务。
    密码系统:指用于加密、解密的系统。
    柯克霍夫原则:数据的安全基于密钥而不是算法的保密。即系统的安全取决于密钥,对密钥保密,对算法公开。-现代密码学设计的基本原则

    密码分类

    时间上分
    古典密码:以字符为基本加密单元。
    现代密码:以信息块为基本加密单元。
    保密内容上分
    在这里插入图片描述
    密码体制上分
    在这里插入图片描述
    明文处理上分
    分组密码:指加密时将明文分成固定长度的组,用同一密钥和
    算法对每一块加密,输出也是固定长度的密文。多用于网络加
    密。
    流密码:也称序列密码。指加密时每次加密一位或者一个字节明
    文。

    散列函数

    用来验证数据的完整性。
    特点:①长度不受限制
    ②哈希值容易计算
    ③散列运算过程不可逆
    相关的算法:①消息摘要算法MD5
    ②SHA–安全散列算法
    ③MAC–消息认证码算法(MAC–苹果操作系统)

    数字签名

    主要针对以数字的形式存储的消息进行处理

    OSI(Open System Interconnection)

    开发式通信系统。网络通信的OSI的七层通信协议(从1到7):物理层、数据链路层、网络层、传输层、会话层、表示层、应用层。
    在这里插入图片描述

    TCP/IP安全体系

    在这里插入图片描述
    在这里插入图片描述

    Java安全组成

    JCA(Java Cryptography Architecture):提供基本加密的框架,比如:消息摘要、数字签名
    JCE(Java Cryptography Extension):JCA基础上的扩展。如DES、AES、RSA算法
    JSSE(Java Secure Socket Extension):提供基于SSL的加密功能,主要用于网络传输
    JAAS(Java Authentication and Authentication Service):提供来java平台上用户身份验证的功能。就是基于java开发的系统权限或者安全

    相关Java包、类

    java.security:消息摘要
    javax.crypto:安全消息摘要,消息认证(鉴别)码
    java.net.ssl:安全套接字,HttpsURLConnection、SSLContext

    第三方Java扩展

    有两种支持方案
    配置
    在这里插入图片描述
    具体在自己java安装目录下的jdk/jre/lib/security/java.security
    在这里插入图片描述
    这些都是默认的
    调用
    在这里插入图片描述
    在这里插入图片描述

    单向加密

    Base64
    严格意义上来说它不算一个加解密的算法。但是也把它称为初级的、简单的加解密密算法。
    算法的实现
    jdk(不建议使用)

    	private static String src = "java,从入门到放弃";
    	public static void main(String[] args) throws IOException  {
    		 jdkBase64();
    	}
    	
    	public static void jdkBase64() throws IOException {
    		// JDK加密类
    		BASE64Encoder encoder = new BASE64Encoder();
    		String result = encoder.encode(src.getBytes());
    		System.out.println(result);
    		// JDK解密类
    		BASE64Decoder decoder = new BASE64Decoder();
    		String content = new String(decoder.decodeBuffer(result));
    		System.out.println(content);
    	}
    

    结果:
    在这里插入图片描述
    奇葩情况:可能会出现编译器无法找到这个类。这个问题就是右键项目进入libraries
    在这里插入图片描述
    点击红线处,添加如图
    在这里插入图片描述
    Commons Codec

    public static void commonsCodesBase64() {
    		byte[] b = Base64.encodeBase64(src.getBytes());
    		System.out.println(new String(b));
    		byte[] b1 = Base64.decodeBase64(b);
    		System.out.println(new String(b1));
    	}
    

    结果:
    在这里插入图片描述
    Bouncy Castle

    public static void bouncyCastleBase64() {
    		byte[] b = org.bouncycastle.util.encoders.Base64.encode(src.getBytes());
    		System.out.println(new String(b));
    		byte[] b1 = org.bouncycastle.util.encoders.Base64.decode(b);
    		System.out.println(new String(b1));
    	}
    

    结果:
    在这里插入图片描述
    该算法的应用场景
    e-mail、密钥、证书文件

    消息摘要算法

    其作用验证数据的完整性(下载的文件,可以根据下载文件生成消息摘要跟下载处进行对比来判断文件是否完整),也是数字签名核心算法。下列列举3个算法
    MD(Message Digest):消息摘要
    生成的消息摘要都是128位摘要信息(MD2、MD4、MD5)
    在这里插入图片描述

    public class TestMD {
    	private static String src = "java,从入门到放弃";
    	public static void main(String[] args)  {
    		
    		  jdkMD5(); 
    		  jdkMD2();
    		  bcMD4(); 
    		  bcMD5();
    		ccMD5();
    		ccMD2();
    	}
    	
    	public static void jdkMD5() {
    		try {
    			MessageDigest md = MessageDigest.getInstance("MD5");
    			byte[] b = md.digest(src.getBytes());
    			System.out.println("JDKMD5 : "+new String(b));
    			// JDK的MD5是不完善的,它没有把byte数组转成十六进制,所以我们需要自己写一个十六进制解析或者借助第三方工具
    			// 这里我用阿帕奇的hex
    			System.out.println("JDKMD5 : "+Hex.encodeHexString(b));
    			
    		} catch (NoSuchAlgorithmException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}	
    		
    	}
    	public static void jdkMD2() {
    		try {
    			MessageDigest md = MessageDigest.getInstance("MD2");
    			byte[] b = md.digest(src.getBytes());
    			System.out.println("JDKMD2 : "+new String(b));
    			// JDK的MD5是不完善的,它没有把byte数组转成十六进制,所以我们需要自己写一个十六进制解析或者借助第三方工具
    			System.out.println("JDKMD2 : "+Hex.encodeHexString(b));
    			
    		} catch (NoSuchAlgorithmException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}	
    		
    	}
    	public static void bcMD5() {
    		Digest digest = new MD5Digest();
    		digest.update(src.getBytes(),0,src.length());
    	    byte[] result = new byte[digest.getDigestSize()];
    		digest.doFinal(result, 0);
    		System.out.println("MD5 : "+org.bouncycastle.util.encoders.Hex.toHexString(result));
    	}
    	public static void bcMD4(){
    		Digest digest = new MD4Digest();
    		digest.update(src.getBytes(),0,src.length());
    	    byte[] result = new byte[digest.getDigestSize()];
    		digest.doFinal(result, 0);
    		System.out.println("MD4 : "+org.bouncycastle.util.encoders.Hex.toHexString(result));
    	}
    	public static void ccMD5() {
    		System.out.println("ccMD5 : "+DigestUtils.md5Hex(src.getBytes()));
    	}
    	public static void ccMD2() {
    		System.out.println("ccMD2 : "+DigestUtils.md2Hex(src.getBytes()));
    	}
    	//从结果发现其实cc的MD5和cc的MD2只是简化的JDK的操作,也是就解释了为什么cc没有MD4
    }
    

    结果:
    在这里插入图片描述
    该算法的应用场景
    在这里插入图片描述
    这个过程是当用户名注册账号的时候把密码进行加密生成十六进制的摘要。而数据库所存的是用户名明文,密码则是密文。
    当然有人会问密码是密文怎么登陆
    在这里插入图片描述
    那当然密码去查询之前也需要加密成摘要,相同内容其摘要是相同的
    SHA(Secure Hash Algorithm):安全散列算法
    与MD5一样固定长度摘要信息,从MD4基础上演变而来。有SHA-1、SHA-2(SHA-224、SHA-256、SHA-384、SHA-512)等五种。
    在这里插入图片描述

    public class TestSHA {
    	private static String src = "java,从入门到放弃"; 
    	public static void main(String[] args)  {
    		jdkSHA1();
    		bcSHA1();
    		bcSHA224();
    		 ccSHA1();
    	}
    	public static void jdkSHA1(){
    		try {
    			MessageDigest md  = MessageDigest.getInstance("SHA");
    			byte[] b= md.digest(src.getBytes());
    			System.out.println("JDK SHA-1 : "+Hex.encodeHexString(b));
    		} catch (NoSuchAlgorithmException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    	public static void bcSHA1() {
    		Digest digest = new SHA1Digest();
    		digest.update(src.getBytes(),0,src.length());
    	    byte[] result = new byte[digest.getDigestSize()];
    		digest.doFinal(result, 0);
    		System.out.println("BC SHA-1 : "+org.bouncycastle.util.encoders.Hex.toHexString(result));
    	}
    	
    	public static void bcSHA224() {
    		Digest digest = new SHA224Digest();
    		digest.update(src.getBytes(),0,src.length());
    	    byte[] result = new byte[digest.getDigestSize()];
    		digest.doFinal(result, 0);
    		System.out.println("BC SHA-224 : "+org.bouncycastle.util.encoders.Hex.toHexString(result));
    	}
    	
    	
    	public static void ccSHA1() {
    		System.out.println("cc SHA-1 : "+DigestUtils.sha1Hex(src.getBytes()));
    	}
    }
    
    

    结果:
    在这里插入图片描述
    该算法的使用
    在这里插入图片描述
    防止消息被篡改。当接受到的消息经过算法加密后是否与发送方发送的摘要一致,一致则表示信息完整未被篡改。
    在这里插入图片描述
    MAC(Message Authentication Code):消息认证码算法
    HMAC(keyed-Hash Message Authentication Code),含有密钥的散列函数算法
    是一种含有密钥、散列函数的算法。兼容了MD和SHA两种的特性
    融合MD、SHA
    – MD系列:HmacMD2、HmacMD4、HmacMD5

    –SHA系列:HmacSHA1、HmacSHA224、HmacSHA256、HmacSHA384、HmacSHA512
    在这里插入图片描述

    public class TestMAC {
    	private static String src = "java,从入门到放弃"; 
    	public static void main(String[] args) throws InvalidKeyException, NoSuchAlgorithmException {
    		 jdkHmacMD5();
    		 bcHmacMD5() ;
    	}
    	public static void jdkHmacMD5() throws NoSuchAlgorithmException, InvalidKeyException {
    		
    			// 初始化密钥工厂
    			KeyGenerator keyGenerator = KeyGenerator.getInstance("HmacMD5");
    			// 产生密钥
    			SecretKey sk = keyGenerator.generateKey();
    			// 获得密钥
    			byte[] b = sk.getEncoded();
    			
    			// 还原密钥
    			SecretKey rsk = new SecretKeySpec(b,"HmacMD5");
    			// 实例化MAC
    			Mac mac = Mac.getInstance(rsk.getAlgorithm());
    			// 初始化MAC
    			mac.init(rsk);
    			// 执行摘要
    			byte[] result = mac.doFinal(src.getBytes());
    			System.out.println("JDK hmacMD5 : "+Hex.encodeHexString(result));
    		
    	}
    	public static void bcHmacMD5() {
    		HMac hmac = new HMac(new MD5Digest());
    		// org.bouncycastle.util.encoders.Hex.decode("aaaaaaaaaa")相当于设置密钥过程
    	    hmac.init(new KeyParameter(org.bouncycastle.util.encoders.Hex.decode("aaaaaaaaaa")));
    	    hmac.update(src.getBytes(),0,src.getBytes().length);
    	    byte[] result = new byte[hmac.getMacSize()];
    	    hmac.doFinal(result, 0);
    	    System.out.println("bc HmacMD5 : "+org.bouncycastle.util.encoders.Hex.toHexString(result));
     	}
    }
    
    

    结果:
    在这里插入图片描述
    该算法应用场景:
    在这里插入图片描述

    Java对称加密算法

    常用的对称加密算法DES(由于长度不够衍生了3DES)、AES、PBE、IDEA。
    DES(Data Encryption Standard):数据加密标准
    (已经被破解,所以基本没人使用)
    在这里插入图片描述

    public class TestSymmetric {
    	private static String src = "java,从入门到放弃"; 
    	public static void main(String[] args) throws Exception {
    		jdkDES();
    		bcDES();
    	}
    	public static void jdkDES() throws Exception {
    		// 生成key
    		KeyGenerator keyGenerator = KeyGenerator.getInstance("DES");
    		System.out.println(keyGenerator.getProvider());
    		// 生成56位
    		keyGenerator.init(56);
    		SecretKey sk1 = keyGenerator.generateKey();
    		byte[] bytesKey = sk1.getEncoded();
    		// key转换
    		DESKeySpec desKeySpec = new DESKeySpec(bytesKey);
    	    SecretKeyFactory skf = SecretKeyFactory.getInstance("DES");
    	    Key sk2 = skf.generateSecret(desKeySpec);
    	    
    	    //加密
    	    //分别是加密算法、加密模式、填充方式
    	    Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
    	    //Cipher.ENCRYPT_MODE 加密模式
    	    cipher.init(Cipher.ENCRYPT_MODE, sk2);
    	    byte[] result = cipher.doFinal(src.getBytes());
    	    System.out.println("JDK DES 加密结果: "+Hex.encodeHexString(result));
    	    
    	    
    	    // 解密操作
    	    // Cipher.DECRYPT_MODE解密模式
    	    cipher.init(Cipher.DECRYPT_MODE,sk2);
    	    result = cipher.doFinal(result);
    	    System.out.println("JDK DES 解密结果: "+new String(result));
    	}
    	
    	public static void bcDES() throws Exception  {
    		Security.addProvider(new BouncyCastleProvider());
    		KeyGenerator keyGenerator = KeyGenerator.getInstance("DES","BC");
    		System.out.println(keyGenerator.getProvider());
    		// 生成56位
    		keyGenerator.init(56);
    		SecretKey sk1 = keyGenerator.generateKey();
    		byte[] bytesKey = sk1.getEncoded();
    		// key转换
    		DESKeySpec desKeySpec = new DESKeySpec(bytesKey);
    	    SecretKeyFactory skf = SecretKeyFactory.getInstance("DES");
    	    Key sk2 = skf.generateSecret(desKeySpec);
    	    
    	    //加密
    	    //分别是加密算法、加密模式、填充方式
    	    Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
    	    //Cipher.ENCRYPT_MODE 加密模式
    	    cipher.init(Cipher.ENCRYPT_MODE, sk2);
    	    byte[] result = cipher.doFinal(src.getBytes());
    	    System.out.println("BC DES 加密结果: "+Hex.encodeHexString(result));
    	    
    	    
    	    // 解密操作
    	    // Cipher.DECRYPT_MODE解密模式
    	    cipher.init(Cipher.DECRYPT_MODE,sk2);
    	    result = cipher.doFinal(result);
    	    System.out.println("BC DES 解密结果: "+new String(result));
    	}
    }
    
    

    结果:
    在这里插入图片描述
    应用
    在这里插入图片描述
    3重DES
    因为DES违反了柯克霍夫原则及安全等问题衍生出来的。
    好处:1、密钥长度增强
    2、迭代次数提高
    在这里插入图片描述

    public static void jdk3DES() throws Exception {
    		// 生成key
    				KeyGenerator keyGenerator = KeyGenerator.getInstance("DESede");
    				System.out.println(keyGenerator.getProvider());
    				keyGenerator.init(168);
    				SecretKey sk1 = keyGenerator.generateKey();
    				byte[] bytesKey = sk1.getEncoded();
    				// key转换
    				DESedeKeySpec desKeySpec = new DESedeKeySpec(bytesKey);
    			    SecretKeyFactory skf = SecretKeyFactory.getInstance("DESede");
    			    Key sk2 = skf.generateSecret(desKeySpec);
    			    
    			    //加密
    			    //分别是加密算法、加密模式、填充方式
    			    Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");
    			    //Cipher.ENCRYPT_MODE 加密模式
    			    cipher.init(Cipher.ENCRYPT_MODE, sk2);
    			    byte[] result = cipher.doFinal(src.getBytes());
    			    System.out.println("JDK 3DES 加密结果: "+Hex.encodeHexString(result));
    			    
    			    
    			    // 解密操作
    			    // Cipher.DECRYPT_MODE解密模式
    			    cipher.init(Cipher.DECRYPT_MODE,sk2);
    			    result = cipher.doFinal(result);
    			    System.out.println("JDK 3DES 解密结果: "+new String(result));
    	}
    

    结果:
    在这里插入图片描述
    AES(目前使用最多的对称加密算法)
    DES安全有问题,3重DES则效率低下,AES目前为止官方报道并未被破解,AES通常用于移动通信系统加密以及基于SSH协议的软件,如:SSH Client、secureCRT
    在这里插入图片描述

    public class TestAES {
    	private static String src = "java,从入门到放弃"; 
    	public static void main(String[] args) throws Exception {
    		jdkAES();
    	}
    	public static void jdkAES() throws Exception {
    		//生成key
    		KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
    		keyGenerator.init(128);
    		SecretKey sk = keyGenerator.generateKey();
    		byte[] keyBytes = sk.getEncoded();
    		//key转换
    		Key key =  new SecretKeySpec(keyBytes, "AES");
    		//加密
    		Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
    		cipher.init(Cipher.ENCRYPT_MODE, key);
    		byte[] result = cipher.doFinal(src.getBytes());
    		 System.out.println("JDK AES 加密结果:"+Base64.encodeBase64String(result)); 
    		System.out.println("JDK AES 加密结果:"+Hex.encodeHexString(result));
    		//解密
    		cipher.init(Cipher.DECRYPT_MODE, key);
    		result = cipher.doFinal(result);
    		System.out.println("JDK AES 解密结果:"+new String(result));
    	}
    }
    
    

    结果:
    在这里插入图片描述
    应用:
    在这里插入图片描述
    PBE算法(Password Based Encryption基于口令的加密)
    结合了消息摘要算法和对称加密算法的优点
    在这里插入图片描述
    在这里插入图片描述

    public class TestPBE {
    	private static String src = "java,从入门到放弃"; 
    	public static void main(String[] args) throws Exception {
    		jdkPBE();
    	}
    	public static void jdkPBE() throws Exception {
    		//初始化盐,盐就是加密要用的随机数随机条件
    		SecureRandom random = new SecureRandom();
    		byte[] salt = random.generateSeed(8);
    		//口令与密钥
    		String password = "tiger";
    		PBEKeySpec pbeKeySpec = new PBEKeySpec(password.toCharArray());
    		SecretKeyFactory skf = SecretKeyFactory.getInstance("PBEWITHMD5andDES");
    		Key key = skf.generateSecret(pbeKeySpec);
    		//加密
    		// 参数1为盐,参数2位迭代次数
    		PBEParameterSpec pbeParameterSpec = new PBEParameterSpec(salt, 100);
    		Cipher cipher = Cipher.getInstance("PBEWITHMD5andDES");
    		cipher.init(Cipher.ENCRYPT_MODE, key,pbeParameterSpec);
    		byte[] result = cipher.doFinal(src.getBytes());
    		System.out.println("jdk pbe 加密  : "+Base64.encodeBase64String(result));
    		System.out.println("jdk pbe 加密  : "+Hex.encodeHexString(result));
    		//解密
    		cipher.init(Cipher.DECRYPT_MODE,key, pbeParameterSpec);
    		result = cipher.doFinal(result);
    		System.out.println("jdk pbe 解密  : "+new String(result));
    	}
    }
    
    

    结果:
    在这里插入图片描述
    应用:
    在这里插入图片描述

    展开全文
  • Java实现DES加密解密

    万次阅读 2018-11-09 16:27:01
    DES(Data Encryption Standard)是一种对称加密算法,所谓对称加密就是加密和解密都是使用同一个密钥。 加密原理: DES 使用一个 56 位的密钥以及附加的 8 位奇偶校验位,产生最大 64 位的分组大小。这是一个迭代的...

    DES(Data Encryption Standard)是一种对称加密算法,所谓对称加密就是加密和解密都是使用同一个密钥

    加密原理:

    DES 使用一个 56 位的密钥以及附加的 8 位奇偶校验位,产生最大 64 位的分组大小。这是一个迭代的分组密码,使用称为 Feistel 的技术,其中将加密的文本块分成两半。使用子密钥对其中一半应用循环功能,然后将输出与另一半进行"异或"运算;接着交换这两半,这一过程会继续下去,但最后一个循环不交换。DES 使用 16 个循环,使用异或,置换,代换,移位操作四种基本运算。

    不过,DES已可破解,所以针对保密级别特别高的数据推荐使用非对称加密算法。

    下面介绍基于Java实现的DES加解密方法,该方法同样适用于Android平台,使用的是JDK1.8。

    public class DESUtil {
    
        /**
         * 偏移变量,固定占8位字节
         */
        private final static String IV_PARAMETER = "12345678";
        /**
         * 密钥算法
         */
        private static final String ALGORITHM = "DES";
        /**
         * 加密/解密算法-工作模式-填充模式
         */
        private static final String CIPHER_ALGORITHM = "DES/CBC/PKCS5Padding";
        /**
         * 默认编码
         */
        private static final String CHARSET = "utf-8";
    
        /**
         * 生成key
         *
         * @param password
         * @return
         * @throws Exception
         */
        private static Key generateKey(String password) throws Exception {
            DESKeySpec dks = new DESKeySpec(password.getBytes(CHARSET));
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
            return keyFactory.generateSecret(dks);
        }
    
    
        /**
         * DES加密字符串
         *
         * @param password 加密密码,长度不能够小于8位
         * @param data 待加密字符串
         * @return 加密后内容
         */
        public static String encrypt(String password, String data) {
            if (password== null || password.length() < 8) {
                throw new RuntimeException("加密失败,key不能小于8位");
            }
            if (data == null)
                return null;
            try {
                Key secretKey = generateKey(password);
                Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
                IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));
                cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);
                byte[] bytes = cipher.doFinal(data.getBytes(CHARSET));
    
                //JDK1.8及以上可直接使用Base64,JDK1.7及以下可以使用BASE64Encoder
                //Android平台可以使用android.util.Base64
                return new String(Base64.getEncoder().encode(bytes));
    
            } catch (Exception e) {
                e.printStackTrace();
                return data;
            }
        }
    
        /**
         * DES解密字符串
         *
         * @param password 解密密码,长度不能够小于8位
         * @param data 待解密字符串
         * @return 解密后内容
         */
        public static String decrypt(String password, String data) {
            if (password== null || password.length() < 8) {
                throw new RuntimeException("加密失败,key不能小于8位");
            }
            if (data == null)
                return null;
            try {
                Key secretKey = generateKey(password);
                Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
                IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));
                cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);
                return new String(cipher.doFinal(Base64.getDecoder().decode(data.getBytes(CHARSET))), CHARSET);
            } catch (Exception e) {
                e.printStackTrace();
                return data;
            }
        }
    
        /**
         * DES加密文件
         *
         * @param srcFile  待加密的文件
         * @param destFile 加密后存放的文件路径
         * @return 加密后的文件路径
         */
        public static String encryptFile(String password, String srcFile, String destFile) {
    
            if (password== null || password.length() < 8) {
                throw new RuntimeException("加密失败,key不能小于8位");
            }
            try {
                IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));
                Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
                cipher.init(Cipher.ENCRYPT_MODE, generateKey(key), iv);
                InputStream is = new FileInputStream(srcFile);
                OutputStream out = new FileOutputStream(destFile);
                CipherInputStream cis = new CipherInputStream(is, cipher);
                byte[] buffer = new byte[1024];
                int r;
                while ((r = cis.read(buffer)) > 0) {
                    out.write(buffer, 0, r);
                }
                cis.close();
                is.close();
                out.close();
                return destFile;
            } catch (Exception ex) {
                ex.printStackTrace();
            }
            return null;
        }
    
        /**
         * DES解密文件
         *
         * @param srcFile  已加密的文件
         * @param destFile 解密后存放的文件路径
         * @return 解密后的文件路径
         */
        public static String decryptFile(String password, String srcFile, String destFile) {
            if (password== null || password.length() < 8) {
                throw new RuntimeException("加密失败,key不能小于8位");
            }
            try {
                File file = new File(destFile);
                if (!file.exists()) {
                    file.getParentFile().mkdirs();
                    file.createNewFile();
                }
                IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes(CHARSET));
                Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
                cipher.init(Cipher.DECRYPT_MODE, generateKey(key), iv);
                InputStream is = new FileInputStream(srcFile);
                OutputStream out = new FileOutputStream(destFile);
                CipherOutputStream cos = new CipherOutputStream(out, cipher);
                byte[] buffer = new byte[1024];
                int r;
                while ((r = is.read(buffer)) >= 0) {
                    cos.write(buffer, 0, r);
                }
                cos.close();
                is.close();
                out.close();
                return destFile;
            } catch (Exception ex) {
                ex.printStackTrace();
            }
            return null;
        }
    }
    

     

    展开全文
  • Java-数据加解密实现

    千次阅读 2018-08-30 14:20:11
    (1)对称加密:即加密与解密用的是同一把秘钥,常用的对称加密技术有DES、AES等。 (2)非对称加密:加密与解密用的是不同的秘钥,常用的非对称加密技术有RSA等。 为什么要有非对称加密、解密技术呢? 假设这样一...

    序言

    注意:强烈建议阅读本文之前,先行阅读下面这篇文章,建立对密码学技术体系的整体认知:
    https://blog.csdn.net/weixin_39190897/article/details/82223408

    先来一个故事(可粗略理解 数字签名、散列函数、证书机构、非对称加密、公私密钥 等密码学技术的应用)~

    假如A授权B的一段代码dmk可以访问A的系统,一个坏蛋C也想要访问A的系统做一些坏事,但是C没有的到A的授权,那么A怎么知道dmk就是dmk呢,是这样做的B通过dmk生成一个散列值,然后将这个散列值追加到代码尾部传送给A,A拿到这个信息后将代码和散列分开,然后A用和B相同的算法也计算出散列值,用计算出的散列值和B传过来的散列值比较如果相等就证明这段代码是dmk。现在坏蛋要和B斗志斗勇了!!!
    这里写图片描述
    解密过程:
    这里写图片描述
    好戏开始~
    这里写图片描述

    加密技术

    加密技术大体上分为 双向加密单向加密 ,而双向加密又分为 对称加密 和非对称加密(有些资料将加密直接分为对称加密和非对称加密)。

    双向加密即明文加密后形成的密文,可以通过逆向算法还原出明文。而单向加密只是对信息进行了摘要计算,不能通过算法逆向生成明文。

    单向加密技术采用单向散列函数(或称为哈希(Hash)函数/散列函数),可将任意长度的消息散列形成固定长度的散列值(即消息摘要),用于被用户私钥加密后生成数字签名,保证数据的完整性和不可否认性。

    单向加密从严格意思上说不能算是加密的一种,而只是摘要算法,常见的单向加密技术有BASE64(一种编码形式)MD5SHAHMAC(消息认证码)

    双向加密技术可以分为 对称加密非对称加密 两种。
    y

    (1)对称加密:即加密与解密用的是同一把秘钥,常用的对称加密技术有DES、AES等。
    (2)非对称加密:加密与解密用的是不同的秘钥,常用的非对称加密技术有RSA等。

    为什么要有非对称加密、解密技术呢?

    假设这样一种场景A要发送一段消息给B,但是又不想以明文发送,所以就需要对消息进行加密。如果采用对称加密技术,那么加密与解密用的是同一把秘钥。除非B事先就知道A的秘钥,并且保存好,这样才可以解密A发来的消息。

    由于对称技术只有一把秘钥,所以秘钥的管理是一个很麻烦的问题。而非对称技术的诞生就解决了这个问题。非对称加密与解密使用的是不同的秘钥,并且秘钥对是一一对应的,即用A的私钥加密的密文只有用A的公钥才能解密。

    这样的话,每个人都有两把秘钥,私钥和公钥,私钥是只有自己才知道的,不能告诉别人,而公钥是公开的,大家都可以知道。这样,当A想要发送消息给B的时候,只需要用B的公钥对消息进行加密就可以了,由于B的私钥只有B才拥有,所以A用B的公钥加密的消息只有B才能解开。而B想更换自己的密钥时也很方便,只须把公钥告诉大家就可以了。

    那么,既然非对称加密如此之好,对称加密就没有存在的必要了啊,其实不然,由于非对称加密算法的开销很大,所以如果直接以非对称技术来加密发送的消息效率会很差。那么怎么办呢?解决的办法也很简单,就是把对称加密技术与非对称加密技术结合起来使用。

    举个例子:

    假如A要发送一个消息给B,对于发送方的A:
    
    (1) A先生成一个对称秘钥,这个秘钥可以是随机生成的;
    
    (2) A用B的公钥加密第一步生成的这个对称秘钥;
    
    (3) A把加密过的对称秘钥发给B;
    
    (4) A用第一步生成的这个对称秘钥加密实际要发的消息;
    
    (5) A把用对称秘钥加密的消息发给B.
    对于接收方B:1)他先收到A发来的对称秘钥,这个秘钥是用B的公钥加密过的,所以B需要用自己的私钥来解密这个秘钥
    
    (2)然后B又收到A发来的密文,这时候用刚才解密出来的秘钥来解密密文

    这样子的整个过程既保证了安全,又保证了效率.


    Java 对称加密

    采用单钥密码系统的加密方法,同一个密钥可以同时用作信息的加密和解密,这种加密方法称为对称加密,也称为单密钥加密。

    需要对加密和解密使用相同密钥的加密算法。由于其速度,对称性加密通常在消息发送方需要加密大量数据时使用。

    对称加密一般java类中中定义成员:

    //KeyGenerator 提供对称密钥生成器的功能,支持各种算法
    private KeyGenerator keygen;
    //SecretKey 负责保存对称密钥
    private SecretKey deskey;
    //Cipher负责完成加密或解密工作
    private Cipher c;
    //该字节数组负责保存加密的结果
    private byte[] cipherByte;

    1、DES算法

    DES是1977年美国联邦信息处理标准中使用的一种对称密码技术,曾今被美国和其他国家政府银行使用。

    不过现在已被暴力破解,不再安全可靠,我们除了用它解密以前的密文外,已不再使用DES了。

    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    import java.security.Security;
    
    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import javax.crypto.KeyGenerator;
    import javax.crypto.NoSuchPaddingException;
    import javax.crypto.SecretKey;
    
    public class EncrypDES {
    
        //KeyGenerator 提供对称密钥生成器的功能,支持各种算法
        private KeyGenerator keygen;
        //SecretKey 负责保存对称密钥
        private SecretKey deskey;
        //Cipher负责完成加密或解密工作
        private Cipher c;
        //该字节数组负责保存加密的结果
        private byte[] cipherByte;
    
        /**
          * 构造函数,完成所需变量的初始化
          */
        public EncrypDES() throws NoSuchAlgorithmException, NoSuchPaddingException{
            //实例化支持DES算法的密钥生成器(算法名称命名需按规定,否则抛出异常)
            keygen = KeyGenerator.getInstance("DES");
            //生成密钥
            deskey = keygen.generateKey();
            //生成Cipher对象,指定其支持的DES算法
            c = Cipher.getInstance("DES");
        }
    
        /**
         * 对字符串加密
         */
        public byte[] Encrytor(String str) throws InvalidKeyException,
                IllegalBlockSizeException, BadPaddingException {
            // 根据密钥,对Cipher对象进行初始化,ENCRYPT_MODE表示加密模式
            c.init(Cipher.ENCRYPT_MODE, deskey);
            byte[] src = str.getBytes();
            // 加密,结果保存进cipherByte
            cipherByte = c.doFinal(src);
            return cipherByte;
        }
    
        /**
         * 对字符串解密
         */
        public byte[] Decryptor(byte[] buff) throws InvalidKeyException,
                IllegalBlockSizeException, BadPaddingException {
            // 根据密钥,对Cipher对象进行初始化,DECRYPT_MODE表示加密模式
            c.init(Cipher.DECRYPT_MODE, deskey);
            cipherByte = c.doFinal(buff);
            return cipherByte;
        }
    
        /**
         * 主函数,执行加解密测试
         */
        public static void main(String[] args) throws Exception {
            EncrypDES de1 = new EncrypDES();
            String msg ="You are not alone.";
            byte[] encontent = de1.Encrytor(msg);
            byte[] decontent = de1.Decryptor(encontent);
            System.out.println("明文是:" + msg);
            System.out.println("加密后:" + new String(encontent));
            System.out.println("解密后:" + new String(decontent));
        }
    
    }

    执行结果:

    明文是:You are not alone.
    加密后:�����e�]r�.��@:ak��d
    解密后:You are not alone.

    2、3DES

    数据加密标准(DES)是美国的一种由来已久的加密标准,它使用对称密钥加密法.。比起最初的DES,3DES更为安全。3DES是DES加密算法的一种模式,它使用3条56位的密钥对3DES数据进行三次加密。 其具体实现如下:
    这里写图片描述
    设Ek()和Dk()代表DES算法的加密和解密过程,K代表DES算法使用的密钥,P代表明文,C代表密文,这样,   

    3DES加密过程为:C=Ek3(Dk2(Ek1(P)))
    3DES解密过程为:P=Dk1((EK2(Dk3(C))) 

    Java代码:

    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    import java.security.Security;
    
    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import javax.crypto.KeyGenerator;
    import javax.crypto.NoSuchPaddingException;
    import javax.crypto.SecretKey;
    
    public class EncrypDES3 {
    
        // KeyGenerator 提供对称密钥生成器的功能,支持各种算法
        private KeyGenerator keygen;
        // SecretKey 负责保存对称密钥
        private SecretKey deskey;
        // Cipher负责完成加密或解密工作
        private Cipher c;
        // 该字节数组负责保存加密的结果
        private byte[] cipherByte;
    
        public EncrypDES3() throws NoSuchAlgorithmException, NoSuchPaddingException {
            // 实例化支持DES算法的密钥生成器(算法名称命名需按规定,否则抛出异常)
            keygen = KeyGenerator.getInstance("DESede");
            // 生成密钥
            deskey = keygen.generateKey();
            // 生成Cipher对象,指定其支持的DES算法
            c = Cipher.getInstance("DESede");
        }
    
        /**
         * 对字符串加密
         */
        public byte[] Encrytor(String str) throws InvalidKeyException,
                IllegalBlockSizeException, BadPaddingException {
            // 根据密钥,对Cipher对象进行初始化,ENCRYPT_MODE表示加密模式
            c.init(Cipher.ENCRYPT_MODE, deskey);
            byte[] src = str.getBytes();
            // 加密,结果保存进cipherByte
            cipherByte = c.doFinal(src);
            return cipherByte;
        }
    
        /**
         * 对字符串解密
         */
        public byte[] Decryptor(byte[] buff) throws InvalidKeyException,
                IllegalBlockSizeException, BadPaddingException {
            // 根据密钥,对Cipher对象进行初始化,DECRYPT_MODE表示加密模式
            c.init(Cipher.DECRYPT_MODE, deskey);
            cipherByte = c.doFinal(buff);
            return cipherByte;
        }
    
        /**
         * 主函数
         */
        public static void main(String[] args) throws Exception {
            EncrypDES3 des = new EncrypDES3();
            String msg ="You are not alone.";
            byte[] encontent = des.Encrytor(msg);
            byte[] decontent = des.Decryptor(encontent);
            System.out.println("明文是:" + msg);
            System.out.println("加密后:" + new String(encontent));
            System.out.println("解密后:" + new String(decontent));
    
        }
    
    }

    3、AES

    AES密码学中的高级加密标准(Advanced Encryption Standard,AES),又称 高级加密标准Rijndael加密法,是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES,已经被多方分析且广为全世界所使用。

    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    import java.security.Security;
    
    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import javax.crypto.KeyGenerator;
    import javax.crypto.NoSuchPaddingException;
    import javax.crypto.SecretKey;
    
    public class EncrypAES {
    
        //KeyGenerator 提供对称密钥生成器的功能,支持各种算法
        private KeyGenerator keygen;
        //SecretKey 负责保存对称密钥
        private SecretKey deskey;
        //Cipher负责完成加密或解密工作
        private Cipher c;
        //该字节数组负责保存加密的结果
        private byte[] cipherByte;
    
        public EncrypAES() throws NoSuchAlgorithmException, NoSuchPaddingException{
            Security.addProvider(new com.sun.crypto.provider.SunJCE());
            //实例化支持DES算法的密钥生成器(算法名称命名需按规定,否则抛出异常)
            keygen = KeyGenerator.getInstance("AES");
            //生成密钥
            deskey = keygen.generateKey();
            //生成Cipher对象,指定其支持的DES算法
            c = Cipher.getInstance("AES");
        }
    
        /**
         * 对字符串加密
         */
        public byte[] Encrytor(String str) throws InvalidKeyException,
                IllegalBlockSizeException, BadPaddingException {
            // 根据密钥,对Cipher对象进行初始化,ENCRYPT_MODE表示加密模式
            c.init(Cipher.ENCRYPT_MODE, deskey);
            byte[] src = str.getBytes();
            // 加密,结果保存进cipherByte
            cipherByte = c.doFinal(src);
            return cipherByte;
        }
    
        /**
         * 对字符串解密
         */
        public byte[] Decryptor(byte[] buff) throws InvalidKeyException,
                IllegalBlockSizeException, BadPaddingException {
            // 根据密钥,对Cipher对象进行初始化,DECRYPT_MODE表示加密模式
            c.init(Cipher.DECRYPT_MODE, deskey);
            cipherByte = c.doFinal(buff);
            return cipherByte;
        }
    
        /**
         * 主函数
         */
        public static void main(String[] args) throws Exception {
            EncrypAES de1 = new EncrypAES();
            String msg ="You are not alone.";
            byte[] encontent = de1.Encrytor(msg);
            byte[] decontent = de1.Decryptor(encontent);
            System.out.println("明文是:" + msg);
            System.out.println("加密后:" + new String(encontent));
            System.out.println("解密后:" + new String(decontent));
        }
    
    }

    Java 非对称加密

    1976年,美国学者Dime和Henman为解决信息公开传送和密钥管理问题,提出一种新的密钥交换协议,允许在不安全的媒体上的通讯双方交换信息,安全地达成一致的密钥,这就是“公开密钥系统”。相对于“对称加密算法”这种方法也叫做“非对称加密算法”。 与对称加密算法不同,非对称加密算法需要两个密钥:公开密钥(publickey)和私有密钥 (privatekey)。公开密钥与私有密钥是一对,如果用公开密钥对数据进行加密,只有用对应的私有密钥才能解密;如果用私有密钥对数据进行加密,那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥,所以这种算法叫作非对称加密算法。

    RSA

    RSA 公钥加密算法是1977年由Ron Rivest、Adi Shamirh和LenAdleman在(美国麻省理工学院)开发的。RSA取名来自开发他们三者的名字。RSA是目前最有影响力的公钥加密算法,它能够抵抗到目前为止已知的所有密码攻击,已被ISO推荐为公钥数据加密标准。RSA算法基于一个十分简单的数论事实:将两个大素数相乘十分容易,但那时想要对其乘积进行因式分解却极其困难,因此可以将乘积公开作为加密密钥。

    import java.security.InvalidKeyException;
    import java.security.KeyPair;
    import java.security.KeyPairGenerator;
    import java.security.NoSuchAlgorithmException;
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
    
    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import javax.crypto.NoSuchPaddingException;
    
    public class EncrypRSA {
    
        /**
         * 加密
         */
        protected byte[] encrypt(RSAPublicKey publicKey,byte[] srcBytes) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException{
            if(publicKey!=null){
                //Cipher负责完成加密或解密工作,基于RSA
                Cipher cipher = Cipher.getInstance("RSA");
                //根据公钥,对Cipher对象进行初始化
                cipher.init(Cipher.ENCRYPT_MODE, publicKey);
                byte[] resultBytes = cipher.doFinal(srcBytes);
                return resultBytes;
            }
            return null;
        }
    
        /**
         * 解密 
         */
        protected byte[] decrypt(RSAPrivateKey privateKey,byte[] srcBytes) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException{
            if(privateKey!=null){
                //Cipher负责完成加密或解密工作,基于RSA
                Cipher cipher = Cipher.getInstance("RSA");
                //根据公钥,对Cipher对象进行初始化
                cipher.init(Cipher.DECRYPT_MODE, privateKey);
                byte[] resultBytes = cipher.doFinal(srcBytes);
                return resultBytes;
            }
            return null;
        }
    
        /**
         * 主函数
         */
        public static void main(String[] args) throws NoSuchAlgorithmException, InvalidKeyException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
            EncrypRSA rsa = new EncrypRSA();
            String msg = "You are not alone.";
            //KeyPairGenerator类用于生成公钥和私钥对,基于RSA算法生成对象
            KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
            //初始化密钥对生成器,密钥大小为1024位
            keyPairGen.initialize(1024);
            //生成一个密钥对,保存在keyPair中
            KeyPair keyPair = keyPairGen.generateKeyPair();
            //得到私钥
            RSAPrivateKey privateKey = (RSAPrivateKey)keyPair.getPrivate();             
            //得到公钥
            RSAPublicKey publicKey = (RSAPublicKey)keyPair.getPublic();
    
            //用公钥加密
            byte[] srcBytes = msg.getBytes();
            byte[] resultBytes = rsa.encrypt(publicKey, srcBytes);
    
            //用私钥解密
            byte[] decBytes = rsa.decrypt(privateKey, resultBytes);
    
            System.out.println("明文是:" + msg);
            System.out.println("加密后是:" + new String(resultBytes));
            System.out.println("解密后是:" + new String(decBytes));
        }
    
    }

    运行结果:

    明文是:You are not alone.
    加密后是:C��n�?�ק����R�`��ZYNo�x�y�8&2J��y:;�a�A]v����2ߝK7�m�\�%
    解密后是:You are not alone.

    Java 单向加密(信息摘要)

    Java一般需要获取对象MessageDigest来实现单项加密(信息摘要)。

    1、MD5

    MD5 即Message-Digest Algorithm 5(信息-摘要算法 5),用于确保信息传输完整一致。是计算机广泛使用的杂凑算法之一(又译摘要算法、哈希算法),主流编程语言普遍已有MD5实现。将数据(如汉字)运算为另一固定长度值,是杂凑算法的基础原理,MD5的前身有MD2、MD3和MD4。MD5的作用是让大容量信息在用数字签名软件签署私人密钥前被”压缩”成一种保密的格式(就是把一个任意长度的字节串变换成一定长的十六进制数字串)。除了MD5以外,其中比较有名的还有sha-1、RIPEMD以及Haval等。

    Java代码:

    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    
    public class EncrypMD5 {
    
        public byte[] eccrypt(String info) throws NoSuchAlgorithmException{
            //根据MD5算法生成MessageDigest对象
            MessageDigest md5 = MessageDigest.getInstance("MD5");
            byte[] srcBytes = info.getBytes();
            //使用srcBytes更新摘要
            md5.update(srcBytes);
            //完成哈希计算,得到result
            byte[] resultBytes = md5.digest();
            return resultBytes;
        }
    
    
        public static void main(String args[]) throws NoSuchAlgorithmException{
            String msg = "You are not alone.";
            EncrypMD5 md5 = new EncrypMD5();
            byte[] resultBytes = md5.eccrypt(msg);
    
            System.out.println("密文是:" + new String(resultBytes));
            System.out.println("明文是:" + msg);
        }
    
    }

    运行结果:

    密文是:(!� ,D���⸎�޻
    明文是:You are not alone.

    2、SHA

    SHA 是一种数据加密算法,该算法经过加密专家多年来的发展和改进已日益完善,现在已成为公认的最安全的散列算法之一,并被广泛使用。该算法的思想是接收一段明文,然后以一种不可逆的方式将它转换成一段(通常更小)密文,也可以简单的理解为取一串输入码(称为预映射或信息),并把它们转化为长度较短、位数固定的输出序列即散列值(也称为信息摘要或信息认证代码)的过程。散列函数值可以说时对明文的一种“指纹”或是“摘要”所以对散列值的数字签名就可以视为对此明文的数字签名。

    Java代码:

    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    
    public class EncrypSHA {
    
        public byte[] eccrypt(String info) throws NoSuchAlgorithmException{
            MessageDigest md5 = MessageDigest.getInstance("SHA");
            byte[] srcBytes = info.getBytes();
            //使用srcBytes更新摘要
            md5.update(srcBytes);
            //完成哈希计算,得到result
            byte[] resultBytes = md5.digest();
            return resultBytes;
        }
    
        /**
         * @param args
         * @throws NoSuchAlgorithmException 
         */
        public static void main(String[] args) throws NoSuchAlgorithmException {
            String msg = "You are not alone.";
            EncrypSHA sha = new EncrypSHA();
            byte[] resultBytes = sha.eccrypt(msg);
            System.out.println("明文是:" + msg);
            System.out.println("密文是:" + new String(resultBytes));
    
        }
    }

    运行结果:

    明文是:You are not alone.
    密文是:�bJ�q����X=�����

    MySql 加解密函数

    MySQL有两个函数来支持这种类型的加密,分别叫做ENCODE()和DECODE()。

    下面是一个简单的实例:

    Mysql代码

    mysql> INSERT INTO users (username,password) VALUES ('joe',ENCODE('guessme','abr'));
    
    Query OK, 1 row affected (0.14 sec)

    其中,Joe的密码是guessme,它通过密钥abr被加密。

    提示:虽然ENCODE()和DECODE()这两个函数能够满足大多数的要求,但是有的时候您希望使用强度更高的加密手段。在这种情况下,您可以使用AES_ENCRYPT()和AES_DECRYPT()函数,它们的工作方式是相同的,但是加密强度更高。

    单向加密与双向加密不同,一旦数据被加密就没有办法颠倒这一过程。因此密码的验证包括对用户输入内容的重新加密,并将它与保存的密文进行比对,看是否匹配。

    一种简单的单向加密方式是MD5校验码。MySQL的MD5()函数会为您的数据创建一个“指纹”并将它保存起来,供验证测试使用。下面就是如何使用它的一个简单例子:

    Mysql代码:

    mysql> INSERT INTO users (username,password) VALUES ('joe',MD5('guessme'));
    
    Query OK, 1 row affected (0.00 sec)

    或者,您考虑一下使用ENCRYPT()函数,它使用系统底层的crypt()系统调用来完成加密。这个函数有两个参数:一个是要被加密的字符串,另一个是双(或者多)字符的“salt”。它然后会用salt加密字符串;这个salt然后可以被用来再次加密用户输入的内容,并将它与先前加密的字符串进行比对。下面一个例子说明了如何使用它:

    Mysql代码:

    mysql> INSERT INTO users (username,password) VALUES('joe'ENCRYPT('guessme','ab'));
    
    Query OK, 1 row affected (0.00 sec)

    提示:ENCRYPT()只能用在UNIX、LINIX系统上,因为它需要用到底层的crypt()库。

    展开全文
  • java常用的加密解密方法

    千次阅读 2017-05-12 16:02:55
    该过程的逆过程为解密,即将该编码信息转化为其原来数据的过程。大体上分为双向加密和单向加密,而双向加密又分为对称加密和非对称加密。 一、双向加密  (一)、对称加密  采用单钥密码系统的加密方法,同一个...
  • Java实现文件的加密与解密

    万次阅读 2019-04-17 09:20:49
     先对文件与加密的相关知识做一个极为简单的科普(知道的可以跳过)。 文件与字串 A、文件的操作流程一般为:打开–>读取–>对内容进行变换–>写入–>关闭。 B、常规性文件操作会用到的类有五个:File...
  • JAVA各种加密与解密方式

    千次阅读 2019-08-30 15:59:43
    之前有兴趣研究了一下java的加密与解密的方法,发现市面上有好多种加密解密方式,在这里整理了一下。 目录 1.BASE64加密/解密 2.MD5(Message Digest Algorithm)加密/解密 3.DES(Data Encryption Standard)...
  • RSA加密与解密(Java实现)

    万次阅读 多人点赞 2018-10-17 10:22:52
    RSA的应用 RSA是一种非对称加密算法。现在,很多登陆表单的... Base64编码 apache.commons-codex包提供了许多编码格式转换,例如Base64。...使用apache.commons-codex进行Base64对字符串进行编码与解码的程序如下: ...
  • Java加密解密工具类

    千次阅读 2017-05-03 22:07:25
    package com.sjzx.common.util; import java.lang.reflect.Method; import java.security.Key; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.security.Secure
  • Java 加密解密zip文件

    万次阅读 2011-06-26 15:49:00
    网上有很多关于zip文件加密解密的帖子, 大多没有给出具体的Java语言的实现代码。本文将给出测试及实现代码。 在前面的文章中我给出了前端AS3语言的zip加密解密代码,而在后台Java也要实现这个功能,这样才能保证...
  • Java加密解密代码小记

    千次阅读 2018-01-26 11:18:21
    花了一周时间看了一本叫《Java加密与解密的艺术》的书,这本书还是可以看看,第三章是对java API中类的一些说明,以及一些小列子,4~9章是对这些类的详细代码表述,我都是随便扫了一眼看了一下,第10~12是关于加密...
  • Java加密解密工具类(实用)

    千次阅读 2019-06-14 17:42:05
    import com.sun.org.apache.xerces.internal.impl.dv.util.Base64... import javax.crypto.Cipher; import javax.crypto.KeyGenerator; import javax.crypto.Mac; import javax.crypto.SecretKey;...import javax.cryp...
  • java 加密解密时间戳

    千次阅读 2017-08-26 15:22:05
    今天献上一个将时间戳加密成一个21位大写英文字母串的java代码,并附上解密代码,思路很简单,仅供娱乐private Map, String> codeMap; private String englishChars; private ArrayList<Integer> changeIndex; ...
  • Java 加密解密工具类AESUtil

    千次阅读 2018-07-31 11:20:33
    package test; /* @auther wjh @date 2018-08-01*...import java.security.SecureRandom; import javax.crypto.Cipher; import javax.crypto.KeyGenerator; import javax.crypto.SecretKey; import javax.crypt...
  • Java 加解密技术系列之 SHA

    万次阅读 2015-02-27 11:08:54
    序 上一篇文章中介绍了基本的单向加密算法 — — MD5,也大致的说了说它实现的原理。这篇文章继续之前提到的单向加密,主要讲的是 SHA,同 MD5 一样,SHA 同样也是一个系列,它包括 SHA-1,SHA-224,SHA-256,SHA-...
  • Java加密解密全解

    万次阅读 多人点赞 2016-08-05 11:31:18
    1 sha加密: 安全哈希算法(Secure Hash Algorithm)主要适用于数字签名标准(Digital Signature Standard DSS)里面定义的数字签名算法(Digital Signature Algorithm DSA)。对于长度小于2^64位的消息,SHA1会产生...
  • java加密解密工具类

    千次阅读 2015-06-04 22:20:13
    package com.xy6.moneykeeper.syn; import java.security.MessageDigest; import javax.crypto.KeyGenerator; import javax.crypto.Mac; import javax.crypto.SecretKey; import javax.crypto.spec.SecretK
  • JAVA实现PGP/GPG加解密加验签

    万次阅读 2020-03-13 11:05:24
    一、引言 上一篇博客中介绍了GPG的基本使用,在原来的项目中我们对接gpg加密的时候,采用的方式,利用java代码执行...所以小编也利用java生成一个加密文件,这样双方可以愉快的加解密了。 二、代码实现 2.1 mave...
  • java 加密解密简单实现

    万次阅读 2009-08-19 22:53:00
    加密算法有很多种:这里只大约列举几例: 1:消息摘要:(数字指纹):既对一个任意...2:单匙密码体制:DES:比较简便高效,密钥简短,加解密速度快,破译极其困难,但其安全性依赖于密匙的安全性。DES(Data Encryption
  • JAVA加密解密要用到的JAR包

    千次阅读 2016-02-22 15:39:53
    3DES加密解密算法  jce.jar  security/US_export_policy.jar  security/local_policy.jar  ext/sunjce_provider.jar
1 2 3 4 5 ... 20
收藏数 79,537
精华内容 31,814
关键字:

java加解密