精华内容
下载资源
问答
  • 第一 对称加密: 对称加密是指,加密...常用的对称加密算法:AES,RC4,3DES传输的示意图如下所示:如上图所示,此种方式属于对称加密,双方拥有相同的密钥,信息得到安全传输,但此种方式的缺点是:(1)不同的客户...
    第一 对称加密:
    对称加密是指,加密方和解密方使用同样的秘钥来进行加密和解密。
    在对称加密算法中,数据发信方将明文(原始数据)和加密密钥(mi yue)一起经过特殊加密算法处理后,使其变成复杂的加密密文发送出去。常用的对称加密算法:AES,RC4,3DES

    传输的示意图如下所示:

    如上图所示,此种方式属于对称加密,双方拥有相同的密钥,信息得到安全传输,但此种方式的缺点是:

    (1)不同的客户端、服务器数量庞大,所以双方都需要维护大量的密钥,维护成本很高

    (2)因每个客户端、服务器的安全级别不同,密钥极易泄露

    这里举例一个使用DES算法来实现对称加密的例子:

    public class DESUtils {

    public byte[] initKey(){
    try {
    KeyGenerator keyGenerator = KeyGenerator.getInstance("DES");
    keyGenerator.init(56);
    SecretKey secretKey = keyGenerator.generateKey();
    return  secretKey.getEncoded();
    } catch (NoSuchAlgorithmException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }

    return null;
    }

    /**
      * @Method: encrypt
      * @Description: 加密算法
      * @param data 被加密字节数组
      * @param key  随机对称密钥
      * @return
      * 返回类型:byte[]
      */
    public byte[] encrypt(byte[] data,byte[] key){
    SecretKey secretKey = new SecretKeySpec(key, "DES");
    Cipher cipher;
    try {
    cipher = Cipher.getInstance("DES");
    cipher.init(Cipher.ENCRYPT_MODE, secretKey);
    return cipher.doFinal(data);
    } catch (Exception e) {
    e.printStackTrace();


    return null;
    }

    /**
      * @Method: decode
      * @Description: TODO
      * @param 被解密的字节数组
      * @param key 随机对称密钥(和加密密钥务必保持一致)
      * @return
      * 返回类型:byte[]
      */
    public byte[] decode(byte[] data,byte[] key){
    SecretKey secretKey = new SecretKeySpec(key, "DES");
    Cipher cipher;
    try {
    cipher = Cipher.getInstance("DES");
    cipher.init(Cipher.DECRYPT_MODE, secretKey);
    return cipher.doFinal(data);
    } catch (Exception e) {
    e.printStackTrace();


    return null;
    }

    测试代码为:

    public static void testDes(){
    DESUtils desUtils = new DESUtils();
    byte[] key = desUtils.initKey();   // 
    String originData = "123456";
    System.out.println("原始数据:"+originData);
    try {
    // 将原始数据转化为字符串
    byte[] arrayOrigin = originData.getBytes("utf-8");
    // 对原始数据进行加密
    byte[] encryption = desUtils.encrypt(arrayOrigin, key);
    // 通过BASE64Encoder转化处理
    String encryptionStr = new BASE64Encoder().encode(encryption);
    System.out.println("经过加密之后的字符串:"+encryptionStr);

    try {
    // 使用BASE64Decoder进行转化处理
    byte[] decoceOrigin = new BASE64Decoder().decodeBuffer(encryptionStr);
    // 使用DES进行解密操作
    byte[] decode = desUtils.decode(decoceOrigin, key);
    // 把字节数组转化为字符串
    String decodeStr = new String(decode,"utf-8");
    System.out.println("对加密字符串进行解密:"+decodeStr);
    } catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }
    } catch (UnsupportedEncodingException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }
    }

    运行结果如下:

    原始数据:123456
    经过加密之后的字符串:jaKOVkHJtOQ=
    对加密字符串进行解密:123456

    第二 、非对称加密:
    非对称加密算法实现机密信息交换的基本过程是:甲方生成一对密钥并将其中的一把作为公用密钥向其它方公开;得到该公用密钥的乙方使用该密钥对机密信息进行加密后再发送给甲方;甲方再用自己保存的另一把专用密钥对加密后的信息进行解密。甲方只能用其专用密钥解密由其公用密钥加密后的任何信息。非对称加密算法:RSA,DSA/DSS 

    如上图所示,客户端用公钥对请求内容加密,服务器使用私钥对内容解密,反之亦然,但上述过程也存在缺点:

    公钥是公开的(也就是黑客也会有公钥),所以第 ④ 步私钥加密的信息,如果被黑客截获,其可以使用公钥进行解密,获取其中的内容。

    实现非对称加密算法例子:

    public class AsymmetricEncryption {


    public static final String KEY_ALGORITHM = "RSA";
    /** 貌似默认是RSA/NONE/PKCS1Padding,未验证 */
    public static final String CIPHER_ALGORITHM = "RSA/ECB/PKCS1Padding";
    public static final String PUBLIC_KEY = "publicKey";
    public static final String PRIVATE_KEY = "privateKey";


    /** RSA密钥长度必须是64的倍数,在512~65536之间。默认是1024 */
    public static final int KEY_SIZE = 2048;


    public static final String PLAIN_TEXT = "hello world!";


    /**
    * @Method: generateKeyBytes
    * @Description: 首先产生一个公钥和私钥对,使用HashMap保存起来
    * @return 返回类型:Map<String,byte[]>
    */
    public static Map<String, byte[]> generateKeyBytes() {


    try {
    KeyPairGenerator keyPairGenerator = KeyPairGenerator
    .getInstance(KEY_ALGORITHM);
    keyPairGenerator.initialize(KEY_SIZE);
    KeyPair keyPair = keyPairGenerator.generateKeyPair();


    RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
    RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();


    Map<String, byte[]> keyMap = new HashMap<String, byte[]>();
    keyMap.put(PUBLIC_KEY, publicKey.getEncoded());
    keyMap.put(PRIVATE_KEY, privateKey.getEncoded());
    return keyMap;
    } catch (NoSuchAlgorithmException e) {
    e.printStackTrace();
    }
    return null;
    }


    /**
    * 还原公钥,X509EncodedKeySpec 用于构建公钥的规范

    * @param keyBytes
    * @return
    */
    public static PublicKey restorePublicKey(byte[] keyBytes) {
    X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);


    try {
    KeyFactory factory = KeyFactory.getInstance(KEY_ALGORITHM);
    PublicKey publicKey = factory.generatePublic(x509EncodedKeySpec);
    return publicKey;
    } catch (Exception e) {
    e.printStackTrace();
    }
    return null;
    }


    /**
    * 还原私钥,PKCS8EncodedKeySpec 用于构建私钥的规范

    * @param keyBytes
    * @return
    */
    public static PrivateKey restorePrivateKey(byte[] keyBytes) {
    PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(
    keyBytes);
    try {
    KeyFactory factory = KeyFactory.getInstance(KEY_ALGORITHM);
    PrivateKey privateKey = factory
    .generatePrivate(pkcs8EncodedKeySpec);
    return privateKey;
    } catch (Exception e) {
    e.printStackTrace();
    }
    return null;
    }


    /**
    * 加密,三步走。

    * @param key
    * @param plainText
    * @return
    */
    public static byte[] RSAEncode(PublicKey key, byte[] plainText) {


    try {
    Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
    cipher.init(Cipher.ENCRYPT_MODE, key);
    return cipher.doFinal(plainText);
    } catch (Exception e) {
    e.printStackTrace();
    }


    return null;
    }


    public static String RSADecode(PrivateKey key, byte[] encodedText) {


    try {
    Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
    cipher.init(Cipher.DECRYPT_MODE, key);
    return new String(cipher.doFinal(encodedText));
    } catch (Exception e) {
    e.printStackTrace();
    }
    return null;
    }

    }

    测试代码如下:

    public static void tesRSA(){
    Map<String, byte[]> keyMap = AsymmetricEncryption.generateKeyBytes();

    // 加密
    PublicKey publicKey = AsymmetricEncryption.restorePublicKey(keyMap.get(AsymmetricEncryption.PUBLIC_KEY));
    byte[] encodedText = AsymmetricEncryption.RSAEncode(publicKey, AsymmetricEncryption.PLAIN_TEXT.getBytes());
    String rsaString = new BASE64Encoder().encode(encodedText);
    System.out.println("RSA encoded: " + rsaString);

    PrivateKey privateKey = AsymmetricEncryption.restorePrivateKey(keyMap.get(AsymmetricEncryption.PRIVATE_KEY));
    System.out.println("RSA decoded: "+ AsymmetricEncryption.RSADecode(privateKey, encodedText));

    }

    运行结果如下所示:

    RSA encoded: e7wIyV32VtiJhiraQGIYxD2TKtC4O6dRJx0lgVuEUsjCTSjqNFmEVNlYmFzd3ohIiW67XyIfEzWD
    W9YFpFnDekRFLgeerh7c5gXMLVsVkf7k7XuTbiGmQOlOBUmL8VWpWVWTk8Rgn7Y+G7/dz9+DOEnH
    csMnssKC/MBM80Ad5Za+QHqgb6BdZNHjZYzWpDIztBEUf/yHWfkGhmJahxo6Ff6y8er/shiP+qL3
    hMJlw70TTGoGlrAWQqxUMYGPrv4IELi/iNSednXxo5bNNatJYke7FhKnuy8GEOWNH/K8Q52vl24L
    cururJGLEJR6Hn/oaGxnXQbs2Fzo3vUziDj1cQ==
    RSA decoded: hello world!

    第三 非对称和对称完美结合

    非对称加密既然也有缺陷,那我们就将对称加密,非对称加密两者结合起来,取其精华、去其糟粕,发挥两者的各自的优势:


    如上图所示

    (1)第 ③ 步时,客户端说:(咱们后续回话采用对称加密吧,这是对称加密的算法和对称密钥)这段话用公钥进行加密,然后传给服务器

    (2)服务器收到信息后,用私钥解密,提取出对称加密算法和对称密钥后,服务器说:(好的)对称密钥加密

    (3)后续两者之间信息的传输就可以使用对称加密的方式了

    这是个非常非常经典的数据传输过程,也是Https传输协议里面最经典的部分。也是把对称加密和非对称加密的作用发挥到了很好的地方。在https传输的过程中,如果单独只用对称加密,或者单独使用非对称加密都会出现问题。



    展开全文
  • 对称加密算法之DES算法和AES算法

    千次阅读 2019-01-22 13:44:36
    对称加密算法是应用最早的加密算法,技术成熟。在对称加密算法中,数据发送方将明文和加密密钥一起经过特殊加密算法处理后,生成复杂的加密密钥进行发送,数据接收方收到密文后,若想... DES算法属于对称加密算法,...


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

            DES算法
            DES算法属于对称加密算法,明文按64位进行分组,密钥长64位,但事实上只有56位参与DES运算(第8,16,24,32,40,48,56,64位是校验位,使得每个密钥都有个奇数个1),分组后的名为和56位的密钥按位替换或交换的方法形成密文。
            由于计算机运算能力的增强,原来DES密码的密钥长度变得容易被暴力破解,因此演变出了3DES算法。3DES是DES向AES过度的加密算法,它使3条56位的密钥对数据进行3次加密,是DES的一个更安全的变形。

        AES算法
            AES即高级加密标准,已经广为全世界所使用,成为对称加密算法的主流算法之一。
            AES算法作为新一代的数据集加密标准,汇聚了强安全性、高性能、高效率、易用和灵活等优点,设计有三个密钥长度(128,192,256位),比DES算法的加密强度更高,更安全。

    展开全文
  • DES对称加密算法简析

    2017-11-25 13:33:00
     在了解DES算法前,先加单介绍一下对称加密算法,因为DES属于对称加密算法的一种。  对称加密算法是应用较早的加密算法,技术成熟。在对称加密算法中,数据发信方将明文(原始数据)和加密密钥(mi yao)一起经过...

    1 对称加密算法

      在了解DES算法前,先加单介绍一下对称加密算法,因为DES属于对称加密算法的一种。

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

      原理如下图:

      

    2 DES算法简介

    2.1 概述

      DES全称为Data Encryption Standard,即数据加密标准,是一种使用密钥加密的块算法,1977年被美国联邦政府的国家标准局确定为联邦资料处理标准(FIPS),并授权在非密级政府通信中使用,随后该算法在国际上广泛流传开来。需要注意的是,在某些文献中,作为算法的DES称为数据加密算法(Data Encryption Algorithm,DEA),已与作为标准的DES区分开来。

    2.2 发展历史

      美国国家标准局1973年开始研究除国防部外的其它部门的计算机系统的数据加密标准,于1973年5月15日和1974年8月27日先后两次向公众发出了征求加密算法的公告。加密算法要达到的目的(通常称为DES 密码算法要求)主要为以下四点:

      ☆提供高质量的数据保护,防止数据未经授权的泄露和未被察觉的修改;

      ☆具有相当高的复杂性,使得破译的开销超过可能获得的利益,同时又要便于理解和掌握;

      ☆DES密码体制的安全性应该不依赖于算法的保密,其安全性仅以加密密钥的保密为基础;

      ☆实现经济,运行有效,并且适用于多种完全不同的应用。

      1977年1月,美国政府颁布:采纳IBM公司设计的方案作为非机密数据的正式数据加密标准(DES Data Encryption Standard)。

    2.3 算法原理

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

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

      Key为8个字节共64位,是DES算法的工作密钥;

      Data也为8个字节64位,是要被加密或被解密的数据;

      Mode为DES的工作方式,有两种:加密或解密。

      DES算法是这样工作的:

      如Mode为加密,则用Key 去把数据Data进行加密, 生成Data的密码形式(64位)作为DES的输出结果;

      如Mode为解密,则用Key去把密码形式的数据Data解密,还原为Data的明码形式(64位)作为DES的输出结果。

      在通信网络的两端,双方约定一致的Key,在通信的源点用Key对核心数据进行DES加密,然后以密码形式在公共通信网(如电话网)中传输到通信网络的终点,数据到达目的地后,用同样的Key对密码数据进行解密,便再现了明码形式的核心数据。这样,便保证了核心数据(如PIN、MAC等)在公共通信网中传输的安全性和可靠性。

      通过定期在通信网络的源端和目的端同时改用新的Key,便能更进一步提高数据的保密性,这正是现在金融交易网络的流行做法。

    2.4 应用

      目前在国内,随着三金工程尤其是金卡工程的启动,DES算法在POS、ATM、磁卡及智能卡(IC卡)、加油站、高速公路收费站等领域被广泛应用,以此来实现关键数据的保密,如信用卡持卡人的PIN的加密传输,IC卡与POS间的双向认证、金融交易数据包的MAC校验等,均用到DES算法。

    2.5 java代码实现

      1 package xin.dreaming.des;
      2 
      3 import java.security.SecureRandom;
      4 import java.util.Arrays;
      5 
      6 import javax.crypto.Cipher;
      7 import javax.crypto.SecretKey;
      8 import javax.crypto.SecretKeyFactory;
      9 import javax.crypto.spec.DESKeySpec;
     10 import javax.crypto.spec.IvParameterSpec;
     11 
     12 import org.junit.Test;
     13 /**
     14  * 
     15  * @author DREAMING.XIN
     16  *
     17  */
     18 public class DESUtils {
     19     
     20     /**
     21      * 生成随机密钥
     22      * 
     23      * @param size
     24      *            位数
     25      * @return
     26      */
     27     public static String generateRandomKey(int size) {
     28         StringBuilder key = new StringBuilder();
     29         String chars = "0123456789ABCDEF";
     30         for (int i = 0; i < size; i++) {
     31             int index = (int) (Math.random() * (chars.length() - 1));
     32             key.append(chars.charAt(index));
     33         }
     34         return key.toString();
     35     }
     36 
     37     /**
     38      * DES加密
     39      * 
     40      * @param key
     41      *            密钥信息
     42      * @param content
     43      *            待加密信息
     44      * @return
     45      * @throws Exception
     46      */
     47     public static byte[] encodeDES(byte[] key, byte[] content) throws Exception {
     48         // 不是8的倍数的,补足
     49         if (key.length % 8 != 0) {
     50             int groups = key.length / 8 + (key.length % 8 != 0 ? 1 : 0);
     51             byte[] temp = new byte[groups * 8];
     52             Arrays.fill(temp, (byte) 0);
     53             System.arraycopy(key, 0, temp, 0, key.length);
     54             key = temp;
     55         }
     56 
     57         // 不是8的倍数的,补足
     58         byte[] srcBytes = content;
     59         if (srcBytes.length % 8 != 0) {
     60             int groups = content.length / 8 + (content.length % 8 != 0 ? 1 : 0);
     61             srcBytes = new byte[groups * 8];
     62             Arrays.fill(srcBytes, (byte) 0);
     63             System.arraycopy(content, 0, srcBytes, 0, content.length);
     64         }
     65 
     66         IvParameterSpec iv = new IvParameterSpec(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 });
     67         SecureRandom sr = new SecureRandom();
     68         DESKeySpec dks = new DESKeySpec(key);
     69         SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
     70         SecretKey secretKey = keyFactory.generateSecret(dks);
     71         Cipher cipher = Cipher.getInstance("DES/CBC/NoPadding");
     72         cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv, sr);
     73         byte[] tgtBytes = cipher.doFinal(srcBytes);
     74         return tgtBytes;
     75     }
     76 
     77     /**
     78      * DES解密
     79      * 
     80      * @param key
     81      *            密钥信息
     82      * @param content
     83      *            待加密信息
     84      * @return
     85      * @throws Exception
     86      */
     87     public static byte[] decodeDES(byte[] key, byte[] content) throws Exception {
     88         // 不是8的倍数的,补足
     89         if (key.length % 8 != 0) {
     90             int groups = key.length / 8 + (key.length % 8 != 0 ? 1 : 0);
     91             byte[] temp = new byte[groups * 8];
     92             Arrays.fill(temp, (byte) 0);
     93             System.arraycopy(key, 0, temp, 0, key.length);
     94             key = temp;
     95         }
     96         // 不是8的倍数的,补足
     97         byte[] srcBytes = content;
     98         if (srcBytes.length % 8 != 0) {
     99             int groups = content.length / 8 + (content.length % 8 != 0 ? 1 : 0);
    100             srcBytes = new byte[groups * 8];
    101             Arrays.fill(srcBytes, (byte) 0);
    102             System.arraycopy(content, 0, srcBytes, 0, content.length);
    103         }
    104 
    105         IvParameterSpec iv = new IvParameterSpec(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 });
    106         SecureRandom sr = new SecureRandom();
    107         DESKeySpec dks = new DESKeySpec(key);
    108         SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
    109         SecretKey secretKey = keyFactory.generateSecret(dks);
    110         Cipher cipher = Cipher.getInstance("DES/CBC/NoPadding");
    111         cipher.init(Cipher.DECRYPT_MODE, secretKey, iv, sr);
    112         byte[] tgtBytes = cipher.doFinal(content);
    113         return tgtBytes;
    114     }
    115     
    116     @Test
    117     public void desTest() throws Exception{
    118         //获取随机密钥
    119         String key = generateRandomKey(16);
    120         System.out.println("随机密钥:"+key);
    121         String str = "DREAMING.XIN";
    122         //des加密
    123         byte[] encodeDES = encodeDES(key.getBytes(), str.getBytes());
    124         System.out.println("加密结果:"+encodeDES);
    125         
    126         //des解密
    127         byte[] decodeDES = decodeDES(key.getBytes(), encodeDES);
    128         System.out.println("减密结果: "+new String(decodeDES));
    129     }
    130 
    131 }

    执行结果:

      随机密钥:AB09C55631425D67
      加密结果:[B@19fc4e
      减密结果: DREAMING.XIN

    3 3DES加密算法

    3.1 概述

      3DES又称Triple DES,是DES加密算法的一种模式,它使用3条56位的密钥对数据进行三次加密。数据加密标准(DES)是美国的一种由来已久的加密标准,它使用对称密钥加密法,并于1981年被ANSI组织规范为ANSI X.3.92。DES使用56位密钥和密码块的方法,而在密码块的方法中,文本被分成64位大小的文本块然后再进行加密。比起最初的DES,3DES更为安全。
      3DES(即Triple DES)是DES向AES过渡的加密算法(1999年,NIST将3-DES指定为过渡的加密标准),加密算法,其具体实现如下:设Ek()和Dk()代表DES算法的加密和解密过程,K代表DES算法使用的密钥,M代表明文,C代表密文,这样:
      3DES加密过程为:C=Ek3(Dk2(Ek1(M)))
      3DES解密过程为:M=Dk1(EK2(Dk3(C)))

    3.2 java代码实现

      1 package xin.dreaming.des;
      2 
      3 import java.security.Security;
      4 import java.util.Arrays;
      5 
      6 import javax.crypto.Cipher;
      7 import javax.crypto.SecretKey;
      8 import javax.crypto.spec.SecretKeySpec;
      9 
     10 import org.bouncycastle.jce.provider.BouncyCastleProvider;
     11 import org.junit.Test;
     12 
     13 public class TripleDESUtils {
     14 
     15     /**
     16      * 生成随机密钥
     17      * 
     18      * @param size
     19      *            位数
     20      * @return
     21      */
     22     public static String generateRandomKey(int size) {
     23         StringBuilder key = new StringBuilder();
     24         String chars = "0123456789ABCDEF";
     25         for (int i = 0; i < size; i++) {
     26             int index = (int) (Math.random() * (chars.length() - 1));
     27             key.append(chars.charAt(index));
     28         }
     29         return key.toString();
     30     }
     31 
     32     /**
     33      * 3DES加密
     34      * 
     35      * @param key
     36      *            密钥信息
     37      * @param content
     38      *            待加密信息
     39      * @return
     40      * @throws Exception
     41      */
     42     public static byte[] encode3DES(byte[] key, byte[] content) throws Exception {
     43         Security.addProvider(new BouncyCastleProvider());
     44         // 不是8的倍数的,补足
     45         if (key.length % 8 != 0) {
     46             int groups = key.length / 8 + (key.length % 8 != 0 ? 1 : 0);
     47             byte[] temp = new byte[groups * 8];
     48             Arrays.fill(temp, (byte) 0);
     49             System.arraycopy(key, 0, temp, 0, key.length);
     50             key = temp;
     51         }
     52         // 长度为16位,转换成24位的密钥
     53         if (key.length == 16) {
     54             byte[] temp = new byte[24];
     55             System.arraycopy(key, 0, temp, 0, key.length);
     56             System.arraycopy(key, 0, temp, key.length, temp.length - key.length);
     57             key = temp;
     58         }
     59 
     60         // 不是8的倍数的,补足
     61         byte[] srcBytes = content;
     62         if (srcBytes.length % 8 != 0) {
     63             int groups = content.length / 8 + (content.length % 8 != 0 ? 1 : 0);
     64             srcBytes = new byte[groups * 8];
     65             Arrays.fill(srcBytes, (byte) 0);
     66             System.arraycopy(content, 0, srcBytes, 0, content.length);
     67         }
     68 
     69         SecretKey deskey = new SecretKeySpec(key, "DESede");
     70         Cipher cipher = Cipher.getInstance("DESede/ECB/NoPadding");
     71         cipher.init(Cipher.ENCRYPT_MODE, deskey);
     72         byte[] temp = cipher.doFinal(srcBytes);
     73         byte[] tgtBytes = new byte[content.length];
     74         System.arraycopy(temp, 0, tgtBytes, 0, tgtBytes.length);
     75         return tgtBytes;
     76     }
     77 
     78     /**
     79      * 3DES解密
     80      * 
     81      * @param key
     82      *            密钥
     83      * @param content
     84      *            待解密信息
     85      * @return
     86      * @throws Exception
     87      */
     88     public static byte[] decode3DES(byte[] key, byte[] content) throws Exception {
     89         // 不是8的倍数的,补足
     90         if (key.length % 8 != 0) {
     91             int groups = key.length / 8 + (key.length % 8 != 0 ? 1 : 0);
     92             byte[] temp = new byte[groups * 8];
     93             Arrays.fill(temp, (byte) 0);
     94             System.arraycopy(key, 0, temp, 0, key.length);
     95             key = temp;
     96         }
     97         // 长度为16位,转换成24位的密钥
     98         if (key.length == 16) {
     99             byte[] temp = new byte[24];
    100             System.arraycopy(key, 0, temp, 0, key.length);
    101             System.arraycopy(key, 0, temp, key.length, temp.length - key.length);
    102             key = temp;
    103         }
    104 
    105         // 不是8的倍数的,补足
    106         byte[] srcBytes = content;
    107         if (srcBytes.length % 8 != 0) {
    108             int groups = content.length / 8 + (content.length % 8 != 0 ? 1 : 0);
    109             srcBytes = new byte[groups * 8];
    110             Arrays.fill(srcBytes, (byte) 0);
    111             System.arraycopy(content, 0, srcBytes, 0, content.length);
    112         }
    113 
    114         SecretKey deskey = new SecretKeySpec(key, "DESede");
    115         Cipher cipher = Cipher.getInstance("DESede/ECB/NoPadding");
    116         cipher.init(Cipher.DECRYPT_MODE, deskey);
    117         byte[] tgtBytes = cipher.doFinal(srcBytes);
    118         return tgtBytes;
    119     }
    120 
    121     /**
    122      * 二进制转十六进制字符串。每一个字节转为两位十六进制字符串。
    123      */
    124     public static String byte2hex(byte[] b) {
    125         String hs = "";
    126         String stmp = "";
    127         for (int i = 0; i < b.length; i++) {
    128             stmp = Integer.toHexString(b[i] & 0XFF);
    129             if (stmp.length() == 1) {
    130                 hs = hs + "0" + stmp;
    131             } else {
    132                 hs = hs + stmp;
    133             }
    134         }
    135         return hs.toUpperCase();
    136     }
    137     
    138     /**
    139      * <b>概要:</b>
    140      * 十六进制转二进制
    141      * @param hex
    142      * @return
    143      * @throws IllegalArgumentException
    144      */
    145     public static byte[] hex2byte(String hex) throws IllegalArgumentException {
    146         if (hex.length() % 2 != 0) {
    147             throw new IllegalArgumentException();
    148         }
    149         if (hex.startsWith("0x")) {
    150             hex = hex.substring(2);
    151         }
    152         char[] arr = hex.toCharArray();
    153         byte[] b = new byte[hex.length() / 2];
    154         for (int i = 0, j = 0, l = hex.length(); i < l; i++, j++) {
    155             String swap = "" + arr[i++] + arr[i];
    156             int byteint = Integer.parseInt(swap, 16) & 0xFF;
    157             b[j] = new Integer(byteint).byteValue();
    158         }
    159         return b;
    160     }
    161     
    162     /**
    163      * 3DES加密模式
    164      */
    165      public static String encrypt(String value,String key) {
    166         try {
    167             SecretKeySpec keySpec = new SecretKeySpec(key.getBytes(), "DESede");
    168             Cipher cipher = Cipher.getInstance("DESede");
    169             cipher.init(Cipher.ENCRYPT_MODE, keySpec);
    170             byte[] encryptedByte = cipher.doFinal(value.getBytes());
    171             String encodedByte = byte2hex(encryptedByte);
    172             return encodedByte;
    173         } catch(Exception e) {
    174             e.printStackTrace();
    175             return null;
    176         }
    177      }
    178      
    179      /**
    180       * <b>概要:</b>
    181       * 3DES解密
    182       * @param value
    183       * @param key
    184       * @return
    185       */
    186     public static String decrypt(String value,String key) {
    187         try {
    188             
    189             SecretKeySpec keySpec = new SecretKeySpec(key.getBytes(), "DESede");
    190             Cipher cipher = Cipher.getInstance("DESede");
    191             cipher.init(Cipher.DECRYPT_MODE, keySpec);
    192             byte[] decryptedByte = cipher.doFinal(hex2byte(value));            
    193             return new String(decryptedByte);
    194         } catch(Exception e) {
    195             e.printStackTrace();
    196             return null;
    197         }
    198         }
    199     
    200     @Test
    201     public void TripleDESTest() throws Exception {
    202 
    203         // 获取随机密钥
    204         String key = generateRandomKey(24);
    205         System.out.println("随机密钥:" + key);
    206         String str = "DREAMING.XIN";
    207         // des加密
    208         String encodeDES = encrypt( str,key);
    209         System.out.println("3DES加密结果:" + encodeDES);
    210         
    211         // des解密
    212         String decodeDES = decrypt(encodeDES, key);
    213         System.out.println("减密结果: " + decodeDES);
    214     }
    215 }

    运行结果:

      

    补充说明:

     1、3DES的密钥必须是24位的byte数组

      否则会报错:如图,我生成23位密钥进行测试,报错如下:

      

      2、加密结果的编码方式要一致

      从byte数组转成字符串,一般有两种方式,base64处理和十六进制处理。

      

    参考:

      1、https://www.zhihu.com/question/36767829

      2、https://baike.baidu.com/item/DES/210508?fr=aladdin

      3、https://baike.baidu.com/item/对称加密算法/211953?fr=aladdin

     

    转载于:https://www.cnblogs.com/xq1314/p/7895088.html

    展开全文
  • DES ~ 对称加密算法

    千次阅读 2016-12-05 18:25:52
    DES属于对称加密算法 对称加密指加密和解密使用的密钥是同一个密钥,代表:DES算法,RC算法。速度快,适合大量数据加密。 上面的两个密钥是同一把。 java代码实现: package ...

    DES属于对称加密算法


    对称加密指加密解密使用的密钥是同一个密钥,代表:DES算法,RC算法。速度快,适合大量数据加密

    上面的两个密钥是同一把。



    java代码实现:

    package security;
    /**
     *
     * @author zhengchao
     */
    import java.security.SecureRandom;
    import javax.crypto.spec.DESKeySpec;
    import javax.crypto.SecretKeyFactory;
    import javax.crypto.SecretKey;
    import javax.crypto.Cipher;
    /**
     DES加密介绍:
       DES是一种对称加密算法,所谓对称加密算法即:加密和解密使用相同密钥的算法。DES加密算法出自IBM的研究,
     后来被美国政府正式采用,之后开始广泛流传,但是近些年使用越来越少,因为DES使用56位密钥,以现代计算能力,
     24小时内即可被破解。虽然如此,在某些简单应用中,我们还是可以使用DES加密算法,本文简单讲解DES的JAVA实现
     。
     注意:DES加密和解密过程中,密钥长度都必须是8的倍数
     */
    public class TestDES {
        
        public static void main(String args[]) {
            
            //待加密内容
            String str = "测试内容";
            //密码,长度要是8的倍数
            String password = "0123456776543210";
    
            byte[] result = TestDES.encrypt(str.getBytes(),password);
            System.out.println("加密后:"+new String(result));
            //直接将如上内容解密
            try {
                byte[] decryResult = TestDES.decrypt(result, password);
                System.out.println("解密后:"+new String(decryResult));
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        }
        
        /**
         * 加密
         * @param datasource byte[]
         * @param password String
         * @return byte[]
         */
        public static  byte[] encrypt(byte[] datasource, String password) {            
            try{
                SecureRandom random = new SecureRandom();
                DESKeySpec desKey = new DESKeySpec(password.getBytes());
                //创建一个密匙工厂,然后用它把DESKeySpec转换成
                SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
                SecretKey securekey = keyFactory.generateSecret(desKey);
                //Cipher对象实际完成加密操作
                Cipher cipher = Cipher.getInstance("DES");
                //用密匙初始化Cipher对象
                cipher.init(Cipher.ENCRYPT_MODE, securekey, random);
                //现在,获取数据并加密
                //正式执行加密操作
                return cipher.doFinal(datasource);
            }catch(Throwable e){
                    e.printStackTrace();
            }
            return null;
        }
        /**
         * 解密
         * @param src byte[]
         * @param password String
         * @return byte[]
         * @throws Exception
         */
        public static byte[] decrypt(byte[] src, String password) throws Exception {
            
            // DES算法要求有一个可信任的随机数源
            SecureRandom random = new SecureRandom();
            // 创建一个DESKeySpec对象
            DESKeySpec desKey = new DESKeySpec(password.getBytes());
            // 创建一个密匙工厂
            SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
            // 将DESKeySpec对象转换成SecretKey对象
            SecretKey securekey = keyFactory.generateSecret(desKey);
            // Cipher对象实际完成解密操作
            Cipher cipher = Cipher.getInstance("DES");
            // 用密匙初始化Cipher对象
            cipher.init(Cipher.DECRYPT_MODE, securekey, random);
            // 真正开始解密操作
            return cipher.doFinal(src);
        }
    }
    运行结果:

    run:
    加密后:w�\C�D��.C���
    解密后:测试内容
    成功构建 (总时间: 0 秒)
    


    展开全文
  • 对称加密算法概述

    2020-10-16 11:17:25
    对称加密算法概述1....针对非对称加密算法低效问题,各密码机构主张对称加密算法与非对称加密算法相结合,使用对称加密算法为数据加密/解密,使用公钥和私钥为对称加密算法密钥加密/解密。 2. 非对称加
  • 对称加密算法

    2016-12-01 15:17:53
    对称加密算法 提示:加密内容属于高级程序员的话题!有些内容会很枯燥!注意掌握加密的思路和操作步骤即可!代码不要求会写,只要会用就行!又称传统加密算法 加密和解密使用同一个密钥 对称加密算法示例 密钥:X ...
  • 比如常见的DES/AES都是属于对称加密算法。优点:算法公开、计算量小、加密速度快、加密效率高。缺点:秘钥的管理和分发非常困难,不够安全。在数据传送前,发送方和接收方必须商定好秘钥,然后双方都必...
  • 对称加密算法

    2016-12-01 15:17:20
    对称加密算法 提示:加密内容属于高级程序员的话题!有些内容会很枯燥!注意掌握加密的思路和操作步骤即可!代码不要求会写,只要会用就行! 介绍 非对称加密算法需要两个密钥:公开密钥(publickey) 和 私有...
  • RSA(RSA algorithm):由RSA公司发明,是一个支持变长密钥的公开密钥算法,需要加密的文件块的长度也是可变的,非对称加密算法。 DSA(Digital Signature Algorithm):数字签名算法,是一种标准的DSS(数字签名...
  • 该算法属于对称加密算法,与以前算法的区别在于,此算法中的置换表是随机生成的,并且对应位所采用的采用的置换码是根据密码中对应位的ASC码和上次使用的置换码的相对位置决定的.因此,可以认为每次使用的置换表...
  • RSA是由三位数学家Rivest、Shamir 和 Adleman 发明的非对称加密算法,这种算法非常可靠,秘钥越长,就越难破解。 目前被破解的最长RSA秘钥是768个二进制位,长度超过768位的秘钥还无法破解,但随着计算能力的增强,...
  • BASE64 严格地说,属于编码格式,而非加密算法 MD5(Message Digest algorithm 5,信息摘要算法) SHA(Secure Hash Algorithm,安全散列算法) HMAC(Hash Message Authentication Code,散列消息鉴别码...
  • DES 和 3DES(TripleDES) 属于最常用的对称加密算法,其他的对称加密算法还有 AES、RC2、RC4、RC5 和 Blowfish 等。 3DES加解密工具 1、数据补位 DES 数据加解密就是讲数据按照 8 字节一段进行 DES 加密或解密得到...
  • RSA加密属于对称加密,加密一个秘钥,解密一个秘钥,分别为公钥和私钥。所谓公钥,就是公开的秘钥,任何人都可以下载、浏览、使用,而私钥,是一旦创建后,只有自己知道的秘钥,一定不能泄露给他人,否则整个加密...
  • 对称加密算法 RSA 与 ECC

    千次阅读 2018-06-09 13:07:45
    RSA 属于公钥密码系统,反向使用公钥密码系统便提供了数字签名的功能,RSA 的安全性较高,但是随之而来的计算量也较大(例如指数运算),且会随着规模的增加而增大。 RSA 初始化阶段需要找到两个大素数,p 和 q;其...
  • RC4是一种对称密码算法,它属于...RC4加密算法是Ron Rivest在1987年设计出的密钥长度可变的加密算法簇。起初该算法是商业机密,直到1994年,它才公诸于众。由于RC4具有算法简单,运算速度快,软硬件实现都十分容易等
  • AES加密算法简介

    2018-06-22 17:17:50
    AES-对称加密算法 属于对称加密算法。 对称加密算法只是为了区分非对称加密算法。其中鲜明的特点是对称加密是加密解密使用相同的密钥,而非对称加密加密和解密时使用的密钥不一样。对于大部分情况我们都使用对称...
  • 摘要:实现通用的对称加密算法工具类。 在.Net Framework中与安全、加密相关的共有三大类: Hash算法:将一个流使用Hash算法计算其相应的Hash值,我们最常见的MD5、SHA1均属于Hash算法。 对称算法:顾名思义,可以...
  • RSA加密算法

    2016-12-14 20:28:51
    以前的加密算法,大部分属于对称加密算法。通信双方只有掌握同一种规则,才能进行加密解密。这种加密模式有一个最大弱点:甲方必须把加密规则告诉乙方,否则无法解密。就好像一把钥匙单独对应一把锁。但是问题在于,...
  • 比如常见的DES/AES都是属于对称加密算法。 优点:算法公开、计算量小、加密速度快、加密效率高。 缺点:秘钥的管理和分发非常困难,不够安全。 非对称加密:算法需要两个密钥来进行加密和解密,这两个秘钥是公开...
  • 加密解密,曾经是我一个毕业设计的重要组件。在工作了多年以后回想当时那个加密、解密...BASE64 严格地说,属于编码格式,而非加密算法 MD5(MessageDigestalgorithm 5,信息摘要算法) SHA(SecureHashAlgorithm,安...
  • 加密对称算法

    2008-10-14 09:51:04
    如DES,3DES,AES等算法属于对称算法。下面会对这几种有代表性的算法一一做介绍。 DES算法 DES(Data Encryption Standard)是一种经典的对称算法。其数据分组长度为64位,使用的密钥为64位,有效密钥长度为56...
  • 这是信息系统安全实验系列的第五篇~ 1. 实验目的 (1)掌握对称加密、非对称加密... 凯撒密码是一种简单的替换密码,属于对称加密算法中的一种。密钥十分简单,选定一个mod 26的数作为密钥。加密时,将被加密的字...
  • RC4加密算法理解

    2019-10-26 10:47:11
    它加解密使用相同的密钥,因此也属于对称加密算法。RC4是有线等效加密(WEP)中采用的加密算法,也曾经是TLS可采用的算法之一。 原理:总体来说包括两个部分:1.初始化密匙盒子。2.伪随机密码生成 PS:不需要...
  • 2、对称加密与非对称加密 对称加密,或专用密钥(也称做常规加密)由通信两方共享...算法(IDEA)以及Skipjack加密技术都属于对称加密方式。 非对称加密,当发送信息时, 发送方使用接收方的公钥对数据加密,而...
  • JAVA中的Blowfish加密属于对称密钥算法,如果知道密钥,则可以对加密后的数据解密,但如果如果不知道密钥,基本上是不可能的,因此,这就决定了它的先天不足,就是带来的密钥的管理问题

空空如也

空空如也

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

属于对称加密算法