精华内容
下载资源
问答
  • Des算法计算和演示软件包与使用手册 Des算法计算和演示软件包与使用手册 Des算法计算和演示软件包与使用手册 Des算法计算和演示软件包与使用手册Des算法计算和演示软件包与使用手册
  • Des算法计算和演示软件包与使用手册 由freespaceteam团队开发 请关注www.freespaceteam.com
  •  在学习《信息安全管理原理及应用》过程中,由于DES算法计算过程较复杂,教师在授课过程中,难以验证结果的正确性。所以FREESPACE打算开发一个DES算法的计算过程演示软件,用于教学DES算法。 三、软件功能  本...

    一、软件名称 

      DES 算法计算演示软件ver1.0

    二、创意来源 

      在学习《信息安全管理原理及应用》过程中,由于DES算法计算过程较复杂,教师在授课过程中,难以验证结果的正确性。所以FREESPACE打算开发一个DES算法的计算过程演示软件,用于教学DES算法。

    三、软件功能 

      本软件用于DES运算过程的详细演示,用于帮助教学使用。软件中明文(密文),密钥随机产生,运算过程明确,输出中间结果和重定向到文本文件中。

    四、 软件使用

      具体请下载《DES算法计算演示软件 用户使用手册》,软件截图如下:

    2011050714531635.jpg

    五、 联系我们

      如果您有什么意见或意见,可以给我们发邮件(freespaceteam@gmail.com freespaceteam@163.com)

      主站点:http://www.freespaceteam.com

    六、软件和用户手册下载

      http://ishare.iask.sina.com.cn/f/15195078.html

    /****************************************************************/

        开发人员:陈宇 王利宝 杨溪 肖大伟 汪进祥 张杰

        测试人员:李博 邬明 王利宝

        LOGO设计者:常馨

    /****************************************************************/

    转载于:https://www.cnblogs.com/freespace/archive/2011/05/07/2039802.html

    展开全文
  • 3DES算法计算MAC

    2014-10-22 13:41:04
    此代码采用双倍长密钥,计算工作密钥mackey,pinkey,计算校验值,计算mac
  • 利用3DES算法计算MAC及解加密

    千次阅读 2014-07-24 11:18:59
    不少人对于3DES算法有些陌生

    不少人对于3DES的算法有些陌生,尤其是从事金融类编程的用到的概率相对较大,网上比较完整的例子也很少,因此,写了个比较完整的例子,供大家参考

    eg:

    1、利用3DES算法计算MAC

    2、利用3DES算法解加密一个KEY

    3、计算校验值

    此代码采用双倍长密钥为例


    import java.security.SecureRandom;
    import javax.crypto.Cipher;
    import javax.crypto.SecretKey;
    import javax.crypto.SecretKeyFactory;
    import javax.crypto.spec.DESKeySpec;
    import javax.crypto.spec.IvParameterSpec;
    
    import org.apache.commons.lang3.ArrayUtils;
    
    /**
     * 
     * 
     * @author ZhangYaMin
     *
     */
    public class EncryptionMachine {
    	
    	
    	
    	
    	//初始向量
    	private static String ivInfo = "0000000000000000";
    	
    	private static char[] CHARARRAY= {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
    	private static byte[] funStringToBcd(char[] data){
    		int len = data.length;
    		if(len % 2 != 0 || len == 0){
    			throw new RuntimeException("数据长度错误");
    		}
    		byte[] outData = new byte[len >> 1];
    		for(int i=0, j=0; j<len; i++){
    			outData[i] = (byte) (((Character.digit(data[j], 16) & 0x0F) << 4) | (Character.digit(data[j+1], 16) & 0x0F));
    			j++;
    			j++;
    		}
    		
    		return outData;
    	}
    	
    	private static String funByteToHexString(byte[] data){
    		int len = data.length;
    		char[] outChar = new char[len<<1];
    		for(int i=0, j=0; j<len; j++){
    			outChar[i++] = CHARARRAY[(0xF0 & data[j]) >>> 4];
    			outChar[i++] = CHARARRAY[data[j] & 0x0F];		
    		}
    		String outString = new String(outChar);
    
    		return outString;
    	}
    	
    	
    	/**
    	 * 加密函数(ECB)
    	 * 
    	 * @param data
    	 *            加密数据
    	 * @param key
    	 *            密钥
    	 * @return 返回加密后的数据
    	 */
    	private static byte[] ecbEncrypt(byte[] data, byte[] key) {
    
    		try {
    
    			// DES算法要求有一个可信任的随机数源
    			SecureRandom sr = new SecureRandom();
    
    			// 从原始密钥数据创建DESKeySpec对象
    			DESKeySpec dks = new DESKeySpec(key);
    
    			// 创建一个密匙工厂,然后用它把DESKeySpec转换成一个SecretKey对象
    			SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
    			SecretKey secretKey = keyFactory.generateSecret(dks);
    
    			// DES的ECB模式
    			Cipher cipher = Cipher.getInstance("DES/ECB/NoPadding");
    
    			// 用密钥初始化Cipher对象
    			cipher.init(Cipher.ENCRYPT_MODE, secretKey, sr);
    
    			// 执行加密操作
    			byte encryptedData[] = cipher.doFinal(data);
    
    			return encryptedData;
    		} catch (Exception e) {
    			throw new RuntimeException("ECB-DES算法,加密数据出错!");
    		}
    
    	}
    
    	/**
    	 * 解密函数(ECB)
    	 * 
    	 * @param data
    	 *            解密数据
    	 * @param key
    	 *            密钥
    	 * @return 返回解密后的数据
    	 */
    	private static byte[] ecbDecrypt(byte[] data, byte[] key) {
    		try {
    			// DES算法要求有一个可信任的随机数源
    			SecureRandom sr = new SecureRandom();
    
    			// byte rawKeyData[] = /* 用某种方法获取原始密匙数据 */;
    
    			// 从原始密匙数据创建一个DESKeySpec对象
    			DESKeySpec dks = new DESKeySpec(key);
    
    			// 创建一个密匙工厂,然后用它把DESKeySpec对象转换成 一个SecretKey对象
    			SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
    			SecretKey secretKey = keyFactory.generateSecret(dks);
    
    			// DES的ECB模式
    			Cipher cipher = Cipher.getInstance("DES/ECB/NoPadding");
    
    			// 用密钥初始化Cipher对象
    			cipher.init(Cipher.DECRYPT_MODE, secretKey, sr);
    
    			// 正式执行解密操作
    			byte decryptedData[] = cipher.doFinal(data);
    
    			return decryptedData;
    		} catch (Exception e) {
    			throw new RuntimeException("ECB-DES算法,解密出错。");
    		}
    
    	}
    
    	/**
    	 * 加密函数(CBC)
    	 * 
    	 * @param data
    	 *            加密数据
    	 * @param key
    	 *            密钥
    	 * @return 返回加密后的数据
    	 */
    	private static byte[] cbcEncrypt(byte[] data, byte[] key, byte[] iv) {
    
    		try {
    			// 从原始密钥数据创建DESKeySpec对象
    			DESKeySpec dks = new DESKeySpec(key);
    
    			// 创建一个密匙工厂,然后用它把DESKeySpec转换成一个SecretKey对象
    			SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
    			SecretKey secretKey = keyFactory.generateSecret(dks);
    
    			// DES的CBC模式,采用NoPadding模式,data长度必须是8的倍数
    			 Cipher cipher = Cipher.getInstance("DES/CBC/NoPadding");
    
    			// 用密钥初始化Cipher对象
    			IvParameterSpec param = new IvParameterSpec(iv);
    			cipher.init(Cipher.ENCRYPT_MODE, secretKey, param);
    
    			// 执行加密操作
    			byte encryptedData[] = cipher.doFinal(data);
    
    			return encryptedData;
    		} catch (Exception e) {
    			throw new RuntimeException("CBC-DES算法,加密数据出错!");
    		}
    	}
    
    	/**
    	 * 解密函数(CBC)
    	 * 
    	 * @param data
    	 *            解密数据
    	 * @param key
    	 *            密钥
    	 * @return 返回解密后的数据
    	 */
    	@SuppressWarnings("unused")
    	private static byte[] cbcDecrypt(byte[] data, byte[] key, byte[] iv) {
    		try {
    			// 从原始密匙数据创建一个DESKeySpec对象
    			DESKeySpec dks = new DESKeySpec(key);
    
    			// 创建一个密匙工厂,然后用它把DESKeySpec对象转换成一个SecretKey对象
    			SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
    			SecretKey secretKey = keyFactory.generateSecret(dks);
    
    			// DES的CBC模式,采用NoPadding模式,data长度必须是8的倍数
    			Cipher cipher = Cipher.getInstance("DES/CBC/NoPadding");
    
    			// 用密钥初始化Cipher对象
    			IvParameterSpec param = new IvParameterSpec(iv);
    			cipher.init(Cipher.DECRYPT_MODE, secretKey, param);
    
    			// 正式执行解密操作
    			byte decryptedData[] = cipher.doFinal(data);
    
    			return decryptedData;
    		} catch (Exception e) {
    			throw new RuntimeException("CBC-DES算法,解密出错。");
    		}
    
    	}
    	
    	/**
    	 * 将工作密钥解为明文
    	 *@param plaintextZmk
    	 *		解workKey的Zmk(明文)
    	 *@param ciphertextWorkingKey
    	 *		workKey密文
    	 *@return
    	 *		返回workKey明文
    	 **/
    	public static String analogDecryptWorkingKey(String plaintextZmk, String ciphertextWorkingKey){
    		byte[] inPlaintextZmk = funStringToBcd(plaintextZmk.toCharArray());
    		byte[] inCiphertextWorkingKey = funStringToBcd(ciphertextWorkingKey.toCharArray());
    		
    		byte[] leftPlaintextZmk = ArrayUtils.subarray(inPlaintextZmk, 0, 8);
    		byte[] rightPlaintextZmk = ArrayUtils.subarray(inPlaintextZmk, 8, 16);
    		
    		byte[] leftCiphertextWorkingKey = ArrayUtils.subarray(inCiphertextWorkingKey, 0, 8);
    		byte[] rightCiphertextWorkingKey = ArrayUtils.subarray(inCiphertextWorkingKey, 8, 16);
    		
    		// 一、WorkingKey左部分解密 (反3DES)
    		/* 1、ECB-DES解密  left key */		
    		byte[] ecbDecryptReturn = ecbDecrypt(leftCiphertextWorkingKey, leftPlaintextZmk);
    		System.out.println(funByteToHexString(ecbDecryptReturn));
    		/* 2、 ECB-DES加密  right key */
    		byte[] ecbEncryptReturn = ecbEncrypt(ecbDecryptReturn, rightPlaintextZmk);	
    		/* 3、 ECB-DES解密  left key */
    		byte[] leftPlaintextWorkingKey = ecbDecrypt(ecbEncryptReturn, leftPlaintextZmk);
    		
    		// 一、WorkingKey右部分解密 (反3DES)
    		/* 1、ECB-DES解密  left key */		
    		ecbDecryptReturn = ecbDecrypt(rightCiphertextWorkingKey, leftPlaintextZmk);
    		/* 2、 ECB-DES加密  right key */
    		ecbEncryptReturn = ecbEncrypt(ecbDecryptReturn, rightPlaintextZmk);	
    		/* 3、 ECB-DES解密  left key */
    		byte[] rightPlaintextWorkingKey = ecbDecrypt(ecbEncryptReturn, leftPlaintextZmk);
    		
    		byte[] plaintextWorkingKey = ArrayUtils.addAll(leftPlaintextWorkingKey, rightPlaintextWorkingKey);
    			
    		return funByteToHexString(plaintextWorkingKey);
    	}
    	
    	/**
    	 * 计算密钥校验值
    	 *@param plaintextKey
    	 *		明文KEY
    	 *@return
    	 *		返回校验值
    	 **/
    	public static String getCheckValueOfKey(String plaintextKey){
    		byte[] desData = funStringToBcd("0000000000000000".toCharArray());
    		byte[] leftPlaintextKey = funStringToBcd(plaintextKey.substring(0, 16).toCharArray());
    		byte[] rightPlaintextKey = funStringToBcd(plaintextKey.substring(16, 32).toCharArray());
    		/* 1、ECB-DES加密  left key */
    		byte[] ecbEncryptReturn = ecbEncrypt(desData, leftPlaintextKey);
    		
    		/* 2、 ECB-DES解密  right key */
    		byte[] ecbDecryptReturn = ecbDecrypt(ecbEncryptReturn, rightPlaintextKey);
    	
    		/* 3、 ECB-DES加密  left key */
    		ecbEncryptReturn = ecbEncrypt(ecbDecryptReturn, leftPlaintextKey);
    		
    		return funByteToHexString(ArrayUtils.subarray(ecbEncryptReturn, 0, 3));
    	}
    
    	/**
    	 * 3DES算法计算MAC
    	 *@param macKey
    	 *		计算mac的Key(明文)
    	 *@param macData
    	 *		计算mac的数据域
    	 *@return
    	 *		返回mac数据
    	 **/
    	public static String analogMacBy3Des(String macKey, String macData) {
    		byte[] inMacKey = funStringToBcd(macKey.toCharArray());	
    		byte[] inMacData = macData.getBytes();
    		
    		if(inMacData.length % 8 != 0){
    			int iFillLen = 8 - inMacData.length % 8;
    			byte[] bFillData = new byte[iFillLen];
    			for(int i = 0; i < iFillLen; i++){
    				bFillData[i] = 0x00;
    			}
    			inMacData = ArrayUtils.addAll(inMacData, bFillData);
    		}
    		//初始变量
    		byte[] ivData = funStringToBcd(ivInfo.toCharArray());
    		//left key
    		byte[] lKey = ArrayUtils.subarray(inMacKey, 0, 8);
    		//right key
    		byte[] rKey = ArrayUtils.subarray(inMacKey, 8, 16);
    		
    		/* 1、CBC-DES加密  left key */
    		byte[] cbcEncryptReturn = cbcEncrypt(inMacData, lKey, ivData);
    //		System.out.println(funByteToHexString(cbcEncryptReturn));
    		byte[] ecbDecryptData = ArrayUtils.subarray(cbcEncryptReturn, cbcEncryptReturn.length-8, cbcEncryptReturn.length);
    //		System.out.println(funByteToHexString(ecbDecryptData));
    		
    		/* 2、 ECB-DES解密  right key */
    		byte[] ecbDecryptReturn = ecbDecrypt(ecbDecryptData, rKey);
    //		System.out.println(funByteToHexString(ecbDecryptReturn));
    		
    		/* 3、 ECB-DES加密  left key */
    		byte[] ecbEncryptReturn = ecbEncrypt(ecbDecryptReturn, lKey);
    		
    		return funByteToHexString(ecbEncryptReturn);
    	}
    
    	/**
    	 * PIN加密
    	 *@param pinKey
    	 *		计算pin的Key
    	 *@param cardNo
    	 *		卡号/主账号
    	 *@param pinData
    	 *		明文PIN
    	 *@return
    	 *		返回pin密文
    	 **/
    	public static String analogPinEncrypt(String pinKey, String cardNo, String pinData){
    		byte[] inPinKey = funStringToBcd(pinKey.toCharArray());
    		//left key
    		byte[] lKey = ArrayUtils.subarray(inPinKey, 0, 8);
    		//right key
    		byte[] rKey = ArrayUtils.subarray(inPinKey, 8, 16);
    				
    		/* xorPin 处理 */
    		byte[] xorPin = funStringToBcd(String.format("%02d%-14s", pinData.length(), pinData).replace(' ', 'F').toCharArray());
    		/* xorPan 处理*/
    		byte[] xorPan = funStringToBcd(String.format("0000%12s", cardNo.substring(cardNo.length()-13, cardNo.length()-1)).toCharArray());
    		/* xorData 处理*/
    		byte[] xorData = new byte[8];
    		for(int i=0; i<8; i++){
    			xorData[i] = (byte) (xorPin[i] ^ xorPan[i]);
    		}
    		
    		/* 1、ECB-DES加密  left key */
    		byte[] ecbEncryptReturn = ecbEncrypt(xorData, lKey);
    //		System.out.println(funByteToHexString(xorData) + " " + funByteToHexString(lKey));
    		
    		/* 2、 ECB-DES解密  right key */
    		byte[] ecbDecryptReturn = ecbDecrypt(ecbEncryptReturn, rKey);
    //		System.out.println(funByteToHexString(ecbEncryptReturn) + " " + funByteToHexString(rKey));
    	
    		/* 3、 ECB-DES加密  left key */
    		ecbEncryptReturn = ecbEncrypt(ecbDecryptReturn, lKey);
    //		System.out.println(funByteToHexString(ecbDecryptReturn) + " " + funByteToHexString(lKey));
    				
    		return funByteToHexString(ecbEncryptReturn);
    	}
    
    	public static void main(String[] args){
    //		 mac 测试 
    		String macBuf = analogMacBy3Des("FE9B757CFBA18CFE51E36431F1B6D652", "cardno:5123160028455874&mername:小明公司");
    		System.out.println(macBuf);
    		
    //		 pin 测试 
    		 String pinBuf = analogPinEncrypt("92BC5DA70DC46E9E8A380E2F85105EF8", "5123160028455874", "369");
    		 System.out.println(pinBuf);
    
    //		 workKey解密
    		 String workkeyBuf = analogDecryptWorkingKey("33333333333234543422222222222222", "CDEECF47CF0EEBE879D7270EAF5036D9");
    		 System.out.println(workkeyBuf);
    		 
    //		 计算校验值
    		 String chKeyBuf = getCheckValueOfKey("92BC5DA70DC46E9E8A380E2F85105EF8");
    		 System.out.println(chKeyBuf);
    	}
    }
    

    如果这篇文章对你有用,欢迎您阅读

    如果这篇文章内容有错误,欢迎您指出

    如果您想转载,请注明出处

    如果对本文有意见或者建议,欢迎您留言

    本文版权归作者和CSDN共有,欢迎转载,但未经作者同意,您必须保留此段声明,且在文章页面明显位置给出原文链接,否则作者保留追究法律责任的权利。

    展开全文
  • DES算法

    千次阅读 2019-09-25 07:50:36
    文章目录什么是DESDES的加密解密DES工作原理Feistel 网络的...DES之前一直使用很普遍,但是随着计算机的进步,现在DES已经可以被暴力破解了,处理历史的原因外,我们不再建议使用DES算法。 DES的加密解密 DES的密...

    什么是DES

    DES全称叫(Data Encryption Standard), 是1977年美国联邦信息处理标准(FIPS)中所采用的一种对称加密算法。

    DES之前一直使用很普遍,但是随着计算机的进步,现在DES已经可以被暴力破解了,处理历史的原因外,我们不再建议使用DES算法。

    DES的加密解密

    DES的密钥长度是64比特,也就是8个字节。但是DES每隔7
    比特会设置一个错误校验位,所以真正的密钥长度是56比特。

    因为DES的长度是64比特,他每次只能将长度为64比特的原文进行加密,如果原文长于64比特的话,需要多次分组进行加密,这64比特的单位也叫做分组。

    分组密码(block cipher)就是以分组为单位进行加密的算法。

    其加密解密的示意图如下:

    DES加密

    明文64bits
    密文64bits
    密钥56bits
    DES加密

    DES解密

    密文64bits
    明文64bits
    密钥56bits
    DES解密

    DES工作原理

    DES是由Horst Feistel设计的,因此也称作Feistel网络。

    Feistel网络,加密的各个步骤称为轮(round),整个加密过程就是进行若干轮的循环。

    下图展示了DES中的一轮加密过程:

    左侧32bits
    XOR运算
    加密后的左侧32bits
    子密钥
    轮函数f
    右侧32bits
    复制
    右侧32bits

    由上图我们可以看到,在每一轮的操作中,输入的数据被分成左右两部分,中间的子密钥是指本轮加密所使用的密钥。在Feistel网络中,每一轮都使用不同的密钥,该密钥只是一个局部密钥,所以被称为子密钥。

    其运算步骤如下:

    1. 将输入的数据分成左右两部分
    2. 将输入的右边直接发送到输出的右边
    3. 将输入的右边发送到轮函数f
    4. 轮函数根据右侧数据和子密钥计算出一个随机数
    5. 将4得到的随机数和左侧数据进行XOR运算,将运算后的结果作为加密的左侧。

    我们可以看到这一轮操作,只加密了左侧数据,右侧的没有加密,然后我们可以交换左右两侧的数据,再来一轮加密。这样右侧的数据也被加密了。

    怎么解密

    上面我们讲到了加密的过程,接下来我们再看一下解密的过程。

    在一次性密码本中,我们讲到了XOR的特性,即:

    A XOR B = C
    C XOR B = A

    按照这样的特性,我们只需要将加密后的结果跟步骤4中计算出来的随机数再做一次XOR运算即可还原加密前的数据。

    如下图所示:

    左侧32bits
    XOR运算
    加密后的左侧32bits
    子密钥
    轮函数f
    右侧32bits
    复制
    右侧32bits
    加密后的左侧32bits
    XOR运算
    左侧32bits
    右侧32bits
    右侧32bits
    子密钥
    轮函数f
    复制

    Feistel 网络的特定

    我们可以看到Feistel网络有如下几个特定:

    1. Feistel网络的轮数可以任意增加。不论多少轮都可以正常解密。
    2. 解密与轮函数f无关,轮函数f也不需要有逆函数。轮函数可以设计得足够复制。
    3. 加密和解密可以使用完全相同的结构来实现。从上面我们讲到的可以看到,加密和解密其实是没有什么区别的。

    三重DES

    因为DES现在可以很容易被暴力破解,所以开发出了三重DES算法。

    三重DES就是将DES的算法重复三次得到的一种密码算法。其加密机制如下:

    DES加密
    DES解密
    DES加密
    密文
    明文
    DES密钥1
    DES密钥2
    DES密钥3

    由上图所示,3重DES的密钥长度是3*64bits。

    并且是 加密->解密->加密的过程。 在两个加密中加入了一个解密过程。

    这个是为了兼容普通的DES算法,如果将3个DES密钥保持一致,这样3重DES算法等于普通的DES算法了。

    更多精彩内容且看:

    更多教程请参考 flydean的博客

    展开全文
  • DES算法& AES算法.ppt

    2019-09-09 12:42:51
    1977年颁布的数据加密标准DES算法,56位长的密码空间在芯片技术和计算技术高速发展的今天,越来越不适应安全需求。 1997年9月,美国国家标准技术研究所(NIST)提出了征求新的加密标准---AES(Advanced Encryption ...
  • 可以方面进行单des加密,解密,三DES加密,解密。使用方面。绿色安装。
  • DES算法和Mac算法

    2016-04-21 10:34:00
    关于DES和3DES算法,网上有很多实现和代码,也有在线的DES转换工具,也有下载下来的DES计算小工具,但是理解还不深,这里是工作需要使用,百度以后整理了一下: 关于DES和3DES 1 package com.hm.com.util; 2 ...

    关于DES和3DES算法,网上有很多实现和代码,也有在线的DES转换工具,也有下载下来的DES计算小工具,但是理解还不深,这里是工作需要使用,百度以后整理了一下:

    关于DES和3DES

      1 package com.hm.com.util;
      2 
      3 import java.security.spec.KeySpec;
      4 
      5 import javax.crypto.Cipher;
      6 import javax.crypto.SecretKey;
      7 import javax.crypto.SecretKeyFactory;
      8 import javax.crypto.spec.DESKeySpec;
      9 import javax.crypto.spec.DESedeKeySpec;
     10 
     11 /**
     12  * simple introduction
     13  * 
     14  * <p>
     15  * detailed comment
     16  * @author zjj 2016-4-12
     17  * @see
     18  * @since 1.0
     19  */
     20 public class DesUtils
     21 {
     22     
     23     static String DES = "DES/ECB/NoPadding";
     24     static String TriDes = "DESede/ECB/NoPadding";
     25 
     26     /**
     27      * 把16进制字符串转换成字节数组
     28      * @param hex
     29      * @return
     30      */
     31     public static byte[] hexStringToBytes(String hex)
     32     {
     33         int len = (hex.length() / 2);
     34         byte[] result = new byte[len];
     35         char[] achar = hex.toCharArray();
     36         for (int i = 0; i < len; i++)
     37         {
     38             int pos = i * 2;
     39             result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));
     40         }
     41         return result;
     42     }
     43 
     44     /**
     45      * 把字节数组转化为16进制字符串
     46      * @param bytes byte[]
     47      * @return String
     48      */
     49     public static String bytesToHexString(byte[] bytes)
     50     {
     51         String ret = "";
     52         for (int i = 0; i < bytes.length; i++)
     53         {
     54             String hex = Integer.toHexString(bytes[i] & 0xFF);
     55             if (hex.length() == 1)
     56             {
     57                 hex = '0' + hex;
     58             }
     59             ret += hex.toUpperCase();
     60         }
     61         return ret;
     62     }
     63     
     64     /**
     65      * 将字符转化为字节
     66      * @param c
     67      * @return
     68      * @author zjj 2016-4-12
     69      * @since 1.0
     70      */
     71     private static byte toByte(char c)
     72     {
     73         byte b = (byte) "0123456789ABCDEF".indexOf(c);
     74         return b;
     75     }
     76     
     77     /**单DES加密算法
     78      * <p>如果参数是字符串,请先用{@link DesUtils.hexStringToByte}转换为字节数组
     79      * @param key 密钥,字节数组,长度为8
     80      * @param data 待加密的源数据,字节数组
     81      * @return
     82      * @author zjj 2016-4-12
     83      * @since 1.0
     84      */
     85     public static byte[] des_encrypt(byte key[], byte data[]) {
     86         try {
     87             KeySpec ks = new DESKeySpec(key);
     88             SecretKeyFactory kf = SecretKeyFactory.getInstance("DES");
     89             SecretKey ky = kf.generateSecret(ks);
     90             Cipher c = Cipher.getInstance(DES);
     91             c.init(Cipher.ENCRYPT_MODE, ky);
     92             return c.doFinal(data);
     93         } catch (Exception e) {
     94             e.printStackTrace();
     95             return null;
     96         }
     97     }
     98     
     99     /**单DES解密算法
    100      * <p>如果参数是字符串,请先用{@link DesUtils.hexStringToByte}转换为字节数组
    101      * @param key 密钥,字节数组,长度为8
    102      * @param data 待加密的源数据,字节数组
    103      * @return
    104      * @author zjj 2016-4-12
    105      * @since 1.0
    106      */
    107     public static byte[] des_decrypt(byte key[], byte data[]) {
    108         try {
    109             KeySpec ks = new DESKeySpec(key);
    110             SecretKeyFactory kf = SecretKeyFactory.getInstance("DES");
    111             SecretKey ky = kf.generateSecret(ks);
    112 
    113             Cipher c = Cipher.getInstance(DES);
    114             c.init(Cipher.DECRYPT_MODE, ky);
    115             return c.doFinal(data);
    116         } catch (Exception e) {
    117             e.printStackTrace();
    118             return null;
    119         }
    120     }
    121     
    122     /**
    123      * 3DES加密算法
    124      * @param keyStr String类型的密钥,在方法中会自动转化为字节数组 
    125      * @param data byte[]待加密的源数据 
    126      * @return byte[] 加密后的字节数组
    127      * @author zjj 2016-4-12
    128      * @since 1.0
    129      */
    130     public static byte[] trides_encrypt(String keyStr, byte data[]) {
    131         
    132         return trides_encrypt(hexStringToBytes(keyStr),data);
    133         
    134     }
    135     /**
    136      * 3DES加密算法
    137      * @param keyStr String类型的密钥,在方法中会自动转化为字节数组 
    138      * @param dataStr String类型的密钥,在方法中会自动转化为字节数组 
    139      * @return byte[] 加密后的字节数组
    140      * @author zjj 2016-4-12
    141      * @since 1.0
    142      */
    143     public static byte[] trides_encrypt(String keyStr, String dataStr) {
    144         
    145         return trides_encrypt(hexStringToBytes(keyStr),hexStringToBytes(dataStr));
    146         
    147     }
    148     /**
    149      * 3DES加密算法
    150      * <p>如果参数是字符串,请先用{@link DesUtils.hexStringToByte}转换为字节数组
    151      * @param key byte[]密钥,字节数组,长度固定为24
    152      * @param data byte[]待加密的源数据 
    153      * @return byte[] 加密后的字节数组
    154      * @author zjj 2016-4-12
    155      * @since 1.0
    156      */
    157     public static byte[] trides_encrypt(byte key[], byte data[]) {
    158         try {
    159             byte[] k = new byte[24];
    160 
    161             int len = data.length;
    162             if(data.length % 8 != 0){
    163                 len = data.length - data.length % 8 + 8;
    164             }
    165             byte [] needData = null;
    166             if(len != 0)
    167                 needData = new byte[len];
    168             
    169             for(int i = 0 ; i< len ; i++){
    170                 needData[i] = 0x00;
    171             }
    172             
    173             System.arraycopy(data, 0, needData, 0, data.length);
    174             
    175             if (key.length == 16) {
    176                 System.arraycopy(key, 0, k, 0, key.length);
    177                 System.arraycopy(key, 0, k, 16, 8);
    178             } else {
    179                 System.arraycopy(key, 0, k, 0, 24);
    180             }
    181 
    182             KeySpec ks = new DESedeKeySpec(k);
    183             SecretKeyFactory kf = SecretKeyFactory.getInstance("DESede");
    184             SecretKey ky = kf.generateSecret(ks);
    185 
    186             Cipher c = Cipher.getInstance(TriDes);
    187             c.init(Cipher.ENCRYPT_MODE, ky);
    188             return c.doFinal(needData);
    189         } catch (Exception e) {
    190             e.printStackTrace();
    191             return null;
    192         }
    193     }
    194     
    195     /**
    196      * 3DES解密算法
    197      * @param keyStr String类型的密钥,在方法中会自动转化为字节数组 
    198      * @param data byte[]待加密的源数据 
    199      * @return byte[] 加密后的字节数组
    200      * @author zjj 2016-4-12
    201      * @since 1.0
    202      */
    203     public static byte[] trides_decrypt(String keyStr, byte data[]) {
    204         
    205         return trides_encrypt(hexStringToBytes(keyStr),data);
    206         
    207     }
    208     /**
    209      * 3DES解密算法
    210      * @param keyStr String类型的密钥,在方法中会自动转化为字节数组 
    211      * @param dataStr String类型的密钥,在方法中会自动转化为字节数组 
    212      * @return byte[] 加密后的字节数组
    213      * @author zjj 2016-4-12
    214      * @since 1.0
    215      */
    216     public static byte[] trides_decrypt(String keyStr, String dataStr) {
    217         
    218         return trides_encrypt(hexStringToBytes(keyStr),hexStringToBytes(dataStr));
    219         
    220     }
    221     /**
    222      * 3DES解密算法
    223      * <p>如果参数是字符串,请先用{@link DesUtils.hexStringToByte}转换为字节数组
    224      * @param key byte[]密钥,字节数组,长度固定为24
    225      * @param data byte[]待加密的源数据 
    226      * @return byte[] 加密后的字节数组
    227      * @author zjj 2016-4-12
    228      * @since 1.0
    229      */
    230     public static byte[] trides_decrypt(byte key[], byte data[]) {
    231         try {
    232             byte[] k = new byte[24];
    233 
    234             int len = data.length;
    235             if(data.length % 8 != 0){
    236                 len = data.length - data.length % 8 + 8;
    237             }
    238             byte [] needData = null;
    239             if(len != 0)
    240                 needData = new byte[len];
    241             
    242             for(int i = 0 ; i< len ; i++){
    243                 needData[i] = 0x00;
    244             }
    245             
    246             System.arraycopy(data, 0, needData, 0, data.length);
    247             
    248             if (key.length == 16) {
    249                 System.arraycopy(key, 0, k, 0, key.length);
    250                 System.arraycopy(key, 0, k, 16, 8);
    251             } else {
    252                 System.arraycopy(key, 0, k, 0, 24);
    253             }
    254             KeySpec ks = new DESedeKeySpec(k);
    255             SecretKeyFactory kf = SecretKeyFactory.getInstance("DESede");
    256             SecretKey ky = kf.generateSecret(ks);
    257             Cipher c = Cipher.getInstance(TriDes);
    258             c.init(Cipher.DECRYPT_MODE, ky);
    259             return c.doFinal(needData);
    260         } catch (Exception e) {
    261             e.printStackTrace();
    262             return null;
    263         }
    264     }
    265 
    266 }

    关于MAc算法

      1 package com.hm.com.util;
      2 
      3 import java.util.Arrays;
      4 
      5 /**
      6  * Mac工具类,采用ECB算法
      7  * @author zjj
      8  */
      9 public class MacEcbUtils
     10 {
     11     public static byte[] IV = new byte[8];
     12 
     13     /**
     14      * 两个字节异或
     15      * @param src
     16      * @param src1
     17      * @return
     18      * @author Administrator 2016-4-12
     19      * @since 1.0
     20      */
     21     public static byte byteXOR(byte src, byte src1)
     22     {
     23         return (byte) ((src & 0xFF) ^ (src1 & 0xFF));
     24     }
     25 
     26     /**
     27      * 分别将两个数组中下标相同的字节进行异或
     28      * <p>要求数组长度一致
     29      * @param src
     30      * @param src1
     31      * @return
     32      * @author Administrator 2016-4-12
     33      * @since 1.0
     34      */
     35     public static byte[] bytesXOR(byte[] src, byte[] src1)
     36     {
     37         int length = src.length;
     38         if (length != src1.length)
     39         {
     40             return null;
     41         }
     42         byte[] result = new byte[length];
     43         for (int i = 0; i < length; i++)
     44         {
     45             result[i] = byteXOR(src[i], src1[i]);
     46         }
     47         return result;
     48     }
     49 
     50     /**
     51      * mac计算,数据不为8的倍数,需要补0(64bit的mac算法)
     52      * <p>具体的步骤如下:
     53      * <p>1.源字节数组的长度应为8的倍数,否则补零至8的倍数,按8个字节分段(d0,d1,d2...)
     54      * <p>2.密钥key字节数组长度固定是8
     55      * <p>3.将key与第一段d0进行des[加密]运算,得到e1
     56      * <p>4.e1与d2进行异或运算得到x1
     57      * <p>5.key再与x1进行des[加密]运算,得到e2
     58      * <p>6.e2在于d3进行异或运算得到x2
     59      * <p>7.key再与x2进行des[加密],依次进行,直到将源数组加密完毕,最后的到的字节数组即是mac值
     60      * 
     61      * <p>如果参数是字符串,请先用{@link DesUtils.hexStringToByte}转换为字节数组
     62      * @param key 密钥,字节数组长度应为16,多于16将会截取前16位,少于16位则补0
     63      * @param srcData 源数据
     64      * @return
     65      * @throws Exception 
     66      */
     67     public static byte[] computeMac(byte[] key, byte[] srcData) throws Exception
     68     {
     69         int length = srcData.length;
     70         int x = length % 8;
     71         int addLen = 0;
     72         if (x != 0)
     73         {
     74             addLen = 8 - length % 8;
     75         }
     76         int pos = 0;
     77         //保证data是8的倍数
     78         byte[] data = new byte[length + addLen];
     79         //data的值就是源数组的值(包括补零的值)
     80         System.arraycopy(srcData, 0, data, 0, length);
     81         //源数组第一段8字节
     82         byte[] oper1 = new byte[8];
     83         System.arraycopy(data, pos, oper1, 0, 8);
     84         pos += 8;
     85         //用于存储每段字节与ka加密后的结果数组
     86         byte[] be = new byte[8];
     87         for (int i = 0; i < data.length / 8; i++)
     88         {
     89             //将第一段oper1与ka进行des加密,得到be
     90             be = DesUtils.des_encrypt(key,oper1);
     91             
     92             if((i+1)*8 < data.length){
     93                 //将加密结果e1与第二段oper2异或
     94                 byte[] oper2 = new byte[8];
     95                 System.arraycopy(data, pos, oper2, 0, 8);
     96                 //得到异或结果bx
     97                 byte[] bx = bytesXOR(be, oper2);
     98                 oper1 = bx;
     99                 pos += 8;
    100             }
    101         }
    102         return be;
    103     }
    104     
    105     /**
    106      * mac计算,数据不为8的倍数,需要补0(128bit的mac算法)
    107      * <p>具体的步骤如下:
    108      * <p>1.源字节数组的长度应为8的倍数,否则补零至8的倍数,按8个字节分段(d0,d1,d2...)
    109      * <p>2.密钥key字节数组长度固定是16,分为左右两部分(ka,kb)
    110      * <p>3.左半部分ka与第一段d0进行des[加密]运算,得到e1
    111      * <p>4.e1与d2进行异或运算得到x1
    112      * <p>5.ka再与x1进行des[加密]运算,得到e2
    113      * <p>6.e2在于d3进行异或运算得到x2
    114      * <p>7.ka再与x2进行des[加密],依次进行,直到将源数组加密完毕,假设最后得到字节数组dn
    115      * <p>8.用密钥的后半部分kb与dn进行des[解密]运算,得到p1
    116      * <p>9.最后使用ka与p1进行des[加密]得到最后的mac值
    117      * 
    118      * <p>如果参数是字符串,请先用{@link DesUtils.hexStringToByte}转换为字节数组
    119      * @param key 密钥,字节数组长度应为16,多于16将会截取前16位,少于16位则补0
    120      * @param srcData 源数据
    121      * @return
    122      * @throws Exception 
    123      */
    124     public static byte[] computeMac_128(byte[] key, byte[] srcData) throws Exception
    125     {
    126         int klen = key.length;
    127         byte[] ka = new byte[8];
    128         byte[] kb = new byte[8];
    129         byte[] temp = new byte[16];
    130         //判断key的长度,主要是确定key的左右两部分
    131         if(klen < 16){
    132             System.arraycopy(key, 0, temp, 0, key.length);
    133             System.arraycopy(temp, 0, ka, 0, 8);
    134             System.arraycopy(temp, 8, kb, 0, 8);
    135         } else {
    136             System.arraycopy(key, 0, ka, 0, 8);
    137             System.arraycopy(key, 8, kb, 0, 8);
    138         }
    139         
    140         int length = srcData.length;
    141         int x = length % 8;
    142         int addLen = 0;
    143         if (x != 0)
    144         {
    145             addLen = 8 - length % 8;
    146         }
    147         int pos = 0;
    148         //保证data是8的倍数
    149         byte[] data = new byte[length + addLen];
    150         //data的值就是源数组的值(包括补零的值)
    151         System.arraycopy(srcData, 0, data, 0, length);
    152         //源数组第一段8字节
    153         byte[] oper1 = new byte[8];
    154         System.arraycopy(data, pos, oper1, 0, 8);
    155         pos += 8;
    156         //用于存储每段字节与ka加密后的结果数组
    157         byte[] be = new byte[8];
    158         for (int i = 0; i < data.length / 8; i++)
    159         {
    160             //将第一段oper1与ka进行des加密,得到be
    161             be = DesUtils.des_encrypt(ka,oper1);
    162             
    163             if((i+1)*8 < data.length){
    164                 //将加密结果e1与第二段oper2异或
    165                 byte[] oper2 = new byte[8];
    166                 System.arraycopy(data, pos, oper2, 0, 8);
    167                 //得到异或结果bx
    168                 byte[] bx = bytesXOR(be, oper2);
    169                 oper1 = bx;
    170                 pos += 8;
    171             }
    172         }
    173         
    174         //将最后加密的be与kb进行解密,得到dd
    175         byte[] bb = new byte[8];
    176         bb = DesUtils.des_decrypt(kb, be);
    177         
    178         //最后将bb与ka进行加密,得到mac值
    179         // 取8个长度字节
    180         byte[] retBuf = new byte[8];
    181         retBuf = DesUtils.des_encrypt(ka,bb);
    182         return retBuf;
    183     }
    184 
    185     public static void main(String[] args) throws Exception
    186     {
    187         byte[] buff = DesUtils.hexStringToBytes("0200603804003081100D196228481610460005310031000000049000393404070901376228481610460005310D4912120481237000000104996228481610460551810D156156000000000000000000000011414144912DD000000000000D000000000000D027255100000000313330323839363300074143435459504598A5D201AED5C3FD00733131313135353531313135353130303030303030303030323931353635303130303039373331353635303130303130303031353635303130303130303030303030303030303030303000474142434836343431343130303030303035303030303031303330303330333039393330333036303130323433333330");
    188         byte[] keys = DesUtils.hexStringToBytes("0000000000000000");
    189         
    190         byte[] result = computeMac(keys, buff);
    191         
    192         System.out.println("加密结果:"+DesUtils.bytesToHexString(result));
    193         System.out.println(Arrays.toString(result));
    194     }
    195 }

     

    测试类:

     1 package com.hm.com.util;
     2 
     3 import java.util.Arrays;
     4 
     5 import com.hm.com.util.string.HexConvertUtil;
     6 
     7 /**
     8  * simple introduction
     9  *
    10  * <p>detailed comment
    11  * @author Administrator 2016-4-12
    12  * @see
    13  * @since 1.0
    14  */
    15 public class CheckMac
    16 {
    17     public static void main(String[] args) throws Exception
    18     {
    19         String sss = computeMac("s");
    20         System.out.println(sss);
    21     }
    22 
    23     public static String computeMac(String reqStr) throws Exception{
    24         String mac = "";
    25 //        reqStr = "0200603804003080100D196228480028219036671031000000030709210703300921376228480028219036671D2310220343103000000104996228480028219036671D156156000000000000000000000021414142310DD000000000000D000000000000D04591010000000030303030303030303B749E4512BCD90500733131303135353531314435353120202030303034313030303031353635303233343039373931353635303233343130303031353635303233343130303030303030303030313030303000474142434836343431313730303030303035303030303031303330303330333039393330333036303130323433333330";
    26         System.out.println("待计算的报文数据:(长度:" + reqStr.length()+ ")"+reqStr);
    27         
    28         //将63域mac转化为字节数组(此算法默认字符串是16进制表示)
    29         byte[] srcs = HexConvertUtil.hexStrToBytes("1234567890123456");
    30         System.out.println("源字节数组长度:" + srcs.length);
    31         
    32         //获取加解密的key字符串
    33         String keyStr = "000000000000000000000000000000000000000000000000";
    34         //将源数据转化为字节数组(此算法默认字符串是16进制表示)
    35         byte[] keys = HexConvertUtil.hexStrToBytes(keyStr);
    36         System.out.println("密钥字符串长度为:" + keyStr.length() + "-->转化为字节数组后长度:" + keys.length);
    37         
    38         //执行解密
    39         byte[] reqKey = DesUtils.trides_decrypt(keys, srcs);
    40         System.out.println("解密结果:" + DesUtils.bytesToHexString(reqKey));
    41         
    42         byte[] srcData = HexConvertUtil.hexStrToBytes(reqStr);
    43         byte[] result = MacEcbUtils.computeMac(reqKey, srcData);
    44         
    45         mac = DesUtils.bytesToHexString(result);
    46         System.out.println("计算得到的mac结果:" + mac);
    47         
    48         return mac;
    49     }
    50 
    51 }

     

    后面有时间还要再整理一下~!

     

    转载于:https://www.cnblogs.com/seguzhizi/p/5415971.html

    展开全文
  • DES算法应用

    2013-06-11 22:24:22
    计算机信息安全中关于DES算法。美国IBM公司W. Tuchman 和 C. Meyer 1971-1972年研制成功。1967年美国Horst Feistel提出的理论。 美国国家标准局(NBS)1973年5月到1974年8月两次发布通告,公开征求用于电子计算机的...
  • 1973 年 5 月 15 日美国国家标准局 现在美国国家标准技术研究所 NIST 在联邦注册报上发表一则启事 公开征集用来保护传输和静止存储中的计算机数 据的密码算法这一举措最终导致了数据加密标准 DES 的出现 DES 采用...
  • 3Des算法

    2015-08-19 10:40:14
    3DES算法     1977年1月,美国政府颁布:采纳IBM公司设计的方案作为非机密数据的正式数据加密标 准(Data Encryption Standard)。 先来讲讲DES加密: 首先,这个算法全程是按位运算...
  • DES 加密算法;3DES 加密算法;数据传输安全控制的基本要求;数据加密传输环境的基本要求;各层次密钥简介;密钥的产生;密钥保存示意图;PIN的加密和解密;PIN BLOCK ;PIN BLOCK;PIN的加密方法;联机报文 MAC 的计算方法 ;...
  • 3DES算法

    2014-05-19 11:12:41
    上周帮leojay看3DES算法,讲讲这个算法是如何进行的:)  先来讲讲DES加密:  首先,这个算法全程是按位运算的,每次计算64位的内容,也就是8个字节。密钥Key,为64位。  我们把内容经过一
  • Go-Des和3Des算法详解与代码

    万次阅读 2021-06-03 21:12:12
    Des 发展史 1973年5月美国联邦政府提出征求在传输和存储数据中保护计算机数据的密码算法的建议;1975年3月,美国国家标准局(NBS)首次公布IBM公司提出的算法Lucifer中选;1977年1月NBS正式向社会公布,采纳IBM...
  • DES\3DES\MAC计算算法源码(JAVA)

    热门讨论 2012-04-25 14:13:21
    实际使用着的JAVA版本的DES\3DES算法源码
  • DES算法作业 Java实现

    2020-12-02 21:14:43
    ① 统计DES算法在密钥固定情况,输入明文改变1位、2位,。。。64位时。输出密文位数改变情况。 ② 统计DES算法在明文固定情况,输入密钥改变1位、2位,。。。64位时。输出密文位数改变情况。 注:为了具有客观性,①...
  • DES算法C++实现

    2010-06-04 23:17:11
    DES加密算法的C++实现,包含了加密和解密算法的时间的计算
  • 银联计算DES与MAC算法工具

    热门讨论 2009-08-26 15:13:22
    银联计算DES与MAC算法工具,银联计算DES与MAC算法工具
  • des算法的BCB实现

    2011-12-22 11:20:49
    DES算法把64位的明文输入块变为数据长度为64位的密文输出块,其中8位为奇偶校验位,另外56位作为密码的长度。首先,DES把输入的64位数据块按位重新组合,并把输出分为L0、R0两部分,每部分各长32位,并进行前后置换...
  • DES算法加密解密文件

    2010-04-29 11:49:42
    DES算法加密解密1M文件,并计算加密和解密时间
  • 1973年5月15日美国国家标准局现在美国国家标准技术研究所NIST在联邦注册报上发表一则启事公开征集用来保护传输和静止存储中的计算机数据的密码算法这一举措最终导致了数据加密标准DES的出现DES采用分组乘积密码体制...
  • DES 算法及其在 VC++6.0 下的实现 摘要 本文介绍了一种国际上通用的加密算法DES 算法的原理并给出了在 VC++6.0 语言环境下实现的源代码最后给出一个示例以供参考 关键字DES 算法明文密文密钥VC 本文程序运行效果图...
  • DES算法详细介绍.pptx

    2020-10-10 02:10:39
    1973 年 5 月 15 日美国国家标准局现在美国国家标准技术研究所NIST在联邦注册报上...IBM 开发是对早期被称为 Lucifer 密码体制的改进 DES 在 1975 年 3 月 17 日首次在联邦记录中公布而且声明对比算法征求意见到 197
  • DES & 3DES算法

    千次阅读 2007-08-01 17:29:00
    上周帮leojay看3DES算法,讲讲这个算法是如何进行的:) 先来讲讲DES加密: 首先,这个算法全程是按位运算的,每次计算64位的内容,也就是8个字节。密钥Key,为64位。 我们把内容经过一个初始置换,就是每位按如下...
  • DES算法详细介绍.docx

    2020-02-14 13:37:57
    专业资料整理 1973 年 5 月 15 日美国国家标准局现在美国国家标准技术研究所 NIST 在联邦注册报上发表一则启事 公开征集用来保护传输和静止存储中的计算机数 据的密码算法这一举措最终导致了数据加密标准 DES 的出现...
  • DES算法S盒学习

    千次阅读 2020-08-20 04:25:07
    DES算法中替代由8个不同的S盒完成,每个S盒有6位输入4位输出。 一个S盒就是一个4行16列的表,盒中的每一项都是一个4位二进制数表示的十进制数。 输入的高低两位做为行数H,中间四位做为列数L,在S-BOX中查找...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 970
精华内容 388
关键字:

des算法计算