精华内容
下载资源
问答
  • 安全算法

    千次阅读 2016-12-18 11:48:51
    常用的安全算法主要包括数字摘要、对称加密算法、非对称加密算法、信息编码等。  一、数字摘要  数字摘要也称为消息摘要,它是唯一对应一个消息或文本的固定长度的值,它由一个单向Hash函数对消息进行计算而产生。...

            安全传输除了可以使用https,还可通过安全算法实现。常用的安全算法主要包括数字摘要、对称加密算法、非对称加密算法、信息编码等。

           一、数字摘要

          数字摘要也称为消息摘要,它是唯一对应一个消息或文本的固定长度的值,它由一个单向Hash函数对消息进行计算而产生。消息在传递中改变了,接受方

    对收到的消息采用相同的Hash重新计算,产生的摘要跟原摘要进行比较,即可知道消息是否被恶意篡改了,所以消息摘要能够验证消息的完整性。常用的数字

    摘要有MD5,SHA.

          1、MD5

    MD5即Message Digest Algorithm 5,是数字摘要的一种实现,用于确保信息传输完整性和一致性,摘要长度为128位。MD5由MD4、MD3、MD2改进而来,

    主要增强了算法复杂度和不可逆性。C#的MD5算法的参考(引用msdn):

    	public static string GetMd5Hash(string input)
            {
    		MD5 md5Hash = MD5.Create();
                	// Convert the input string to a byte array and compute the hash.            
    	  	byte[] data = md5Hash.ComputeHash(Encoding.UTF8.GetBytes(input));            
    		// Create a new Stringbuilder to collect the bytes           
     		// and create a string.            
    		StringBuilder sBuilder = new StringBuilder();            
    		// Loop through each byte of the hashed data   
                    // and format each one as a hexadecimal string.            
    		for (int i = 0; i < data.Length; i++)            
    		{                
    			sBuilder.Append(data[i].ToString("x2"));
                    }            
    		// Return the hexadecimal string.      
    		return sBuilder.ToString();     
                    }
    	 }

     2、SHA

              SHA是全称是Secure Hash Algorithm,即安全散列算法。1993年,安全散列算法(SHA)由美国国家标准和技术协会(NIST)提出,并作为联邦

    信息处理标准(FIPS    PUB 180)公布,1995年又发布了一个修订版FIPS PUB 180-1,通常称之为SHA-1,并被广泛使用。SHA-1的摘要信息长度为

    160位,由于生成的摘要信息更长,运算的      过程更加复杂,在相同的硬件上,运算速度比MD5更慢,也更为安全。C#版SHA1算法参考

            byte[] data = new byte[DATA_SIZE];
    	byte[] result; 
    
    	SHA1 sha = new SHA1CryptoServiceProvider(); 
    	// This is one implementation of the abstract class SHA1.
    	result = sha.ComputeHash(data);  


    二、对称加密

              对称加密算法是应用较早的加密算法,加解密使用相同的密钥,对称加密过程如下所示:


    对称加密算法特点是算法公开、计算量小、加密效率高,使用长密钥时难破解性,但安全性由于依赖于密钥,泄露密钥就意味着任何人都可以对加密的

    密文进行解密,因 此密钥的保护对于加密信息是否安全至关重要。常用的对称加密算法包括DES算法、3DES算法、AES算法等。

          由于计算机运算能力的增强,原版DES密码的密钥长度变得容易被暴力破解,因此演变出了3DES算法,3DES是DES向AES过渡的加密算法。

            1、DES

                   加密算法如:

               DESCryptoServiceProvider des = new DESCryptoServiceProvider();            		
               return des.CreateEncryptor(key, key).TransformFinalBlock(plain, 0, plain.Length);
            	
                   解密算法如:
               DESCryptoServiceProvider des = new DESCryptoServiceProvider();            		
               return des.CreateDecryptor(key, key).TransformFinalBlock(encrypt, 0, encrypt.Length);
        三、非对称加密

    非对称加密算法又称为公开密钥加密算法,两个密钥,一个公钥,另一个私钥。公钥与私钥需要配对使用,如果用公钥对数据进行加密,只有对应

    的私钥才能进行解密,而 如果使用私钥对数据进行加密,那只有对应的公钥才能解密。由于加密和解密使用的是两个不同的密钥,所以这种算法称

    为非对称加密算法。具体过程如下图所示:

         


    非对称加密算法特点:对称加密算法只有一种密钥,并且是非公开的,若要解密则需要对方知道密钥,所以保证其安全性就是保证密钥的安全,而

    一旦密钥在传输过程中泄露加密信息就不再安全。而非对称加密算法包含两种密钥,其中一个是公开的,这样不需要像对称加密算法那样,需要传

    输密钥给对方进行数据加密了,大大提高了加密算法的安全性。非对称加密算法能够保证,即使在获知公钥、加密算法和加密源代码的情况下,也

    无法获知公钥对应的私钥,因此也无法对公钥加密的密文进行解密。

    由于非对称加密算法的复杂性,使得其加密解密速度远没有对称加密解密那么快,为了解决该问题,一般都是使用对称和非对称结合使用的办法,

    优缺点互补,达到时间和安全的平衡:对称加密较长的文件,然后用非对称加密算法给文件密钥加密,解决了对称加密算法密钥分发问题。

    当前使用最为广泛的非对称加密算法是RSA算法。

     


           

    展开全文
  • 张新鹏教授的算法是加密域可逆信息隐藏经典算法以下简称Zhang算法,本篇文章首先介绍Zhang算法流程,然后介绍Zhang算法的严重BUG,即安全性问题。 一、Zhang算法简介: 1、图像加密:采用异或加密原始图像。 2、...

    本篇文章介绍加密域可逆信息隐藏经典算法----张新鹏教授的《Reversible data hiding in encrypted image》
    张新鹏教授的算法是加密域可逆信息隐藏经典算法以下简称Zhang算法,本篇文章首先介绍Zhang算法流程,然后介绍Zhang算法的严重BUG,即安全性问题。
    一、Zhang算法简介:
    算法流程图
    1、图像加密:采用异或加密原始图像。
    2、信息隐藏:数据嵌入, 首先,将加密图像分割成由S*S大小的多个非重叠块。 然后,每个块将被用于携带一个附加位。对于每个块,将像素伪随机划分成两组S0和S1. 这里,像素属于S0或S1的概率为1/2。 如果要嵌入的附加位为0,则翻转S0中每个加密像素的3个最低有效位(LSB)。如果附加位为1,则翻转S1中的3个加密LSB像素其他加密数据不做更改。具体过程如下图:
    在这里插入图片描述
    3、信息提取:由波动函数在这里插入图片描述
    进行计算提取,信息提取过程用下图表示:
    在这里插入图片描述
    4、图像解密:异或解密
    实验结果:
    在这里插入图片描述
    数据提取及内容恢复性能依赖于分块大小 , 在Zhang所提出的方案中,块大小越小,可以嵌入更多的附加数据。 然而,失败的位提取和图像恢复的风险上升,当块的边长大于32时,对于大多数封面图像,所有嵌入的位都可以正确地进行,原始图像可以被成功地恢复。

    二、Zhang算法的安全性问题——异或加密之唯密文攻击。
    Zhang算法采用异或加密,无法抵抗唯密文攻击。对原始测试图像分别用异或加密。加密后的图像如下图。
    在这里插入图片描述
    在这里插入图片描述
    可以看出XOR(异或)加密完全遮掩了原始图像内容。似乎加密效果良好。下面我们用唯密文攻击来进行测试其加密图像。
    选取测试图像中的Lena、Airplane、Barbara对其分别提取采样像素的高八位,分别采用XOR加密。对加密后的高八位图像使用COA(唯密文)攻击。从下图可以看出,仅使用异或加密,用COA攻击方法选取10幅已知图像便可破解加密图像,破解后的图像可以清晰辨认出原始图像,泄露了大量明文内容。
    在这里插入图片描述
    关于针对异或加密的COA攻击算法,下期更新。

    展开全文
  • 常见的安全算法

    万次阅读 2017-03-28 10:00:36
    本文整理了常见的安全算法,包括MD5、SHA、DES、AES、RSA等,并写了完整的工具类(Java 版),工具类包含测试。一、数字摘要算法 数字摘要也称为消息摘要,它是一个唯一对应一个消息或文本的固定长度的值,它由一个...

    本文整理了常见的安全算法,包括MD5、SHA、DES、AES、RSA等,并写了完整的工具类(Java 版),工具类包含测试。

    一、数字摘要算法

    数字摘要也称为消息摘要,它是一个唯一对应一个消息或文本的固定长度的值,它由一个单向Hash函数对消息进行计算而产生。如果消息在传递的途中改变了,接收者通过对收到消息采用相同的Hash重新计算,新产生的摘要与原摘要进行比较,就可知道消息是否被篡改了,因此消息摘要能够验证消息的完整性。消息摘要采用单向Hash函数将需要计算的内容"摘要"成固定长度的串,这个串亦称为数字指纹。这个串有固定的长度,且不同的明文摘要成密文,其结果总是不同的(相对的),而同样的明文其摘要必定一致。这样这串摘要便可成为验证明文是否是"真身"的"指纹"了。

    1. Md5

    MD5即Message Digest Algorithm 5(信息摘要算法5),是数字摘要算法一种实现,用于确保信息传输完整性和一致性,摘要长度为128位。 MD5由MD4、 MD3、 MD2改进而来,主要增强算法复杂度和不可逆性,该算法因其普遍、稳定、快速的特点,在产业界得到了极为广泛的使用,目前主流的编程语言普遍都已有MD5算法实现。

    import java.security.MessageDigest;
    import java.security.NoSuchAlgorithmException;
    
    /**
     * Message Digest Algorithm 5(信息摘要算法5)
     */
    public class MD5Util {
    	/**
    	 * Constructs the MD5Util object and sets the string whose MD5Util is to be
    	 * computed.
    	 * 
    	 * @param inStr
    	 *    the <code>String</code> whose MD5Util is to be computed
    	 */
    	
    	
    	public final static String COMMON_KEY="zhongzhuoxin#@!321";
    	public MD5Util() {
    
    	}
    
    	public final static String str2MD5(String inStr) {
    		char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
    				'a', 'b', 'c', 'd', 'e', 'f' };
    		try {
    			byte[] strTemp = inStr.getBytes("UTF-8");
    			MessageDigest mdTemp = MessageDigest.getInstance("MD5");
    			mdTemp.update(strTemp);
    			byte[] md = mdTemp.digest();
    			int j = md.length;
    			char str[] = new char[j * 2];
    			int k = 0;
    			for (int i = 0; i < j; i++) {
    				byte byte0 = md[i];
    				str[k++] = hexDigits[byte0 >>> 4 & 0xf];
    				str[k++] = hexDigits[byte0 & 0xf];
    			}
    			return new String(str);
    		} catch (Exception e) {
    			return null;
    		}
    	}
    	
    	
    	
    
    	//--MD5Util
    	private static final char HEX_DIGITS[] = { '0', '1', '2', '3', '4', '5',
    			'6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
    
    	public static String toHexString(byte[] b) { // String to byte
    		StringBuilder sb = new StringBuilder(b.length * 2);
    		for (int i = 0; i < b.length; i++) {
    			sb.append(HEX_DIGITS[(b[i] & 0xf0) >>> 4]);
    			sb.append(HEX_DIGITS[b[i] & 0x0f]);
    		}
    		return sb.toString();
    	}
    
    	public static String AndroidMd5(String s) {
    		try {
    			// Create MD5Util Hash
    			MessageDigest digest = MessageDigest
    					.getInstance("MD5");
    			digest.update(s.getBytes());
    			byte messageDigest[] = digest.digest();
    
    			return toHexString(messageDigest);
    		} catch (NoSuchAlgorithmException e) {
    			e.printStackTrace();
    		}
    
    		return "";
    	}
    
    	public static void main(String[] args) {
    
    		String m = MD5Util.str2MD5("swwwwwwwwwwdkinner");
    
    		System.out.print(m.length() + "    ");
    		System.out.println(m);
    
    	}
    }
    
    

    ###2.SHA

    SHA的全称是Secure Hash Algorithm,即安全散列算法。 1993年,安全散列算法(SHA)由美国国家标准和技术协会(NIST)提出,并作为联邦信息处理标准(FIPS PUB 180)公布, 1995年又发布了一个修订版FIPS PUB 180-1,通常称之为SHA-1。 SHA-1是基于MD4算法的,现在已成为公认的最安全的散列算法之一,并被广泛使用。SHA-1算法生成的摘要信息的长度为160位,由于生成的摘要信息更长,运算的过程更加复杂,在相同的硬件上, SHA-1的运行速度比MD5更慢,但是也更为安全。

    
    
    import com.google.common.base.Strings;
    
    import java.security.MessageDigest;
    
    /**
     * SHA的全称是Secure Hash Algorithm,即安全散列算法
     * Created by fangzhipeng on 2017/3/21.
     */
    public class SHAUtil {
    
        /**
         * 定义加密方式
         */
        private final static String KEY_SHA = "SHA";
        private final static String KEY_SHA1 = "SHA-1";
        /**
         * 全局数组
         */
        private final static String[] hexDigits = { "0", "1", "2", "3", "4", "5",
                "6", "7", "8", "9", "a", "b", "c", "d", "e", "f" };
    
        /**
         * 构造函数
         */
        public SHAUtil() {
    
        }
    
        /**
         * SHA 加密
         * @param data 需要加密的字节数组
         * @return 加密之后的字节数组
         * @throws Exception
         */
        public static byte[] encryptSHA(byte[] data) throws Exception {
            // 创建具有指定算法名称的信息摘要
    //        MessageDigest sha = MessageDigest.getInstance(KEY_SHA);
            MessageDigest sha = MessageDigest.getInstance(KEY_SHA1);
            // 使用指定的字节数组对摘要进行最后更新
            sha.update(data);
            // 完成摘要计算并返回
            return sha.digest();
        }
    
        /**
         * SHA 加密
         * @param data 需要加密的字符串
         * @return 加密之后的字符串
         * @throws Exception
         */
        public static String encryptSHA(String data) throws Exception {
            // 验证传入的字符串
            if (Strings.isNullOrEmpty(data)) {
                return "";
            }
            // 创建具有指定算法名称的信息摘要
            MessageDigest sha = MessageDigest.getInstance(KEY_SHA);
            // 使用指定的字节数组对摘要进行最后更新
            sha.update(data.getBytes());
            // 完成摘要计算
            byte[] bytes = sha.digest();
            // 将得到的字节数组变成字符串返回
            return byteArrayToHexString(bytes);
        }
    
        /**
         * 将一个字节转化成十六进制形式的字符串
         * @param b 字节数组
         * @return 字符串
         */
        private static String byteToHexString(byte b) {
            int ret = b;
            //System.out.println("ret = " + ret);
            if (ret < 0) {
                ret += 256;
            }
            int m = ret / 16;
            int n = ret % 16;
            return hexDigits[m] + hexDigits[n];
        }
    
        /**
         * 转换字节数组为十六进制字符串
         * @param bytes 字节数组
         * @return 十六进制字符串
         */
        private static String byteArrayToHexString(byte[] bytes) {
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < bytes.length; i++) {
                sb.append(byteToHexString(bytes[i]));
            }
            return sb.toString();
        }
    
        /**
         * 测试方法
         * @param args
         */
        public static void main(String[] args) throws Exception {
            String key = "123";
            System.out.println(encryptSHA(key));
        }
    }
    
    

    二、对称加密

    对称加密算法是应用较早的加密算法,技术成熟。在对称加密算法中,数据发送方将明文(原始数据)和加密密钥一起经过特殊加密算法处理后,生成复杂的加密密文进行发送,数据接收方收到密文后,若想读取原文,则需要使用加密使用的密钥及相同算法的逆算法对加密的密文进行解密,才能使其恢复成可读明文。在对称加密算法中,使用的密钥只有一个,发送和接收双方都使用这个密钥对数据进行加密和解密,这就要求加密和解密方事先都必须知道加密的密钥。

    1. DES算法

    1973 年,美国国家标准局(NBS)在认识到建立数据保护标准既明显又急迫的情况下,开始征集联邦数据加密标准的方案。 1975 年3月17日, NBS公布了IBM公司提供的密码算法,以标准建议的形式在全国范围内征求意见。经过两年多的公开讨论之后, 1977 年7月15日, NBS宣布接受这建议,作为联邦信息处理标准46 号数据加密标准(Data Encryptin Standard),即DES正式颁布,供商业界和非国防性政府部门使用。DES算法属于对称加密算法,明文按64位进行分组,密钥长64位,但事实上只有56位参与DES
    运算(第8、 16、 24、 32、 40、 48、 56、 64位是校验位,使得每个密钥都有奇数个1),分组后的明文和56位的密钥按位替代或交换的方法形成密文。由于计算机运算能力的增强,原版DES密码的密钥长度变得容易被暴力破解,因此演变出了3DES算法。 3DES是DES向AES过渡的加密算法,它使用3条56位的密钥对数据进行三次加密,是DES的一个更安全的变形

    
    
    import java.io.IOException;
    import java.security.SecureRandom;
    
    import javax.crypto.Cipher;
    import javax.crypto.SecretKey;
    import javax.crypto.SecretKeyFactory;
    import javax.crypto.spec.DESKeySpec;
    
    
    import sun.misc.BASE64Decoder;
    import sun.misc.BASE64Encoder;
    
    /**
     * Data Encryptin Standard
     * 数据加密标准
     */
    public class DESUtil {
    
    
        private final static String DES = "DES";
    
        /**
         * Description 根据键值进行加密
         *
         * @param data
         * @param key  加密键byte数组
         * @return
         * @throws Exception
         */
        public static String encrypt(String data, String key) throws Exception {
            byte[] bt = encrypt(data.getBytes(), key.getBytes());
            String strs = new BASE64Encoder().encode(bt);
            return strs;
        }
    
        /**
         * Description 根据键值进行解密
         *
         * @param data
         * @param key  加密键byte数组
         * @return
         * @throws IOException
         * @throws Exception
         */
        public static String decrypt(String data, String key) throws Exception,
                Exception {
            if (data == null)
                return null;
            BASE64Decoder decoder = new BASE64Decoder();
            byte[] buf = decoder.decodeBuffer(data);
            byte[] bt = decrypt(buf, key.getBytes());
            return new String(bt);
        }
    
        /**
         * Description 根据键值进行加密
         *
         * @param data
         * @param key  加密键byte数组
         * @return
         * @throws Exception
         */
        private static byte[] encrypt(byte[] data, byte[] key) throws Exception {
            // 生成一个可信任的随机数源
            SecureRandom sr = new SecureRandom();
    
            // 从原始密钥数据创建DESKeySpec对象
            DESKeySpec dks = new DESKeySpec(key);
    
            // 创建一个密钥工厂,然后用它把DESKeySpec转换成SecretKey对象
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
            SecretKey securekey = keyFactory.generateSecret(dks);
    
            // Cipher对象实际完成加密操作
            Cipher cipher = Cipher.getInstance(DES);
    
            // 用密钥初始化Cipher对象
            cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);
    
            return cipher.doFinal(data);
        }
    
    
        /**
         * Description 根据键值进行解密
         *
         * @param data
         * @param key  加密键byte数组
         * @return
         * @throws Exception
         */
        private static byte[] decrypt(byte[] data, byte[] key) throws Exception {
            // 生成一个可信任的随机数源
            SecureRandom sr = new SecureRandom();
    
            // 从原始密钥数据创建DESKeySpec对象
            DESKeySpec dks = new DESKeySpec(key);
    
            // 创建一个密钥工厂,然后用它把DESKeySpec转换成SecretKey对象
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
            SecretKey securekey = keyFactory.generateSecret(dks);
    
            // Cipher对象实际完成解密操作
            Cipher cipher = Cipher.getInstance(DES);
    
            // 用密钥初始化Cipher对象
            cipher.init(Cipher.DECRYPT_MODE, securekey, sr);
    
            return cipher.doFinal(data);
        }
    
        public static void main(String[]args)throws Exception{
           String  sStr=encrypt("122222112222:12343232323:jajwwwwslwskwkkwksk","wew2323w233321ws233w");
           System.out.println(sStr);
           String mStr=decrypt(sStr,"wew2323w233321ws233w");
           System.out.println(mStr);
        }
    }
    
    

    2. AES

    AES的全称是Advanced Encryption Standard,即高级加密标准,该算法由比利时密码学家Joan Daemen和Vincent Rijmen所设计,结合两位作者的名字,又称Rijndael加密算法,是美国联邦政府采用的一种对称加密标准,这个标准用来替代原先的DES算法,已经广为全世界所使用,已然成为对称加密算法中最流行的算法之一。AES算法作为新一代的数据加密标准汇聚了强安全性、高性能、高效率、易用和灵活等优
    点,设计有三个密钥长度:128,192,256位,比DES算法的加密强度更高,更为安全。

    
    import java.io.IOException;
    import java.io.UnsupportedEncodingException;
    import java.security.InvalidKeyException;
    import java.security.NoSuchAlgorithmException;
    import java.security.SecureRandom;
    import java.util.Base64;
    import java.util.Scanner;
    
    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import javax.crypto.KeyGenerator;
    import javax.crypto.NoSuchPaddingException;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    
    import sun.misc.BASE64Decoder;
    import sun.misc.BASE64Encoder;
    
    /**
     * Created by fangzhipeng on 2017/3/21.
     */
    public class AESUtil {
    
        static  byte[]  key = "w@#$4@#$s^&3*&^4".getBytes();
        final static String algorithm="AES";
    
        public static String encrypt(String data){
    
            byte[] dataToSend = data.getBytes();
            Cipher c = null;
            try {
                c = Cipher.getInstance(algorithm);
            } catch (NoSuchAlgorithmException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (NoSuchPaddingException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            SecretKeySpec k =  new SecretKeySpec(key, algorithm);
            try {
                c.init(Cipher.ENCRYPT_MODE, k);
            } catch (InvalidKeyException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            byte[] encryptedData = "".getBytes();
            try {
                encryptedData = c.doFinal(dataToSend);
            } catch (IllegalBlockSizeException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (BadPaddingException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            byte[] encryptedByteValue =     Base64.getEncoder().encode(encryptedData);
            return  new String(encryptedByteValue);//.toString();
        }
    
        public static String decrypt(String data){
    
            byte[] encryptedData  =  Base64.getDecoder().decode(data);
            Cipher c = null;
            try {
                c = Cipher.getInstance(algorithm);
            } catch (NoSuchAlgorithmException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (NoSuchPaddingException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            SecretKeySpec k =
                    new SecretKeySpec(key, algorithm);
            try {
                c.init(Cipher.DECRYPT_MODE, k);
            } catch (InvalidKeyException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
            byte[] decrypted = null;
            try {
                decrypted = c.doFinal(encryptedData);
            } catch (IllegalBlockSizeException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (BadPaddingException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return new String(decrypted);
        }
    
        public static void main(String[] args){
            String password=encrypt("12233440988:1239874389888:dd333");
            System.out.println(password);
            System.out.println(decrypt(password));
        }
    }
    
    
    

    ##三、非对称加密

    非对称加密算法又称为公开密钥加密算法,它需要两个密钥,一个称为公开密钥(public key),即公钥,另一个称为私有密钥(private key),即私钥。公钥与私钥需要配对使用,如果用公钥对数据进行加密,只有用对应的私钥才能进行解密,而如果使用私钥对数据进行加密,那么只有用对应的公钥才能进行解密。因为加密和解密使用的是两个不同的密钥,所以这种算法称为非对称加密算法。非对称加密算法实现机密信息交换的基本过程是:甲方生成一对密钥并将其中的一把作为公钥向其它人公开,得到该公钥的乙方使用该密钥对机密信息进行加密后再发送给甲方,甲方再使用自己保存的另一把专用密钥,即私钥,对加密后的信息进行解密。

    RSA

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

    
    /**
     * Created by fangzhipeng on 2017/3/21.
     * RSA :RSA非对称加密算法是1977年由Ron Rivest、 Adi Shamirh和LenAdleman开发   *  的, RSA取名来
     *  自开发他们三者的名字。
     * 参考:http://blog.csdn.net/wangqiuyun/article/details/42143957
     */
    
    import java.io.*;
    import java.security.InvalidKeyException;
    import java.security.KeyFactory;
    import java.security.KeyPair;
    import java.security.KeyPairGenerator;
    import java.security.NoSuchAlgorithmException;
    import java.security.SecureRandom;
    
    import java.security.interfaces.RSAPrivateKey;
    import java.security.interfaces.RSAPublicKey;
    import java.security.spec.InvalidKeySpecException;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    import java.util.Base64;
    
    import javax.crypto.BadPaddingException;
    import javax.crypto.Cipher;
    import javax.crypto.IllegalBlockSizeException;
    import javax.crypto.NoSuchPaddingException;
    public class RSAUtil {
    
    
        /**
         * 字节数据转字符串专用集合
         */
        private static final char[] HEX_CHAR = { '0', '1', '2', '3', '4', '5', '6',
                '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
    
        /**
         * 随机生成密钥对
         */
        public static void genKeyPair(String filePath) {
            // KeyPairGenerator类用于生成公钥和私钥对,基于RSA算法生成对象
            KeyPairGenerator keyPairGen = null;
            try {
                keyPairGen = KeyPairGenerator.getInstance("RSA");
            } catch (NoSuchAlgorithmException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            // 初始化密钥对生成器,密钥大小为96-1024位
            keyPairGen.initialize(1024,new SecureRandom());
            // 生成一个密钥对,保存在keyPair中
            KeyPair keyPair = keyPairGen.generateKeyPair();
            // 得到私钥
            RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
            // 得到公钥
            RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
            try {
                // 得到公钥字符串
                // 得到私钥字符串
                String privateKeyString =new String( Base64.getEncoder().encode(privateKey.getEncoded()));
                String publicKeyString =new String( Base64.getEncoder().encode(publicKey.getEncoded()));
                // 将密钥对写入到文件
    
                File file1=new File(filePath + "publicKey.keystore");
                File file2=new File(filePath + "privateKey.keystore");
                if(!file1.exists()) {
                    file1.createNewFile();
                }
                if(!file2.exists()) {
                    file2.createNewFile();
                }
                FileWriter pubfw = new FileWriter(filePath + "/publicKey.keystore");
                FileWriter prifw = new FileWriter(filePath + "/privateKey.keystore");
                BufferedWriter pubbw = new BufferedWriter(pubfw);
                BufferedWriter pribw = new BufferedWriter(prifw);
                pubbw.write(publicKeyString);
                pribw.write(privateKeyString);
                pubbw.flush();
                pubbw.close();
                pubfw.close();
                pribw.flush();
                pribw.close();
                prifw.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 从文件中输入流中加载公钥
         *
         * @param
         *
         * @throws Exception
         *             加载公钥时产生的异常
         */
        public static String loadPublicKeyByFile(String path) throws Exception {
            try {
                BufferedReader br = new BufferedReader(new FileReader(path
                        + "/publicKey.keystore"));
                String readLine = null;
                StringBuilder sb = new StringBuilder();
                while ((readLine = br.readLine()) != null) {
                    sb.append(readLine);
                }
                br.close();
                return sb.toString();
            } catch (IOException e) {
                throw new Exception("公钥数据流读取错误");
            } catch (NullPointerException e) {
                throw new Exception("公钥输入流为空");
            }
        }
    
        /**
         * 从字符串中加载公钥
         *
         * @param publicKeyStr
         *            公钥数据字符串
         * @throws Exception
         *             加载公钥时产生的异常
         */
        public static RSAPublicKey loadPublicKeyByStr(String publicKeyStr)
                throws Exception {
            try {
                byte[] buffer = Base64.getDecoder().decode(publicKeyStr);
                KeyFactory keyFactory = KeyFactory.getInstance("RSA");
                X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
                return (RSAPublicKey) keyFactory.generatePublic(keySpec);
            } catch (NoSuchAlgorithmException e) {
                throw new Exception("无此算法");
            } catch (InvalidKeySpecException e) {
                throw new Exception("公钥非法");
            } catch (NullPointerException e) {
                throw new Exception("公钥数据为空");
            }
        }
    
        /**
         * 从文件中加载私钥
         *
         * @param
         *
         * @return 是否成功
         * @throws Exception
         */
        public static String loadPrivateKeyByFile(String path) throws Exception {
            try {
                BufferedReader br = new BufferedReader(new FileReader(path
                        + "/privateKey.keystore"));
                String readLine = null;
                StringBuilder sb = new StringBuilder();
                while ((readLine = br.readLine()) != null) {
                    sb.append(readLine);
                }
                br.close();
                return sb.toString();
            } catch (IOException e) {
                throw new Exception("私钥数据读取错误");
            } catch (NullPointerException e) {
                throw new Exception("私钥输入流为空");
            }
        }
    
        public static RSAPrivateKey loadPrivateKeyByStr(String privateKeyStr)
                throws Exception {
            try {
                byte[] buffer = Base64.getDecoder().decode(privateKeyStr);
                PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
                KeyFactory keyFactory = KeyFactory.getInstance("RSA");
                return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
            } catch (NoSuchAlgorithmException e) {
                throw new Exception("无此算法");
            } catch (InvalidKeySpecException e) {
                throw new Exception("私钥非法");
            } catch (NullPointerException e) {
                throw new Exception("私钥数据为空");
            }
        }
    
        /**
         * 公钥加密过程
         *
         * @param publicKey
         *            公钥
         * @param plainTextData
         *            明文数据
         * @return
         * @throws Exception
         *             加密过程中的异常信息
         */
        public static byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData)
                throws Exception {
            if (publicKey == null) {
                throw new Exception("加密公钥为空, 请设置");
            }
            Cipher cipher = null;
            try {
                // 使用默认RSA
                cipher = Cipher.getInstance("RSA");
                // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
                cipher.init(Cipher.ENCRYPT_MODE, publicKey);
                byte[] output = cipher.doFinal(plainTextData);
                return output;
            } catch (NoSuchAlgorithmException e) {
                throw new Exception("无此加密算法");
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
                return null;
            } catch (InvalidKeyException e) {
                throw new Exception("加密公钥非法,请检查");
            } catch (IllegalBlockSizeException e) {
                throw new Exception("明文长度非法");
            } catch (BadPaddingException e) {
                throw new Exception("明文数据已损坏");
            }
        }
    
        /**
         * 私钥加密过程
         *
         * @param privateKey
         *            私钥
         * @param plainTextData
         *            明文数据
         * @return
         * @throws Exception
         *             加密过程中的异常信息
         */
        public static byte[] encrypt(RSAPrivateKey privateKey, byte[] plainTextData)
                throws Exception {
            if (privateKey == null) {
                throw new Exception("加密私钥为空, 请设置");
            }
            Cipher cipher = null;
            try {
                // 使用默认RSA
                cipher = Cipher.getInstance("RSA");
                cipher.init(Cipher.ENCRYPT_MODE, privateKey);
                byte[] output = cipher.doFinal(plainTextData);
                return output;
            } catch (NoSuchAlgorithmException e) {
                throw new Exception("无此加密算法");
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
                return null;
            } catch (InvalidKeyException e) {
                throw new Exception("加密私钥非法,请检查");
            } catch (IllegalBlockSizeException e) {
                throw new Exception("明文长度非法");
            } catch (BadPaddingException e) {
                throw new Exception("明文数据已损坏");
            }
        }
    
        /**
         * 私钥解密过程
         *
         * @param privateKey
         *            私钥
         * @param cipherData
         *            密文数据
         * @return 明文
         * @throws Exception
         *             解密过程中的异常信息
         */
        public static byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData)
                throws Exception {
            if (privateKey == null) {
                throw new Exception("解密私钥为空, 请设置");
            }
            Cipher cipher = null;
            try {
                // 使用默认RSA
                cipher = Cipher.getInstance("RSA");
                // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
                cipher.init(Cipher.DECRYPT_MODE, privateKey);
                byte[] output = cipher.doFinal(cipherData);
                return output;
            } catch (NoSuchAlgorithmException e) {
                throw new Exception("无此解密算法");
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
                return null;
            } catch (InvalidKeyException e) {
                throw new Exception("解密私钥非法,请检查");
            } catch (IllegalBlockSizeException e) {
                throw new Exception("密文长度非法");
            } catch (BadPaddingException e) {
                throw new Exception("密文数据已损坏");
            }
        }
    
        /**
         * 公钥解密过程
         *
         * @param publicKey
         *            公钥
         * @param cipherData
         *            密文数据
         * @return 明文
         * @throws Exception
         *             解密过程中的异常信息
         */
        public static byte[] decrypt(RSAPublicKey publicKey, byte[] cipherData)
                throws Exception {
            if (publicKey == null) {
                throw new Exception("解密公钥为空, 请设置");
            }
            Cipher cipher = null;
            try {
                // 使用默认RSA
                cipher = Cipher.getInstance("RSA");
                // cipher= Cipher.getInstance("RSA", new BouncyCastleProvider());
                cipher.init(Cipher.DECRYPT_MODE, publicKey);
                byte[] output = cipher.doFinal(cipherData);
                return output;
            } catch (NoSuchAlgorithmException e) {
                throw new Exception("无此解密算法");
            } catch (NoSuchPaddingException e) {
                e.printStackTrace();
                return null;
            } catch (InvalidKeyException e) {
                throw new Exception("解密公钥非法,请检查");
            } catch (IllegalBlockSizeException e) {
                throw new Exception("密文长度非法");
            } catch (BadPaddingException e) {
                throw new Exception("密文数据已损坏");
            }
        }
    
        /**
         * 字节数据转十六进制字符串
         *
         * @param data
         *            输入数据
         * @return 十六进制内容
         */
        public static String byteArrayToString(byte[] data) {
            StringBuilder stringBuilder = new StringBuilder();
            for (int i = 0; i < data.length; i++) {
                // 取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移
                stringBuilder.append(HEX_CHAR[(data[i] & 0xf0) >>> 4]);
                // 取出字节的低四位 作为索引得到相应的十六进制标识符
                stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);
                if (i < data.length - 1) {
                    stringBuilder.append(' ');
                }
            }
            return stringBuilder.toString();
        }
    
    
    
        public static void main(String[] args) throws Exception {
            String filepath="F:/temp/";
            File file=new File(filepath);
            if(!file.exists()){
                file.mkdir();
            }
            genKeyPair(filepath);
            System.out.println("--------------公钥加密私钥解密过程-------------------");
            String plainText="1223333323:8783737321232:dewejj28i33e92hhsxxxx";
            //公钥加密过程
            byte[] cipherData=encrypt(loadPublicKeyByStr(loadPublicKeyByFile(filepath)),plainText.getBytes());
            String cipher=new String(Base64.getEncoder().encode(cipherData));
            //私钥解密过程
            byte[] res=decrypt(loadPrivateKeyByStr(loadPrivateKeyByFile(filepath)), Base64.getDecoder().decode(cipher));
            String restr=new String(res);
            System.out.println("原文:"+plainText);
            System.out.println("加密密文:"+cipher);
            System.out.println("解密:"+restr);
            System.out.println();
        }
    }
    
    

    注: 文字部分复制了《大型电商分布式系统实践 第一版 讲师 陈康贤》的第三课。代码来源于自己的整理,全部测试通过,应该没有坑。


    扫码关注公众号有惊喜

    (转载本站文章请注明作者和出处 方志朋的博客

    展开全文
  • 安全算法梳理

    千次阅读 2016-09-05 01:12:15
      经常见到RSA、MD5、SHA系列算法,另外还有数字摘要、数字签名、数字证书等名词,以及对称加密与非对称加密。他们之间到底是什么关系呢?下面就通过这篇文章来梳理一下。 一、加密算法  加密算法,简而言之...

      经常见到RSA、MD5、SHA系列算法,另外还有数字摘要、数字签名、数字证书等名词,以及对称加密与非对称加密。他们之间到底是什么关系呢?下面就通过这篇文章来梳理一下。

    一、加密算法

      加密算法,简而言之就是一种能够把原始内容加密,然后再解密获得原始内容的算法。

    加密与解密

    加密算法可以划分为如下两类:

    1.对称加密

      对称加密可以理解为加密与解密都使用同一套算法(即密钥)。

    循环移位算法

      上图是一个经典对称加密算法。采用字母移位的办法对原始字符串进行转换,解密时再根据之前的移位,转换为原始字符串。可以根据此种算法,设计一个密码机,输入移位n,自动进行编码与解码。
      在谍战电视剧中经常出现你争我抢的密码本,加密与解密双方使用同一个密码本对要传递的内容进行加解密,这也是一种对称加密算法。
      对于对称加密在实际使用中的问题,可以通过如下样例来说明。
      假如淘宝网的登录密码传输部分使用的是对称加密算法。此时,张三、李四、还有王五同学需要访问淘宝。那么,服务器就需要生成3个不同的密钥,比如张三的密钥为移5位,李四的密钥为移6位。如果全部都用一个密钥,显然张三用自己的密钥可以解密其它人加密后的密码。对于服务器来讲,有多少个用户就得维护多少组密钥,这样做显然是不合理的。

    1. 常用的对称加密算法有:DES、3DES、TDEA、Blowfish、RC2、RC4、RC5、IDEA、SKIPJACK、AES等。
    2. 百度百科:对称加密

    2.非对称加密

      针对于对称加密存在的问题,使用非对称加密即可完美的解决。

    对称加密与非对称加密

      由上图可以看出,左侧的对称加密为A、B、C、D四个用户分别分配了一个密钥,而右侧的非对称加密(也叫公开密钥加密技术)为A、B、C、D四个用户分配了相同的密钥。
      非对称加密的密钥分为公钥私钥,其中公钥和私钥都可以加密与解密。特别的是,公钥所加密的内容只有私钥能够解密。这样,对于服务器来讲,只需要把公钥分发给所有客户,自己保存好私钥即可。

    1. 常用的非对称加密算法有:RSA、Elgamal、背包算法、Rabin、D-H、ECC(椭圆曲线加密算法)等。
    2. 百度百科:非对称加密

    二、摘要算法

      首先需要指明的是,摘要算法不属于加解密算法。
      对摘要两字可以理解为对信息主体的浓缩。这种浓缩是一个不可逆的过程。
      可以在这些地方使用摘要算法:明文密码取摘要后把摘要存入数据库、文件断点续传与秒传(用文件摘要确定唯一性)、不在网络中传输密码(密码做摘要后传输,在服务器端取出密码用相同的摘要算法计算摘要后再跟客户端传过来的摘要比对)

    1. 常用的摘要算法有:MD5、SHA1、SHA256、SHA384、SHA512
    2. 百度百科:摘要算法

    三、数字签名

      数字签名可以理解为摘要算法非对称加密的综合使用。
      数字签名可以对应为经常见到的骑缝章(经常有人喜欢把名字写在书的侧面)。数字签名需要说明是谁编写的报文,同时证明报文未被篡改过。

    数字签名

      通过上图,可以清楚的看出,使用摘要算法来证明报文未被篡改过,使用非对称加密来说明是谁写的报文。

    百度百科:数字签名

    四、数字证书

      我们可以通过非对称加密可以解决报文裸奔的问题。
      试想,有这么一个场景,服务器A分发一个公钥给客户端B,正常情况下很OK。此时A和B之前有个中间代理C,A和B之间的所有数据传输都要经过C来中转。C被黑客控制,C把自己的公钥发给B(B误以为是A的),C收到B传输给A的消息,先用自己的私钥解密,获得明文。然后用A的公钥加密密文再转发给A。
      这里就牵涉到一个问题,B怎么确定收到的公钥的确是A的,而不是别人伪造的?现实中的身份证,要想确定身份证是否是真实的,去权威机构(也就是公安局)查一下就行了。
      数字证书也是这个原理,需要一个权威机构来颁发。以此来证明这个公钥到底是谁的。
    数字证书

      上图是百度的数字证书,详细标明了颁发者、使用者、有效期、加密算法等信息。

    资料:“数字签名”(digital signature)和”数字证书”(digital certificate)到底是什么?

    原文地址:安全算法梳理
    Blog:http://muchstudy.com

    展开全文
  • 网络安全:常见安全算法

    千次阅读 2019-07-22 11:10:50
    废话不多说,本文将介绍常见的几种安全算法:数字摘要,对称加密,非对称加密,数字签名,数字证书。 1.数字摘要 数字摘要(消息摘要)是将一个消息或者文本内容使用函数或算法转换成固定长度的值。 如 函数y= f...
  • 哈希算法(HASH)在信息安全应用

    千次阅读 2018-04-02 21:16:48
    1、HASH的定义Hash,一般翻译做“散列”,也有直接音译为“哈希”的,就是把任意长度的输入(又叫做预映射,pre-image),通过散列算法,变换成固定长度的输出,该输出就是散列值。这种转换是一种压缩映射,也就是,...
  • 信息安全是近年来的热门话题,特别是最近随着物联网的全民化,安全已经成为移动支付,智能家居等领域发展的核心议题,而安全的本质是算法和安全系统。目前遇到的很多比特币钱包被盗,手机支付被盗刷等都与算法相关,...
  • 安全算法—SHA-256算法

    千次阅读 2018-07-15 14:39:47
    1. 什么是SHA-256?SHA-256是SHA2中的一种。对于长度L(L&...2. SHA-256算法实现步骤2.1 把消息转换为位字符串 SHA-256算法是按照位作为输入,所以进行计算前必须把原始消息(比如字符串、文件等)...
  • 信息安全第五篇(国密加密算法

    万次阅读 2018-07-23 18:54:48
    SM1:该算法是国家密码管理部门审批的 SM1 分组密码算法, 分组长度和密钥长度都为 128 比特,算法安全保密强度及相关软硬件实现性能与 AES 相当,该算法不公开,仅以 IP 核的形式存在于芯片中。采用该算法已经研制了...
  • 国产密码安全算法总结

    万次阅读 多人点赞 2017-03-09 17:41:21
    算法是由国家密码管理局编制的一种商用密码分组标准对称算法,分组长度和密钥长度均为128位,算法安全保密强度及相关软硬件实现性能与AES算法相当,目前该算法尚未公开,仅以IP核的形式存在于芯片中。2、SM2算法...
  • 1.前言 ...加密是保护信息安全的手段之一,对信息加密是需要加密算法的。 1.摘要算法 摘要算法就是把任意一个大小的文档,通过计算得到一个固定大小((比如32))的字符串。并且,这个过
  • 信息安全第一篇(加密算法介绍)

    千次阅读 2017-08-13 16:49:16
    随着移动互联网的发展,确确实实给大家...移动互联网的发展比互联网时代更加需要信息安全,所以信息安全突然变得紧迫而重要。今天开始大家跟我一起重新回顾信息安全的保障手段。 一、加密算法的分类 1)几种对称性加密
  • 信息安全中的DES加密算法

    千次阅读 2007-04-20 17:47:00
    信息安全中的DES加密算法 李 联 (西北工业大学 软件学院陕西 西安710072) 摘 要: 根据密钥类型不同将现代密码技术分为2类:—类是对称加密(秘密钥匙加密)系统
  • 置换密码 古典加密算法 信息安全

    万次阅读 2011-11-21 23:13:10
    置换密码算法的原理是不改变明文字符,而是按照某一规则重新排列消息中的比特或字符顺序,才而实现明文信息的加密。置换密码有时又称为换位密码。 矩阵换位法是实现置换密码的一种常用方法。它将明文中的字母按照...
  • 加密分为两大类:对称加密、非对称加密,两类加密算法各有优点,在不同的场景使用不同的算法。 对称加密 加密方将原始数据和加密密钥一起经过特殊加密算法处理后,生成密文结果,解密方使用相同的秘钥及相同加密...
  • 密码学安全算法--对称加密算法

    千次阅读 2017-06-04 21:45:50
    对称加密也称为常规加密、单钥加密,在非对称加密(公钥加密)开发之前是唯一使用的加密类型,直到现在,...- 明文:也就是原始信息或者说原始数据。也就是上图中的A。 - 加密算法:对明文进行各种替换或转换操作的一...
  • 安全算法—Hash算法总结(一)

    千次阅读 2018-07-10 16:37:34
    Hash,一般翻译做“散列”,也有直接音译为“哈希”的,就是把任意长度的输入(又叫做预映射pre-image)通过散列算法变换成固定长度的输出,该输出就是散列值。这种转换是一种压缩映射,也就是,散列值的空间通常远...
  • 信息安全学习总结(2):加密算法

    千次阅读 2007-03-30 12:12:00
    随着社会对信息安全必要性的认识,密码学应运而生;最初密码学仅应用于信息的机密性,但是随着社会的发展和进步,特别是网络的发展,密码学的应用范畴逐步扩展到信息安全各个领域,已经能够解决包括机密性、完整性、...
  • 常见的安全算法--单向加密--Hash算法

    千次阅读 2019-07-25 11:31:17
    常见安全算法—数字摘要 数字摘要也称为消息摘要,它是一个唯一对应一个消息或文本的固定长度的值,它由一个单向 Hash函数对消息进行计算而产生。如果消息在传递的途中改变了,接收者通过对收到消息采用相同的Hash...
  • 国产密码算法:锻造信息安全之盾

    千次阅读 2015-10-10 09:34:59
    随着商业银行信息化的快速发展,以网上银行为代表的基于Internet和其他各类网络的应用系统迅速普及。由于个人金融信息具有高度的敏感性,因此,这些信息在网络上的...那么商业银行怎样才能保护好个人金融信息安全呢?采
  • 本书是《OpenSSL与网络信息安全》 系列书籍的第二本,预计出版日期为2008年初。内容简介: 本书通过结合OpenSSL提供的各种密码算法API接口和其他API机制,对各种密码算法的编程实现技术进行全面的阐述。本书通过对...
  • 2020年8月14日,我发布了WJLHA2.0.1版的哈希算法,该算法对标于SHA256、MD5、SM3等哈希算法。感兴趣的朋友可以测试一下碰撞。另外,请测试后再发表评论,至于那些所谓的证明我不想提,去学习一下“生日碰撞”概率。...
  • 安全哈希算法SHA1

    千次阅读 2016-12-11 12:41:33
    安全哈希算法(Secure Hash Algorithm)SHA1主要适用于数字签名标准 (Digital Signature Standard DSS)里面定义的数字签名算法(Digital SignatureAlgorithm DSA)。对于长度小于2^64位的消息,SHA1会产生一个160...
  • /*以下均为伪代码*/ s_conversion(int* feis_6, int num) { int n, m; n = feis_6[5] + feis_6[0]*2; m = feis_6[4] + feis_6[3]*2 + feis_6[2]*4 + feis_6[1]*8; int feis_4_dec = s_box[num][n][m];...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 436,818
精华内容 174,727
关键字:

信息安全算法