精华内容
下载资源
问答
  • DES加密

    千次阅读 2020-01-21 10:44:46
    DES加密 DES是一种对称加密算法,所谓对称加密算法即:加密和解密使用相同密钥的算法。 import java.security.Key; import java.security.SecureRandom; import javax.crypto.Cipher; import javax.crypto....

    DES加密
    DES是一种对称加密算法,所谓对称加密算法即:加密和解密使用相同密钥的算法。

    import java.security.Key;
    import java.security.SecureRandom;
    import javax.crypto.Cipher;
    import javax.crypto.KeyGenerator;
    import sun.misc.BASE64Decoder;
    import sun.misc.BASE64Encoder;
    public class DESUtil {
    
    	private static Key key;
    	// 设置密钥key
    	private static String KEY_STR = "myKey";
    	private static String CHARSETNAME = "UTF-8";
    	private static String ALGORITHM = "DES";
    
    	static {
    		try {
    			// 生成DES算法对象
    			KeyGenerator generator = KeyGenerator.getInstance(ALGORITHM);
    			// 运用SHA1安全策略
    			SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
    			// 设置上密钥种子
    			secureRandom.setSeed(KEY_STR.getBytes());
    			// 初始化基于SHA1的算法对象
    			generator.init(secureRandom);
    			// 生成密钥对象
    			key = generator.generateKey();
    			generator = null;
    		} catch (Exception e) {
    			throw new RuntimeException(e);
    		}
    	}
    
    	/**
    	 * 加密
    	 * @param str
    	 * @return
    	 */
    	public static String getEncryptString(String str) {
    		// 基于BASE64编码,接收byte[]并转换成String
    		BASE64Encoder base64encoder = new BASE64Encoder();
    		try {
    			// 按UTF8编码
    			byte[] bytes = str.getBytes(CHARSETNAME);
    			// 获取加密对象
    			Cipher cipher = Cipher.getInstance(ALGORITHM);
    			// 初始化密码信息
    			cipher.init(Cipher.ENCRYPT_MODE, key);
    			// 加密
    			byte[] doFinal = cipher.doFinal(bytes);
    			// byte[]to encode好的String并返回
    			return base64encoder.encode(doFinal);
    		} catch (Exception e) {
    			// TODO: handle exception
    			throw new RuntimeException(e);
    		}
    	}
    
    	/**
    	 * 解密
    	 * @param str
    	 * @return
    	 */
    	public static String getDecryptString(String str) {
    		// 基于BASE64编码,接收byte[]并转换成String
    		BASE64Decoder base64decoder = new BASE64Decoder();
    		try {
    			// 将字符串decode成byte[]
    			byte[] bytes = base64decoder.decodeBuffer(str);
    			// 获取解密对象
    			Cipher cipher = Cipher.getInstance(ALGORITHM);
    			// 初始化解密信息
    			cipher.init(Cipher.DECRYPT_MODE, key);
    			// 解密
    			byte[] doFinal = cipher.doFinal(bytes);
    			// 返回解密之后的信息
    			return new String(doFinal, CHARSETNAME);
    		} catch (Exception e) {
    			// TODO: handle exception
    			throw new RuntimeException(e);
    		}
    	}
    	public static void main(String[] args) {
    		System.out.println(getEncryptString("root"));
    		System.out.println(getEncryptString("zl0119.."));
    	}
    }
    
    展开全文
  • des 加密

    2013-08-05 13:51:16
    DES加密依赖JDK6自带的功能,使用默认支持的56位密钥长度,加密具体细节如下: 格式 值 密钥数组 8字节密钥,系统随机生成,双方妥存 工作模式 ECB 填充方式 ...

    DES加密依赖JDK6自带的功能,使用默认支持的56位密钥长度,加密具体细节如下:

    格式

    密钥数组

    8字节密钥,系统随机生成,双方妥存

    工作模式

    ECB

    填充方式

    PKCS5Padding

     具体实现:

    //DES加密,模式DES/ECB/PKCS5Padding 密钥8字节密钥,系统随机生成,双方妥存
    		byte[] requestXmlDES = null;
    		try {
    			//des 密钥
    			byte[] desPrivateKey = systemCofingManager.getSystemConfig("").getBytes("UTF-8");//从数据库中或配置属性文件取
    			DESKeySpec dESKeySpec =new DESKeySpec(desPrivateKey);
    			//使用算法(DES)、模式(ECB)、填充方案(PKCS5Padding)实例化为加密或解密的类
    			Cipher c = Cipher.getInstance("DES/ECB/PKCS5Padding");
    			//返回转换指定算法(DES)的秘密密钥的 SecretKeyFactory 对象。
    			SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance("DES");
    			//用指定的密钥生成对称密钥
    			SecretKey secretKey = secretKeyFactory.generateSecret(dESKeySpec);
    			//用加密模式和密钥初始化此 Cipher。
    			c.init(Cipher.ENCRYPT_MODE, secretKey);
    			requestXmlDES = c.doFinal(requestXml.getBytes("UTF-8"));
    		} catch (Exception e) {
    			e.printStackTrace();
    			log.info("des加密请求报文出错",e);
    		}


    展开全文
  • 3des 3des3des加密3des加密3des加密3des加密
  • DES 加密

    万次阅读 2013-08-23 15:33:35
    * DES加密 * @param plainData * @param secretKey * @return * @throws Exception */ public static String encryption(String plainData) throws Exception{ Cipher cipher = null;
    /**
    	 * DES加密
    	 * @param plainData
    	 * @param secretKey
    	 * @return
    	 * @throws Exception
    	 */
    	public static String encryption(String plainData) throws Exception{
    
    		Cipher cipher = null;
    		try {
    			cipher = Cipher.getInstance(DES_ALGORITHM);
    			cipher.init(Cipher.ENCRYPT_MODE, generateKey(KEY));
    			
    		} catch (NoSuchAlgorithmException e) {
    			e.printStackTrace();
    		} catch (NoSuchPaddingException e) {
    			e.printStackTrace();
    		}catch(InvalidKeyException e){
    			
    		}
    		
    		try {
    			// 为了防止解密时报javax.crypto.IllegalBlockSizeException: Input length must be multiple of 8 when decrypting with padded cipher异常,
    			// 不能把加密后的字节数组直接转换成字符串
    			byte[] buf = cipher.doFinal(plainData.getBytes());
    			
    			return Base64Utils.encode(buf);
    			
    		} catch (IllegalBlockSizeException e) {
    			e.printStackTrace();
    			throw new Exception("IllegalBlockSizeException", e);
    		} catch (BadPaddingException e) {
    			e.printStackTrace();
    			throw new Exception("BadPaddingException", e);
    		}
    	    
    	}
    
    	/**
    	 * DES解密
    	 * @param secretData
    	 * @param secretKey
    	 * @return
    	 * @throws Exception
    	 */
    	public static String decryption(String secretData) throws Exception{
    		
    		Cipher cipher = null;
    		try {
    			cipher = Cipher.getInstance(DES_ALGORITHM);
    			cipher.init(Cipher.DECRYPT_MODE, generateKey(KEY));
    			
    		} catch (NoSuchAlgorithmException e) {
    			e.printStackTrace();
    			throw new Exception("NoSuchAlgorithmException", e);
    		} catch (NoSuchPaddingException e) {
    			e.printStackTrace();
    			throw new Exception("NoSuchPaddingException", e);
    		}catch(InvalidKeyException e){
    			e.printStackTrace();
    			throw new Exception("InvalidKeyException", e);
    			
    		}
    		
    		try {
    			
    			byte[] buf = cipher.doFinal(Base64Utils.decode(secretData.toCharArray()));
    			
    			return new String(buf);
    			
    		} catch (IllegalBlockSizeException e) {
    			e.printStackTrace();
    			throw new Exception("IllegalBlockSizeException", e);
    		} catch (BadPaddingException e) {
    			e.printStackTrace();
    			throw new Exception("BadPaddingException", e);
    		}
    	}
    	
    	
    	/**
    	 * 获得秘密密钥
    	 * 
    	 * @param secretKey
    	 * @return
    	 * @throws NoSuchAlgorithmException 
    	 */
    	private static SecretKey generateKey(String secretKey) throws NoSuchAlgorithmException{
    		//SecureRandom secureRandom = new SecureRandom(secretKey.getBytes());
    		  SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");  
    		  secureRandom.setSeed(secretKey.getBytes());	
    		// 为我们选择的DES算法生成一个KeyGenerator对象
    		KeyGenerator kg = null;
    		try {
    			kg = KeyGenerator.getInstance(DES_ALGORITHM);
    		} catch (NoSuchAlgorithmException e) {
    		}
    		kg.init(secureRandom);
    		//kg.init(56, secureRandom);
    		
    		// 生成密钥
    		return kg.generateKey();
    	}
    			
    
    		
    	static class Base64Utils {
    
    		static private char[] alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".toCharArray();
    		static private byte[] codes = new byte[256];
    		static {
    			for (int i = 0; i < 256; i++)
    				codes[i] = -1;
    			for (int i = 'A'; i <= 'Z'; i++)
    				codes[i] = (byte) (i - 'A');
    			for (int i = 'a'; i <= 'z'; i++)
    				codes[i] = (byte) (26 + i - 'a');
    			for (int i = '0'; i <= '9'; i++)
    				codes[i] = (byte) (52 + i - '0');
    			codes['+'] = 62;
    			codes['/'] = 63;
    		}
    		
    		/**
    		 * 将原始数据编码为base64编码
    		 */
    		static public String encode(byte[] data) {
    			char[] out = new char[((data.length + 2) / 3) * 4];
    			for (int i = 0, index = 0; i < data.length; i += 3, index += 4) {
    				boolean quad = false;
    				boolean trip = false;
    				int val = (0xFF & (int) data[i]);
    				val <<= 8;
    				if ((i + 1) < data.length) {
    					val |= (0xFF & (int) data[i + 1]);
    					trip = true;
    				}
    				val <<= 8;
    				if ((i + 2) < data.length) {
    					val |= (0xFF & (int) data[i + 2]);
    					quad = true;
    				}
    				out[index + 3] = alphabet[(quad ? (val & 0x3F) : 64)];
    				val >>= 6;
    				out[index + 2] = alphabet[(trip ? (val & 0x3F) : 64)];
    				val >>= 6;
    				out[index + 1] = alphabet[val & 0x3F];
    				val >>= 6;
    				out[index + 0] = alphabet[val & 0x3F];
    			}
    			
    			return new String(out);
    		}
    
    		/**
    		 * 将base64编码的数据解码成原始数据
    		 */
    		static public byte[] decode(char[] data) {
    			int len = ((data.length + 3) / 4) * 3;
    			if (data.length > 0 && data[data.length - 1] == '=')
    				--len;
    			if (data.length > 1 && data[data.length - 2] == '=')
    				--len;
    			byte[] out = new byte[len];
    			int shift = 0;
    			int accum = 0;
    			int index = 0;
    			for (int ix = 0; ix < data.length; ix++) {
    				int value = codes[data[ix] & 0xFF];
    				if (value >= 0) {
    					accum <<= 6;
    					shift += 6;
    					accum |= value;
    					if (shift >= 8) {
    						shift -= 8;
    						out[index++] = (byte) ((accum >> shift) & 0xff);
    					}
    				}
    			}
    			if (index != out.length)
    				throw new Error("miscalculated data length!");
    			return out;
    		}
    	}
    	
    	
    	public static void main(String[] a) throws Exception{
    		String input = "test";  
    		
    		String result = encryption(input);
    		System.out.println(result);
    		
    		System.out.println( decryption(result));
    			//H+Ac2AysRv6CWn3ncH1HIw==
    	}
    }

    展开全文
  • DES加密算法源码 DES加密算法源码

    热门讨论 2009-06-10 12:05:56
    DES加密算法源码 DES加密算法源码 DES加密算法源码 DES加密算法源码 DES加密算法源码 DES加密算法源码 DES加密算法源码 DES加密算法源码 DES加密算法源码 DES加密算法源码 DES加密算法源码 DES加密算法源码DES加密...
  • DES加密解密工具 DES加密解密工具

    热门讨论 2009-03-13 16:19:00
    DES加密解密工具DES加密解密工具DES加密解密工具DES加密解密工具DES加密解密工具DES加密解密工具DES加密解密工具DES加密解密工具DES加密解密工具
  • Des加密

    2013-06-12 22:28:14
    对称加密算法 密钥长度与安全性成正比,Java仅支持56位密钥长度,作为补充,Bouncy Castle...这里的加密/解密算法中除了包含密钥算法(DES)外,还包含了工作模式(ECB)和填充方式(PKCS5Padding)。 当在跨平

    对称加密算法

    密钥长度与安全性成正比,Java仅支持56位密钥长度,作为补充,Bouncy Castle提供64位密钥长度的支持。


    Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
    这里的加密/解密算法中除了包含密钥算法(DES)外,还包含了工作模式(ECB)和填充方式(PKCS5Padding)。


    当在跨平台的情况下进行加解密的操作时,应注意“工作模式”、“填充方式”是否一致。否则加解密会失败

    Java6实现des支持的工作模式:ECB、CBC、PCBC、CTR、CTS、CFB、CFB8至CFB128、OFB、OFB8至OFB128

    Java6实现des支持的填充方式:NoPadding、PKCS5Padding、ISO10126Padding


    示例代码:

    public class DESUtil {
    
    	/**
    	 * 构造器.
    	 */
    	protected DESUtil() {
    		throw new UnsupportedOperationException();
    	}
    
    	/**
    	 * @param args
    	 *            args
    	 * @throws Exception
    	 *             Exception
    	 */
    	public static void main(String[] args) throws Exception {
    		/* 生成des随机密钥 */
    		byte[] key = getKey();
    		/* 将byte数组转为16进制字符串 */
    		String hex = getHexString(key);
    		// /* 将16进制的字符串转为字节数组;一个16进制数对应4位二进制。长度自己可以任意创建,单实际加密解密过程中只会用到前56位 */
    		hex = "0fa61e1b77b51b8a";
    		key = getByteArray(hex);
    		Assert.assertEquals(hex.length(), key.length * 2);
    		System.out.println("key Length:" + key.length + "字节");
    		for (int i = 0; i < key.length; i++) {
    			System.out.print(key[i] + " ");
    		}
    		System.out.println("");
    		/* 等加密明文 */
    		String s = "1111aaaa1111aaaa1111aaaa";
    		System.out.println("明文:" + s);
    		/* 加密结果字节数组 */
    		byte[] encryptedData = encrypt(s.getBytes(), key);
    		for (int i = 0; i < encryptedData.length; i++) {
    			System.out.print(encryptedData[i] + " ");
    		}
    		System.out.println("");
    		System.out.println("encryptedData Length:" + encryptedData.length + "字节");
    		/* 将byte数组转为16进制字符串 */
    		System.out.println("encryptedData hex:" + getHexString(encryptedData));
    		System.out.println("");
    
    		/* 解密结果字节数组 */
    		byte[] decryptedData = decrypt(encryptedData, key);
    		System.out.println("解密:" + new String(decryptedData));
    	}
    
    	/**
    	 * decrypt.
    	 * 
    	 * @param encryptedData
    	 *            encryptedData
    	 * @param key
    	 *            key
    	 * @return String
    	 */
    	public static String decrypt(String encryptedData, String key) {
    		String ret = null;
    		byte[] keyByte = DESUtil.getByteArray(key);
    		byte[] byteData = DESUtil.getByteArray(encryptedData.toLowerCase());
    		try {
    			ret = new String(DESUtil.decrypt(byteData, keyByte));
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    
    		return ret;
    	}
    
    	/**
    	 * DES加密.
    	 * 
    	 * @param data
    	 *            .
    	 * @param keyBytes
    	 *            .
    	 * @return byte[]
    	 * @throws Exception .
    	 */
    	public static byte[] encrypt(byte[] data, byte[] keyBytes) throws Exception {
    		/* 实例化DES密钥材料 */
    		DESKeySpec dks = new DESKeySpec(keyBytes);
    		/* 实例化秘密密钥工厂 */
    		SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
    		/* 生成秘密密钥 */
    		SecretKey key = keyFactory.generateSecret(dks);
    		SecureRandom sr = new SecureRandom();
    		/* jce框架核心,为加密和解密提供密码功能 */
    		Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
    		/* 设置加密模式 */
    		cipher.init(Cipher.ENCRYPT_MODE, key, sr);
    		byte[] encryptedData = cipher.doFinal(data);
    		return encryptedData;
    	}
    
    	/**
    	 * DES解密.
    	 * 
    	 * @param data
    	 *            .
    	 * @param keyBytes
    	 *            .
    	 * @return byte[]
    	 * @throws Exception .
    	 */
    	public static byte[] decrypt(byte[] data, byte[] keyBytes) throws Exception {
    		/* 实例化DES密钥材料 */
    		DESKeySpec dks = new DESKeySpec(keyBytes);
    		/* 实例化秘密密钥工厂 */
    		SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
    		/* 生成秘密密钥 */
    		SecretKey key = keyFactory.generateSecret(dks);
    		SecureRandom sr = new SecureRandom();
    		Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
    		cipher.init(Cipher.DECRYPT_MODE, key, sr);
    		byte[] decryptedData = cipher.doFinal(data);
    		return decryptedData;
    	}
    
    	/**
    	 * 随机生成密钥.
    	 * 
    	 * @return byte[]
    	 * @throws Exception .
    	 */
    	public static byte[] getKey() throws Exception {
    		/* 随机数生成器 */
    		SecureRandom sr = new SecureRandom();
    		/* 实例化对称密钥生成器 */
    		KeyGenerator kg = KeyGenerator.getInstance("DES");
    		/* 初始化;以下两种方式都将创建一个56位长度的密钥 */
    		kg.init(56);
    		kg.init(sr);
    		/*
    		 * 生成秘密密钥;java仅支持56位密钥长度,作为补充,Bouncy
    		 * Castle提供64位密钥的支持;【使用的密钥为64位,有效密钥长度为56位(有8位用于奇偶校验)】
    		 */
    		SecretKey key = kg.generateKey();
    		/* 获得密钥的二进制编码形式,8个字节 */
    		byte[] b = key.getEncoded();
    		return b;
    	}
    
    	/**
    	 * byte数组转换成16进制字符串.
    	 * 
    	 * @param b
    	 *            .
    	 * @return String
    	 */
    	public static String getHexString(byte[] b) {
    		StringBuffer result = new StringBuffer();
    		for (int i = 0; i < b.length; i++) {
    			String hex = Integer.toHexString(b[i] & 0xFF);
    			if (hex.length() == 1) {
    				hex = '0' + hex;
    			}
    			result.append(hex.toLowerCase());
    		}
    		return result.toString();
    	}
    
    	/**
    	 * 16进制字符串转换成byte数组.
    	 * 
    	 * @param hex
    	 *            .
    	 * @return byte[]
    	 */
    	public static byte[] getByteArray(String hex) {
    		int len = (hex.length() / 2);
    		byte[] result = new byte[len];
    		char[] achar = hex.toCharArray();
    		for (int i = 0; i < len; i++) {
    			int pos = i * 2;
    			result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));
    		}
    		return result;
    	}
    
    	/**
    	 * toByte.
    	 * 
    	 * @param c
    	 *            c
    	 * @return int
    	 */
    	private static int toByte(char c) {
    		byte b = (byte) "0123456789abcdef".indexOf(c);
    		return b;
    	}
    }


    展开全文
  • DES加密 DES解密

    2011-03-27 01:02:43
    des算法 DES DES加密 DES解密des算法 DES DES加密 DES解密des算法 DES DES加密 DES解密
  • C# 3Des加密解密

    万次阅读 2019-05-09 10:32:19
    第三方的加密规则约定:加密经过3DES加密后的Base64 编码 最近在对接一个第三方接口,请求参数和响应参数全采用3des加密规则,由于我是用.NET对接的,而第三方是Java开发的,所以两种程序之间采用的算法有一点差异...
  • Java实现DES加密解密

    万次阅读 2018-11-09 16:27:01
    DES(Data Encryption Standard)是一种对称加密算法,所谓对称加密就是加密和解密都是使用同一个密钥。 加密原理: DES 使用一个 56 位的密钥以及附加的 8 位奇偶校验位,产生最大 64 位的分组大小。这是一个迭代的...
  • 一、 对称密钥密码体质 、 二、 数据加密标准 DES 、 三、 DES 加密过程 、 四、 DES 保密性 、 五、 三重 DES 加密
  • DES加密源代码

    2014-11-14 14:00:14
    DES加密DES加密DES加密DES加密
  • DES 加密,RSA 加密DES 文件加密,提供了方便文件加密接口
  • DES,DES加密算法,DES算法源码。用C写的DES加密算法。 DES,DES加密算法,DES算法源码。 DES加密算法(c语言实现) (本程序可以直接使用)
  • 前端有时把数据传给后端,也是需要加密的,这里介绍下des加密:DES 加密算法为最为常见的分组加密算法。其主要思想在于数据位的置换与移位过程,通过16次的迭代加密与最终的逆置换得出最终的密文。DES 的解密方式只...
  • 只进行了两轮des加密,输入为字符 输出为8位的数字 密文是“ABCD” 输出结果: 代码 % 实现3-des 算法 % 2019-5-15 % clear all; text='ABCD'; % ascii码65 66 67 68 P10=[3 5 2 7 4 10 1 9 8 6]; P8=[6 3 ...
  • Android Des加密

    千次阅读 2019-08-08 11:53:33
    DES加密介绍: DES是一种对称加密算法,所谓对称加密算法即:加密和解密使用相同密钥的算法。DES加密算法出自IBM的研究, 后来被美国政府正式采用,之后开始广泛流传,但是近些年使用越来越少,因为DES使用56位密钥...
  • DES加密说明

    2018-05-24 14:38:19
    对称加密:Des Aes不对称加密:Rsa单向加密:Md5本地...DES对数据依次进行加密,一次加密是8个字节一起因此,DES密码,必须是64bit,也就是8个字节 DES加密实现 1. DES加密之后的数据,不能够直接生成字符串的; ...
  • java DES加密工具类

    2017-08-29 10:48:25
    DES加密

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,127
精华内容 7,650
关键字:

des加密