JAVA加密解密之3DES(TripleDES)

最新推荐文章于 2024-05-25 21:18:23 发布
最新推荐文章于 2024-05-25 21:18:23 发布
阅读量5.4k 收藏 1
点赞数 1
分类专栏： JAVA JAVA加密解密 文章标签： java 加密 解密 3DES Triple
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jianggujin/article/details/50536949
版权

3DES算法简介

3DES（或称为Triple DES）是三重数据加密算法（TDEA，Triple Data Encryption Algorithm）块密码的通称。它相当于是对每个数据块应用三次DES加密算法。由于计算机运算能力的增强，原版DES密码的密钥长度变得容易被暴力破解；3DES即是设计用来提供一种相对简单的方法，即通过增加DES的密钥长度来避免类似的攻击，而不是设计一种全新的块密码算法。

3DES算法实现

package com.jianggujin.codec;

import java.io.InputStream;
import java.io.OutputStream;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

import com.jianggujin.codec.util.JCipherInputStream;
import com.jianggujin.codec.util.JCipherOutputStream;
import com.jianggujin.codec.util.JCodecException;

/**
 * 3DES（或称为Triple DES）是三重数据加密算法（TDEA，Triple Data Encryption
 * Algorithm）块密码的通称。它相当于是对每个数据块应用三次DES加密算法
 * 
 * @author jianggujin
 *
 */
public class JTripleDES {

   /**
    * DES算法
    * 
    * @author jianggujin
    *
    */
   public static enum JDESAlgorithm {

      DES, DESede;

      public String getName() {
         return this.name();
      }
   }

   /**
    * 工作模式
    * 
    * @author jianggujin
    *
    */
   public static enum JWorkingMode {

      /**
       * 该模式不能使用向量
       */
      ECB, CBC, CFB, OFB, CTR;

      public String getName() {
         return this.name();
      }
   }

   /**
    * 填充方式
    * 
    * @author jianggujin
    *
    */
   public static enum JPadding {

      NoPadding, PKCS5Padding;

      public String getName() {
         return this.name();
      }
   }

   /**
    * 初始化密钥
    * 
    * @param algorithm
    * @return
    * @throws Exception
    */
   public static byte[] initKey(String algorithm) {
      try {
         KeyGenerator kg = KeyGenerator.getInstance(algorithm);
         return kg.generateKey().getEncoded();
      } catch (Exception e) {
         throw new JCodecException(e);
      }
   }

   /**
    * 初始化向量
    * 
    * @param algorithm
    * @param workingMode
    * @param padding
    * @return
    */
   public static byte[] initIv(String algorithm, String workingMode, String padding) {
      try {
         String fullAlg = algorithm + "/" + workingMode + "/" + padding;
         Cipher cipher = Cipher.getInstance(fullAlg);
         int blockSize = cipher.getBlockSize();
         byte[] iv = new byte[blockSize];
         for (int i = 0; i < blockSize; i++) {
            iv[i] = 0;
         }
         return iv;
      } catch (Exception e) {
         throw new JCodecException(e);
      }
   }

   /**
    * 加密
    * 
    * @param data
    * @param key
    * @param algorithm
    * @param workingMode
    * @param padding
    * @return
    */
   public static byte[] encrypt(byte[] data, byte[] key, String algorithm, String workingMode, String padding) {
      return encrypt(data, key, algorithm, workingMode, padding, null);
   }

   /**
    * 加密
    * 
    * @param data
    * @param key
    * @param algorithm
    * @param workingMode
    * @param padding
    * @param iv
    *           为null时则使用默认向量
    * @return
    */
   public static byte[] encrypt(byte[] data, byte[] key, String algorithm, String workingMode, String padding,
         byte[] iv) {
      // 数据加密
      Cipher cipher = getEncryptCipher(key, algorithm, workingMode, padding, iv);
      try {
         return cipher.doFinal(data);
      } catch (Exception e) {
         throw new JCodecException(e);
      }
   }

   /**
    * 包裹输出流，包裹后的输出流为加密输出流
    * 
    * @param out
    * @param key
    * @param algorithm
    * @param workingMode
    * @param padding
    * @return
    */
   public static OutputStream wrap(OutputStream out, byte[] key, String algorithm, String workingMode, String padding) {
      return wrap(out, key, algorithm, workingMode, padding, null);
   }

   /**
    * 包裹输出流，包裹后的输出流为加密输出流
    * 
    * @param out
    * @param key
    * @param algorithm
    * @param workingMode
    * @param padding
    * @param iv
    *           为null时则使用默认向量
    * @return
    */
   public static OutputStream wrap(OutputStream out, byte[] key, String algorithm, String workingMode, String padding,
         byte[] iv) {
      // 数据加密
      Cipher cipher = getEncryptCipher(key, algorithm, workingMode, padding, iv);

      return new JCipherOutputStream(cipher, out);
   }

   /**
    * 获得加密模式的{@link Cipher}
    * 
    * @param key
    * @param algorithm
    * @param workingMode
    * @param padding
    * @return
    */
   public static Cipher getEncryptCipher(byte[] key, String algorithm, String workingMode, String padding) {
      return getEncryptCipher(key, algorithm, workingMode, padding, null);
   }

   /**
    * 获得加密模式的{@link Cipher}
    * 
    * @param key
    * @param algorithm
    * @param workingMode
    * @param padding
    * @param iv
    *           为null时则使用默认向量
    * @return
    */
   public static Cipher getEncryptCipher(byte[] key, String algorithm, String workingMode, String padding, byte[] iv) {
      return getCipher(key, algorithm, workingMode, padding, iv, Cipher.ENCRYPT_MODE);
   }

   /**
    * 解密
    * 
    * @param data
    * @param key
    * @param algorithm
    * @param workingMode
    * @param padding
    * @return
    */
   public static byte[] decrypt(byte[] data, byte[] key, String algorithm, String workingMode, String padding) {
      return decrypt(data, key, algorithm, workingMode, padding, null);
   }

   /**
    * 解密
    * 
    * @param data
    * @param key
    * @param algorithm
    * @param workingMode
    * @param padding
    * @param iv
    *           为null时则使用默认向量
    * @return
    */
   public static byte[] decrypt(byte[] data, byte[] key, String algorithm, String workingMode, String padding,
         byte[] iv) {
      // 数据解密
      Cipher cipher = getDecryptCipher(key, algorithm, workingMode, padding, iv);
      try {
         return cipher.doFinal(data);
      } catch (Exception e) {
         throw new JCodecException(e);
      }
   }

   /**
    * 包裹输入流，原输入流为加密数据输入流
    * 
    * @param in
    * @param key
    * @param algorithm
    * @param workingMode
    * @param padding
    * @return
    */
   public static InputStream wrap(InputStream in, byte[] key, String algorithm, String workingMode, String padding) {
      return wrap(in, key, algorithm, workingMode, padding, null);
   }

   /**
    * 包裹输入流，原输入流为加密数据输入流
    * 
    * @param in
    * @param key
    * @param algorithm
    * @param workingMode
    * @param padding
    * @param iv
    *           为null时则使用默认向量
    * @return
    */
   public static InputStream wrap(InputStream in, byte[] key, String algorithm, String workingMode, String padding,
         byte[] iv) {
      // 数据解密
      Cipher cipher = getDecryptCipher(key, algorithm, workingMode, padding, iv);
      return new JCipherInputStream(cipher, in);
   }

   /**
    * 获得解密模式的{@link Cipher}
    * 
    * @param key
    * @param algorithm
    * @param workingMode
    * @param padding
    * @return
    */
   public static Cipher getDecryptCipher(byte[] key, String algorithm, String workingMode, String padding) {
      return getDecryptCipher(key, algorithm, workingMode, padding, null);
   }

   /**
    * 获得解密模式的{@link Cipher}
    * 
    * @param key
    * @param algorithm
    * @param workingMode
    * @param padding
    * @param iv
    *           为null时则使用默认向量
    * @return
    */
   public static Cipher getDecryptCipher(byte[] key, String algorithm, String workingMode, String padding, byte[] iv) {
      return getCipher(key, algorithm, workingMode, padding, iv, Cipher.DECRYPT_MODE);
   }

   /**
    * 获得{@link Cipher}
    * 
    * @param key
    * @param algorithm
    * @param workingMode
    * @param padding
    * @param iv
    *           为null时则使用默认向量
    * @param opmode
    * @return
    */
   private static Cipher getCipher(byte[] key, String algorithm, String workingMode, String padding, byte[] iv,
         int opmode) {
      // 生成本地密钥
      SecretKey secretKey = getSecretKey(key, algorithm);

      try {
         String fullAlg = algorithm + "/" + workingMode + "/" + padding;
         Cipher cipher = Cipher.getInstance(fullAlg);
         if (!JWorkingMode.ECB.getName().equalsIgnoreCase(workingMode)) {
            if (iv == null) {
               int blockSize = cipher.getBlockSize();
               iv = new byte[blockSize];
               for (int i = 0; i < blockSize; i++) {
                  iv[i] = 0;
               }
            }
            IvParameterSpec ivSpec = new IvParameterSpec(iv);
            cipher.init(opmode, secretKey, ivSpec);
         } else {
            cipher.init(opmode, secretKey);
         }
         return cipher;
      } catch (Exception e) {
         throw new JCodecException(e);
      }
   }

   /**
    * 获得密钥
    * 
    * @param key
    * @param algorithm
    * @return
    */
   private static SecretKey getSecretKey(byte[] key, String algorithm) {
      try {
         SecretKey secretKey = new SecretKeySpec(key, algorithm);
         return secretKey;
      } catch (Exception e) {
         throw new JCodecException(e);
      }
   }
}

测试代码：

package com.jianggujin.codec.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

import org.junit.Test;

import com.jianggujin.codec.JBase64;
import com.jianggujin.codec.JBase64.JEncoder;
import com.jianggujin.codec.JTripleDES;
import com.jianggujin.codec.JTripleDES.JDESAlgorithm;
import com.jianggujin.codec.JTripleDES.JPadding;
import com.jianggujin.codec.JTripleDES.JWorkingMode;

public class TripleDESTest {
   String str = "jianggujin111111";
   File file = new File(getClass().getSimpleName() + ".dat");

   @Test
   public void test() throws Exception {
      System.out.println("原串：" + str);
      JEncoder encoder = JBase64.getEncoder();
      for (JDESAlgorithm algorithm : JDESAlgorithm.values()) {
         System.out.println("算法：" + algorithm.getName());
         byte[] key = JTripleDES.initKey(algorithm.getName());
         System.out.println("密钥：" + encoder.encodeToString(key, "UTF-8"));
         for (JWorkingMode workingMode : JWorkingMode.values()) {
            for (JPadding padding : JPadding.values()) {
               System.out.println("-----------------------------------------");
               System.out.println(algorithm + "/" + workingMode + "/" + padding);
               byte[] encrypt = JTripleDES.encrypt(str.getBytes(), key, algorithm.getName(), workingMode.getName(),
                     padding.getName());
               System.out.println("加密：" + encoder.encodeToString(encrypt, "UTF-8"));
               System.out.println("解密：" + new String(
                     JTripleDES.decrypt(encrypt, key, algorithm.getName(), workingMode.getName(), padding.getName())));

               System.out.print("输出流加密：" + file.getAbsolutePath());
               OutputStream out = JTripleDES.wrap(new FileOutputStream(file), key, algorithm.getName(),
                     workingMode.getName(), padding.getName());
               out.write(str.getBytes());
               out.flush();
               out.close();
               System.out.println();
               System.out.print("输入流解密：");
               InputStream in = JTripleDES.wrap(new FileInputStream(file), key, algorithm.getName(),
                     workingMode.getName(), padding.getName());
               byte[] buffer = new byte[1024];
               int len = in.read(buffer);
               System.out.println(new String(buffer, 0, len));
            }
         }

      }
   }
}

测试结果
原串：jianggujin111111
算法：DES
密钥：STgOq5j+W2I=
—————————————–
DES/ECB/NoPadding
加密：xReaksflVhoskcgCSbx32g==
解密：jianggujin111111
输出流加密：F:\workspace\java\eclipse\JCodec\TripleDESTest.dat
输入流解密：jianggujin111111
—————————————–
DES/ECB/PKCS5Padding
加密：xReaksflVhoskcgCSbx32nAMw70j5Q4d
解密：jianggujin111111
输出流加密：F:\workspace\java\eclipse\JCodec\TripleDESTest.dat
输入流解密：jianggujin111111
—————————————–
DES/CBC/NoPadding
加密：xReaksflVhoAZm1EazC1pA==
解密：jianggujin111111
输出流加密：F:\workspace\java\eclipse\JCodec\TripleDESTest.dat
输入流解密：jianggujin111111
—————————————–
DES/CBC/PKCS5Padding
加密：xReaksflVhoAZm1EazC1pABSl+6raOnY
解密：jianggujin111111
输出流加密：F:\workspace\java\eclipse\JCodec\TripleDESTest.dat
输入流解密：jianggujin111111
—————————————–
DES/CFB/NoPadding
加密：lv3gnIv2ARWE+EURnN8qBQ==
解密：jianggujin111111
输出流加密：F:\workspace\java\eclipse\JCodec\TripleDESTest.dat
输入流解密：jianggujin111111
—————————————–
DES/CFB/PKCS5Padding
加密：lv3gnIv2ARWE+EURnN8qBeyGlXXo79Vj
解密：jianggujin111111
输出流加密：F:\workspace\java\eclipse\JCodec\TripleDESTest.dat
输入流解密：jianggujin111111
—————————————–
DES/OFB/NoPadding
加密：lv3gnIv2ARWdOf4IFFr2RA==
解密：jianggujin111111
输出流加密：F:\workspace\java\eclipse\JCodec\TripleDESTest.dat
输入流解密：jianggujin111111
—————————————–
DES/OFB/PKCS5Padding
加密：lv3gnIv2ARWdOf4IFFr2REpbraYN8vK1
解密：jianggujin111111
输出流加密：F:\workspace\java\eclipse\JCodec\TripleDESTest.dat
输入流解密：jianggujin111111
—————————————–
DES/CTR/NoPadding
加密：lv3gnIv2ARX96lBo58xf8A==
解密：jianggujin111111
输出流加密：F:\workspace\java\eclipse\JCodec\TripleDESTest.dat
输入流解密：jianggujin111111
—————————————–
DES/CTR/PKCS5Padding
加密：lv3gnIv2ARX96lBo58xf8A==
解密：jianggujin111111
输出流加密：F:\workspace\java\eclipse\JCodec\TripleDESTest.dat
输入流解密：jianggujin111111
算法：DESede
密钥：+MQqI5g+c2GJbdOnTFRUkQ2zdgj96hX4
—————————————–
DESede/ECB/NoPadding
加密：4DfUS0dkn0Yf1NIThNPzRA==
解密：jianggujin111111
输出流加密：F:\workspace\java\eclipse\JCodec\TripleDESTest.dat
输入流解密：jianggujin111111
—————————————–
DESede/ECB/PKCS5Padding
加密：4DfUS0dkn0Yf1NIThNPzRG7eKaTs2NC9
解密：jianggujin111111
输出流加密：F:\workspace\java\eclipse\JCodec\TripleDESTest.dat
输入流解密：jianggujin111111
—————————————–
DESede/CBC/NoPadding
加密：4DfUS0dkn0Y5mctZQQs4lg==
解密：jianggujin111111
输出流加密：F:\workspace\java\eclipse\JCodec\TripleDESTest.dat
输入流解密：jianggujin111111
—————————————–
DESede/CBC/PKCS5Padding
加密：4DfUS0dkn0Y5mctZQQs4liPGg8/jDzsk
解密：jianggujin111111
输出流加密：F:\workspace\java\eclipse\JCodec\TripleDESTest.dat
输入流解密：jianggujin111111
—————————————–
DESede/CFB/NoPadding
加密：2huLYOt44ucXsUXX2fQuqw==
解密：jianggujin111111
输出流加密：F:\workspace\java\eclipse\JCodec\TripleDESTest.dat
输入流解密：jianggujin111111
—————————————–
DESede/CFB/PKCS5Padding
加密：2huLYOt44ucXsUXX2fQuq85yWpJ1qxaq
解密：jianggujin111111
输出流加密：F:\workspace\java\eclipse\JCodec\TripleDESTest.dat
输入流解密：jianggujin111111
—————————————–
DESede/OFB/NoPadding
加密：2huLYOt44uedB3fPCBGGmA==
解密：jianggujin111111
输出流加密：F:\workspace\java\eclipse\JCodec\TripleDESTest.dat
输入流解密：jianggujin111111
—————————————–
DESede/OFB/PKCS5Padding
加密：2huLYOt44uedB3fPCBGGmBmF7G+qCWDe
解密：jianggujin111111
输出流加密：F:\workspace\java\eclipse\JCodec\TripleDESTest.dat
输入流解密：jianggujin111111
—————————————–
DESede/CTR/NoPadding
加密：2huLYOt44ucNRy7fPNJGmA==
解密：jianggujin111111
输出流加密：F:\workspace\java\eclipse\JCodec\TripleDESTest.dat
输入流解密：jianggujin111111
—————————————–
DESede/CTR/PKCS5Padding
加密：2huLYOt44ucNRy7fPNJGmA==
解密：jianggujin111111
输出流加密：F:\workspace\java\eclipse\JCodec\TripleDESTest.dat
输入流解密：jianggujin111111

蒋固金
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
tripledes java_Java加密算法Triple DES详解
weixin_33389183的博客
02-16 653
import javax.crypto.Cipher;import javax.crypto.KeyGenerator;import javax.crypto.SecretKey;import javax.crypto.SecretKeyFactory;import javax.crypto.spec.DESedeKeySpec;import javax.crypto.spec.IvParamet...
Triple Des加密算法
washingtin的专栏
09-23 4004
介绍摘自Wikipedia： Triple DES又称3DES，是DES加密算法的一种模式，它使用3条56位的密钥对 3DES 数据进行三次加密。数据加密标准（DES）是美国的一种由来已久的加密标准，它使用对称密钥加密法，并于1981年被ANSI组织规范为ANSI X.3.92。DES使用56位密钥和密码块的方法，而在密码块的方法中，文本被分成64位大小的文本块然后再进行加密。比起...
【算法】Java实现3DES算法
热门推荐
分享Java硬核干货
06-27 1万+
3DES（Triple Data Encryption Standard）是对DES算法的增强和扩展，也称为TDES或Triple DES。它是一种对称密钥加密算法，通过对数据应用DES算法三次来增加安全性。3DES使用两个或三个不同的密钥对数据进行加密和解密。将明文数据分成64位的块。使用密钥1对第一个64位块进行DES加密，得到中间结果。使用密钥2对中间结果进行DES解密。使用密钥3（如果使用三个密钥）对上一步得到的结果再次进行DES加密。
Pair和Triple的最佳实践
最新发布
在途中
05-25 1049
在计算机科学中，Pair是一种包含两个元素的数据结构。它可以用来存储成对的数据，这两个元素可以是任意类型。return key;Triple是一种包含三个元素的数据结构，类似于Pair，但它能存储三个相关联的元素。return key;本文详细介绍了Pair和Triple的数据结构及其在Java语言中的应用。我们讨论了它们的定义、常见用途，并提供了具体的Java代码示例。Pair和Triple在处理多值返回、数据映射和数据传输等方面非常有用。
Java 中常见的加密算法，DES、3DES、AES、RSA
u013749113的博客
05-20 3500
加密算法是一种将数据转换为不可读形式的算法，以保护数据的机密性和完整性。加密算法被广泛应用于计算机网络、数据库、电子商务等领域，用于保护敏感数据的安全性，如用户密码、信用卡信息、医疗记录等。在 Java 中，有许多常见的加密算法，本文将对加密算法的基本概念和常见的加密算法进行介绍，并附上代码示例。
加解密篇 - 对称加密算法 (DES、3DES、AES、RC)
ss810540895的博客
05-12 2971
我们开发通常采用128位16个字节的密钥，我们使用 AES 加密时需要主动提供密钥，而且只需要提供一个密钥就够了，每段数据加密使用的都是这一个密钥，密钥来源为随机生成**（我们开发时传入的那个为初始密钥，除了初始密钥以外，后面每一轮的密钥都是由上一轮的密钥扩展而来的，密钥扩展有四个步骤：排列、置换、与轮常量异或、生成下一轮密钥的其他列）**。比起最初的 DES，AES 更为安全。采用单钥密码系统的加密方法，同一个密钥用来加密和解密，常见的对称加密算法有 DES，3DES，AES，RC2，RC4，RC5等。
基于Java DES与3DES加密解密
sh879682的博客
04-21 3566
DES/3DES属于对称加密算法。3des即用DES进行三重加密。 下面分别用Java代码实现DES加密解密与3DES加密解密，如有错误请指正，谢谢！ DES加密解密： /** * DES加密 * @param datasource，加密数据 * @param password，密钥 * @return */ public static byte[] encrypt(byte[...
java 3DES加密解密
yqichang的专栏
09-15 6086
3DES（或称为Triple DES）是三重数据加密算法（TDEA，Triple Data Encryption Algorithm）块密码的通称。它相当于是对每个数据块应用三次DES加密算法。由于计算机运算能力的增强，原版DES密码的密钥长度变得容易被暴力破解；3DES即是设计用来提供一种相对简单的方法，即通过增加DES的密钥长度来避免类似的攻击，而不是设计一种全新的块密码算法。 下面使用ja
实现使用3des在页面js加密，后台java解密
12-04
本篇将详细介绍如何在网页前端使用JavaScript进行3DES加密，并在后端Java环境中进行解密。 一、3DES加密原理 3DES是DES的加强版，它使用了3个不同的56位密钥，通过3次独立的DES加密过程来提高安全性。具体流程如下...
小程序+java后端统一 des 加密解密
09-27
在标题提到的"小程序+java后端统一 des 加密解密"中，我们主要讨论的是使用DES（Data Encryption Standard）算法进行数据加密和解密的实践，这涉及到小程序客户端与Java后端服务之间的安全通信。 DES是一种对称加密...
3DES加密解密java版+js版
02-02
在提供的文件`加密web.zip`和`java.zip`中，很可能包含了Java实现3DES加密解密的代码示例，以及可能用于Web端的JavaScript实现。这些代码可以帮助开发者理解如何在实际项目中跨平台地应用3DES加密技术。 3DES虽然...
Triple-DES java实现
05-24
Triple-DES 加密解密算法的java实现
TripleDES.zip_DES tripledes_TripleDES java_Tripledes java
09-14
描述中提到"一个用Java实现的三重des加密与解密过程的程序"，意味着这个压缩包包含了一个Java程序，该程序实现了3DES的加密和解密功能。在Java中，我们可以使用`javax.crypto`包下的类来实现这一过程。关键类包括`...
Java实现3DES加密解密（DESede/ECB/PKCS5Padding使用）
12程序猿的博客
11-30 8701
Java实现3DES加密解密（DESede/ECB/PKCS5Padding使用）
使用Java实现3DES加密解密
Fantasy
07-10 2299
3DES又称TripleDES，是三重数据加密算法（TDEA，Triple Data Encryption Algorithm）块密码的通称。它相当于是对每个数据块应用三次DES加密算法。密钥长度是128位(bit)和192位(bit)。原版DES容易被破解，新的3DES出现，增加了加密安全性，避免被暴力破解。它同样是对称性加密，同样涉及到加密模式和填充方式。加密模式有ECB、CBC、CTR、OFB、CFB。填充方式有PKCS5Padding、PKCS7Padding、ZeroPadding、ISO101
Java中的DES和3DES加密算法详解
码到三十五
03-25 9547
DES加密算法的安全性主要依赖于密钥的保密性和算法的复杂性。然而，由于DES算法使用的密钥长度较短（56位），它已经受到暴力破解攻击的威胁。因此，在实际应用中，建议使用更安全的加密算法，如AES（Advanced Encryption Standard）。AES算法提供了更大的密钥长度和更复杂的加密过程，以提供更高的安全性。
python rsa解密_python中对RSA的加密和解密
weixin_39907850的博客
12-10 256
首先，生成一对密钥，并保存def create_keys(): # 生成公钥和私钥(pubkey, privkey) = rsa.newkeys(1024)pub = pubkey.save_pkcs1()with open('public.pem','wb+')as f:f.write(pub)pri = privkey.save_pkcs1()with open('private.pem','...
【JAVA秒会技术之加密】3DES(TripleDES)实现跨平台统一加密
weixin_34400525的博客
11-07 298
3DES(TripleDES)实现跨平台统一加密 一、3DES简介 3DES（或称为Triple DES）是三重数据加密算法（TDEA，Triple Data Encryption Algorithm）块密码的通称。它相当于是使用3条56位的密钥对每个数据块应用三次DES加密算法。由于计算机运算能力的增强，原版DES密码的密钥长度变得容易被暴力破解...
python 3DES加密解密
09-26
python实现3DES加密解密的代码示例如下： ```python import pyDes # 定义密钥，长度必须为8个字符（64位） key = b'12345678' # 定义初始化向量，长度为8个字符（64位） iv = b'abcdefgh' # 创建加密器 k = pyDes....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值