java中的加解密操作

最新推荐文章于 2024-08-02 07:30:00 发布
最新推荐文章于 2024-08-02 07:30:00 发布
阅读量1.2k 收藏
点赞数
分类专栏： Android基础 文章标签： android java 解密
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lepaitianshi/article/details/50543224
版权

      java中，加解密方式有五种，Base64、消息摘要、对称加密、非对称加密、数字签名。

   消息摘要加密有两种算法：MD和SHA

   对称加密有四种算法：DES、3DES、AES、PBE

   非对称加密有两种算法：DH、RSA

   数字签名有三种算法:RSA、DSA、ECDSA

    

   

public class EncodeUtil {
    /**
     * Base64
     * @param code
     * @return
     */
    public static String base64Encode(String code){
        byte[] encode=null;
        //bc
        encode =org.bouncycastle.util.encoders.Base64.encode(code.getBytes());
        //cc
       encode=Base64.encodeBase64(code.getBytes());
        return new String(encode);

    }

    /***
     * MD5
     * @param code
     * @return
     */
    public static String md5Encode(String code){
        byte[] md5Encode = null;
        //jdk
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            md5Encode=md.digest(code.getBytes());
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        //bc
        MD5Digest digest = new MD5Digest();
        digest.update(code.getBytes(),0,code.getBytes().length);
        md5Encode=new byte[digest.getDigestSize()];
        digest.doFinal(md5Encode,0);
        //cc
        md5Encode =DigestUtils.md5(code.getBytes());
        return Hex.encodeHexString(md5Encode);
    }

    /**
     * SHA
     * @param code
     * @return
     */
    public static String shaEncode(String code){
        byte[] shaEncode=null;
        //jdk
        try {
            MessageDigest messageDigest=MessageDigest.getInstance("SHA");
           shaEncode=messageDigest.digest(code.getBytes());
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        //bc
        Digest digest = new SHA1Digest();
        digest.update(code.getBytes(),0,code.getBytes().length);
        shaEncode = new byte[digest.getDigestSize()];
        digest.doFinal(shaEncode,0);
        //cc
        shaEncode =DigestUtils.sha1(code);
        return Hex.encodeHexString(shaEncode);
    }
    /***
     * 对称加密
     * 第一步：生成Key
     * 第二步：转换Key
     * 第三步：加解密的操作
     */
   public static String desEncode(String code){
       byte[] desEncode=null;
       try {
           //jdk
           //生成Key
           KeyGenerator keygenerator=KeyGenerator.getInstance("DES");
           keygenerator.init(56);
           SecretKey secretKey=keygenerator.generateKey();
           byte[] byteKey=secretKey.getEncoded();

           //Key的转换
           DESKeySpec desKetSpec= new DESKeySpec(byteKey);
           SecretKeyFactory secretKeyFactory=SecretKeyFactory.getInstance("DES");
           Key convertKey=secretKeyFactory.generateSecret(desKetSpec);

           //加密
           Cipher cipher=Cipher.getInstance("DES/ECB/PKCSPadding");
           cipher.init(Cipher.ENCRYPT_MODE,convertKey);
           desEncode=cipher.doFinal(code.getBytes());
       } catch (NoSuchAlgorithmException e) {
           e.printStackTrace();
       } catch (InvalidKeyException e) {
           e.printStackTrace();
       } catch (InvalidKeySpecException e) {
           e.printStackTrace();
       } catch (NoSuchPaddingException e) {
           e.printStackTrace();
       } catch (BadPaddingException e) {
           e.printStackTrace();
       } catch (IllegalBlockSizeException e) {
           e.printStackTrace();
       }
       return Hex.encodeHexString(desEncode);
   }
    public static String threedesEncode(String code){
        byte[] desEncode=null;
        try {
            //jdk
            //生成Key
            KeyGenerator keygenerator=KeyGenerator.getInstance("DESede");
            keygenerator.init(168);
            SecretKey secretKey=keygenerator.generateKey();
            byte[] byteKey=secretKey.getEncoded();

            //Key的转换
            DESedeKeySpec desKetSpec= new DESedeKeySpec(byteKey);
            SecretKeyFactory secretKeyFactory=SecretKeyFactory.getInstance("DESede");
            Key convertKey=secretKeyFactory.generateSecret(desKetSpec);

            //加密
            Cipher cipher=Cipher.getInstance("DESede/ECB/PKCSPadding");
            cipher.init(Cipher.ENCRYPT_MODE,convertKey);
            desEncode=cipher.doFinal(code.getBytes());
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        }
        return Hex.encodeHexString(desEncode);
    }
    public static String aesEncode(String code){
        byte[] aesEncode=null;
        //jdk
        try {
            //生成Key
            KeyGenerator keyGenerator=KeyGenerator.getInstance("AES");
            keyGenerator.init(new SecureRandom());
            SecretKey secretKey=keyGenerator.generateKey();
            byte[] keyByte=secretKey.getEncoded();

            //key的转换
            Key key = new SecretKeySpec(keyByte,"AES");

            //加密
            Cipher cipher=Cipher.getInstance("AES/ECB/PKS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE,key);
            aesEncode=cipher.doFinal(code.getBytes());
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        }
        return Hex.encodeHexString(aesEncode);
    }
    public static String pbeEncoder(String code){
        byte[] pbeEncode=null;
        try {
            //jdk
            //初始化盐
            SecureRandom secureRam = new SecureRandom();
            byte[] salt = secureRam.generateSeed(8);

            //口令与密钥
            String password="123456";
            PBEKeySpec pbeKeySpec= new PBEKeySpec(password.toCharArray());
            SecretKeyFactory factory =SecretKeyFactory.getInstance("PBEWITHMD5andDES");

            //生成Key
            Key key=factory.generateSecret(pbeKeySpec);

            //加密
            PBEParameterSpec pbeParameterSpec= new PBEParameterSpec(salt,100);
            Cipher cipher = Cipher.getInstance("PBEWITHMD5andAES");
            cipher.init(Cipher.ENCRYPT_MODE,key,pbeParameterSpec);
            pbeEncode =cipher.doFinal(code.getBytes());
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (InvalidAlgorithmParameterException e) {
            e.printStackTrace();
        }
        return Hex.encodeHexString(pbeEncode);
    }
    /***
     * 非对称加密。
     * 第一步：发送方生成sendPublicKeyEnc
     * 第二步：接收方根据发送方的sendPublicKeyEnc构建自己的本地密钥以及receiverPublicKeyEnc
     * 第三步：发送方根据接收方的receiverPublicKeyEnc构建自己的本地密钥
     */
    public static String dhEncoder(String code){
        byte[] dhEncoder=null;
        try {
            //初始化发送方sendPublicKeyEnc。
            KeyPairGenerator sendKeyPairGenerator=KeyPairGenerator.getInstance("DH");
            sendKeyPairGenerator.initialize(512);
            KeyPair sendKeyPair = sendKeyPairGenerator.genKeyPair();
            byte[] sendPublicKeyEnc= sendKeyPair.getPublic().getEncoded();

            //解析发送方的PublicKeyEnc
            KeyFactory receiveKeyFactory= KeyFactory.getInstance("DH");
            X509EncodedKeySpec x509EncoderKeySpec=new X509EncodedKeySpec(sendPublicKeyEnc);
            PublicKey receiverPublicKey = receiveKeyFactory.generatePublic(x509EncoderKeySpec);
            DHParameterSpec dhParameterSpec=((DHPublicKey)receiverPublicKey).getParams();
            KeyPairGenerator receiverKeyPairGenerator = KeyPairGenerator.getInstance("DH");
            receiverKeyPairGenerator.initialize(dhParameterSpec);
            KeyPair receiverKeyPair = receiverKeyPairGenerator.generateKeyPair();

            //密钥构建以及生成receiverPublicKeyEnc
            KeyAgreement receiverKeyAgreement=KeyAgreement.getInstance("DH");
            PrivateKey receiverPrivateKey=receiverKeyPair.getPrivate();
            receiverKeyAgreement.init(receiverPrivateKey);
            receiverKeyAgreement.doPhase(receiverPublicKey, true);
            SecretKey receiverDesKey = receiverKeyAgreement.generateSecret("DES");
            byte[] receiverPublicKeyEnc = receiverKeyPair.getPublic().getEncoded();

            //发送方收到接收方的receiverPublicKeyEnc，生成自己的本地密钥
            KeyFactory sendKeyFactory = KeyFactory.getInstance("DH");
            x509EncoderKeySpec=new X509EncodedKeySpec(receiverPublicKeyEnc);
            PublicKey sendPublicKey = sendKeyFactory.generatePublic(x509EncoderKeySpec);
            KeyAgreement sendKeyAgreement = KeyAgreement.getInstance("DH");
            sendKeyAgreement.init(sendKeyPair.getPrivate());
            sendKeyAgreement.doPhase(sendPublicKey, true);
            //发送方本地密钥
            SecretKey sendDesKey=sendKeyAgreement.generateSecret("DES");

            //加密
            Cipher cipher = Cipher.getInstance("DES");
            cipher.init(Cipher.ENCRYPT_MODE,sendDesKey);
            dhEncoder=cipher.doFinal(code.getBytes());
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        } catch (InvalidAlgorithmParameterException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        }
        return Hex.encodeHexString(dhEncoder);
    }
    public static String rsaEncoder(String code){
        byte[] rsaEncoder=null;
        //jdk
        try {
            //初始化密钥
            KeyPairGenerator keyPairGrnerator=KeyPairGenerator.getInstance("RSA");
            keyPairGrnerator.initialize(512);
            KeyPair keyPair = keyPairGrnerator.generateKeyPair();
            RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
            RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();

            //私钥加密，公钥解密----加密
            PKCS8EncodedKeySpec pkcs8EncodedKeySpec=new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
            KeyFactory keyFactory=KeyFactory.getInstance("RSA");
            PrivateKey privateKey=keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            Cipher cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE,privateKey);
            rsaEncoder = cipher.doFinal(code.getBytes());

            //私钥加密，公钥解密----解密
            X509EncodedKeySpec x509EncodedKeySpec= new X509EncodedKeySpec(rsaPublicKey.getEncoded());
            keyFactory = KeyFactory.getInstance("RSA");
            PublicKey publicKey=keyFactory.generatePublic(x509EncodedKeySpec);
            cipher=Cipher.getInstance("RSA");
            cipher.init(Cipher.DECRYPT_MODE, publicKey);
            rsaEncoder =cipher.doFinal(rsaEncoder);

            //公钥加密，私钥解密----加密
            x509EncodedKeySpec= new X509EncodedKeySpec(rsaPublicKey.getEncoded());
            keyFactory = KeyFactory.getInstance("RSA");
            publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
            cipher=Cipher.getInstance("RSA");
            cipher.init(Cipher.ENCRYPT_MODE,publicKey);
            rsaEncoder=cipher.doFinal(code.getBytes());
            //公钥加密，私钥解密----解密
            pkcs8EncodedKeySpec=new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
            keyFactory=KeyFactory.getInstance("RSA");
            privateKey=keyFactory.generatePrivate(pkcs8EncodedKeySpec);
            cipher = Cipher.getInstance("RSA");
            cipher.init(Cipher.DECRYPT_MODE,privateKey);
            rsaEncoder = cipher.doFinal(rsaEncoder);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        }
        return Hex.encodeHexString(rsaEncoder);
    }
    /***
     * 数字签名算法 RSA DSA ECDSA
     */
    public static String signRsaEncoder(String code){
        byte[] signRsaEncode=null;
        try {
            //jdk
            //初始化密钥
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            keyPairGenerator.initialize(512);
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
            RSAPrivateKey rsaPrivateKey= (java.security.interfaces.RSAPrivateKey) keyPair.getPrivate();

            //执行私钥签名
            PKCS8EncodedKeySpec pkcS8EncodedKeySpec=new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
            KeyFactory keyFactory=KeyFactory.getInstance("RSA");
            PrivateKey privateKey=keyFactory.generatePrivate(pkcS8EncodedKeySpec);
            Signature signature= Signature.getInstance("MD5withRSA");
            signature.initSign(privateKey);
            signature.update(code.getBytes());
            signRsaEncode=signature.sign();

            //公钥验证签名
            X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec(rsaPublicKey.getEncoded());
            keyFactory = KeyFactory.getInstance("RSA");
            PublicKey publicKey=keyFactory.generatePublic(x509EncodedKeySpec);
            signature = Signature.getInstance("MD5withRSA");
            signature.initVerify(publicKey);
            signature.update(code.getBytes());
            boolean isTrue =signature.verify(signRsaEncode);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (SignatureException e) {
            e.printStackTrace();
        }
        return Hex.encodeHexString(signRsaEncode);
    }
    public static String signDsaEncode(String code){
        byte[] signDsaEncode=null;
        try {
            //初始化密钥
            KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance("DSA");
            keyPairGenerator.initialize(512);
            KeyPair keyPair=keyPairGenerator.generateKeyPair();
            DSAPublicKey dsaPublicKey= (DSAPublicKey) keyPair.getPublic();
            DSAPrivateKey dsaPrivateKey= (DSAPrivateKey) keyPair.getPrivate();
            //执行签名
            PKCS8EncodedKeySpec pkcS8EncodedKeySpec=new PKCS8EncodedKeySpec(dsaPrivateKey.getEncoded());
            KeyFactory keyFactory=KeyFactory.getInstance("DSA");
            PrivateKey privateKey=keyFactory.generatePrivate(pkcS8EncodedKeySpec);
            Signature signnatrue=Signature.getInstance("SHA1withDSA");
            signnatrue.initSign(privateKey);
            signnatrue.update(code.getBytes());
            signDsaEncode=signnatrue.sign();
            //验证签名
            X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec(dsaPublicKey.getEncoded());
            keyFactory = KeyFactory.getInstance("DSA");
            PublicKey publicKey=keyFactory.generatePublic(x509EncodedKeySpec);
            signnatrue = Signature.getInstance("SHA1withDSA");
            signnatrue.initVerify(publicKey);
            signnatrue.update(code.getBytes());
            boolean isTrue =signnatrue.verify(signDsaEncode);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (SignatureException e) {
            e.printStackTrace();
        }
        return Hex.encodeHexString(signDsaEncode);
    }
    public static String signEcDsaEncode(String code){
        byte[] signEcDsaEncode=null;
        try {
            //初始化密钥
            KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance("DSA");
            keyPairGenerator.initialize(512);
            KeyPair keyPair=keyPairGenerator.generateKeyPair();
            ECPublicKey ecPublicKey= (ECPublicKey) keyPair.getPublic();
            ECPrivateKey ecPrivateKey= (ECPrivateKey) keyPair.getPrivate();
            //执行签名
            PKCS8EncodedKeySpec pkcS8EncodedKeySpec=new PKCS8EncodedKeySpec(ecPrivateKey.getEncoded());
            KeyFactory keyFactory=KeyFactory.getInstance("EC");
            PrivateKey privateKey=keyFactory.generatePrivate(pkcS8EncodedKeySpec);
            Signature signnatrue=Signature.getInstance("SHA1withECDSA");
            signnatrue.initSign(privateKey);
            signnatrue.update(code.getBytes());
            signEcDsaEncode=signnatrue.sign();
            //验证签名
            X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec(ecPublicKey.getEncoded());
            keyFactory = KeyFactory.getInstance("EC");
            PublicKey publicKey=keyFactory.generatePublic(x509EncodedKeySpec);
            signnatrue = Signature.getInstance("SHA1withECDSA");
            signnatrue.initVerify(publicKey);
            signnatrue.update(code.getBytes());
            boolean isTrue =signnatrue.verify(signEcDsaEncode);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (SignatureException e) {
            e.printStackTrace();
        }
        return Hex.encodeHexString(signEcDsaEncode);
    }
}

余生爱静
关注
专栏目录
java 加解密
07-25
根据秘钥进行加解密，适合用与用户的密码加密存储加密
java中AES及SM2加解密
02-16
在Java中，我们可以使用javax.crypto包中的Cipher类来实现AES的加解密操作。AES有多种工作模式，其中CBC（密文分组链接）模式是一种常用的模式，它通过前一密文块与当前明文块异或后再加密，增强了安全性。实现AES ...
Java中的加解密
风继续吹
11-23 921
一、Base64编码 Base64，它是一种编码方式，算不上一种加密算法。它就是使用64个可打印字符来表示二进制数据的方法。Base64一般用于在HTTP协议下传输二进制数据，由于HTTP协议是文本协议，所以在HTTP协议下传输二进制数据需要将二进制数据转换为字符数据。然而直接转换是不行的，此时可以将子节序列用Base64编码。 Java提供了Base64的编解码器，直接使用即可。 public class Base64Test { public static final Base64.Encode
Java中的数据加密与解密技术
最新发布
微赚开发者技术分享博客
08-02 677
数据加密与解密是保护敏感信息的重要手段，通过将明文数据转换为密文，防止未经授权的访问。对称加密使用相同的密钥进行加密和解密，而非对称加密使用一对密钥（公钥和私钥）进行加密和解密。本文详细介绍了在Java中实现数据加密与解密的几种常见技术，包括对称加密算法（AES）、非对称加密算法（RSA）以及结合使用AES和RSA的混合加密技术。为了同时利用对称加密的高效性和非对称加密的安全性，通常会将两者结合使用，即使用RSA加密AES密钥，使用AES加密实际数据。今天我们来探讨Java中的数据加密与解密技术。
java的一种加解密方法
蠢蠢欲动的猫
03-26 773
java的一种加解密方法
java 文件加解密
我要飞翔
01-14 710
文件的加解密难度倒是没有，网上有很多工具，但是我们可能可以加密，但是解密的时候回报错。具体错误就不截图了。 如果我们把加密和解密的文件都转为字节，就会发现他们的长度不一样。 解决办法：可以先对文件进行base64位处理，就不会出现这个问题。但是这样就会产生效率问题...
java加解密_Java加解密全
weixin_33252423的博客
02-15 165
package com.epayto.until;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;import java.securi...
Rsa加密解密.rar_RSA 加密解密_java rsa_rsa加密_rsa加密java_加密 解密
07-14
`Cipher`类在Java中用于加密和解密操作。初始化`Cipher`对象，使用公钥，并执行加密操作。 ```java Cipher cipher = Cipher.getInstance("RSA"); cipher.init(Cipher.ENCRYPT_MODE, publicKey); byte[] ...
JCT - java加密解密工具包.zip_Java加密_java 加密_jct java_加密 解密_加密工具
09-24
这个名为"JCT"的工具包提供了丰富的功能，使得开发者在Java应用中集成加密和解密操作变得更加简单。下面我们将详细探讨Java加密的相关知识点以及可能在JCT中涉及的技术。 1. **对称加密**：这是最常见的加密方式，...
des-java.rar_Java文件加解密_java 加解密_java加解密
09-23
Java文件加解密是软件开发中的重要一环，特别是在处理敏感数据时，数据的安全性显得尤为重要。本压缩包“des-java.rar”包含了关于Java中使用DES（Data Encryption Standard）算法进行文件加解密的相关示例和资料。...
java中常用工具类之字符串操作类和MD5加密解密类
09-04
在Java中，我们可以使用`java.security.MessageDigest`类来实现MD5加密。下面是一个简单的MD5加密类的示例： ```java package com.itjh.javaUtil; import java.security.MessageDigest; import java.security....
Java文件加解密工具
07-12
JavaSwing 字符串、文件加解密工具源码。支持字符流，字节流，分段加密。支持对称AES,DES，非对称RSA等加密，输出格式支持HEX,Base64，二进制流等
Java中常用的加密与解密
Lemon
12-23 7970
一、对称加密与非对称加密 1、对称加密 2、非对称加密 3、对称加密与非对称加密的区别
说说Java的加解密
samsung_samsung的专栏
03-22 620
Java的加解密
JAVA文件加密解密
weixin_33779515的博客
06-13 566
为什么80%的码农都做不了架构师？>>> ...
Java 加解密
chy1984的博客
09-28 1064
Secure Hash Algorithm 安全散列（哈希）算法，该算法的思想是接收一段明文（也称为输入码、预映射、信息），然后以一种不可逆的方式将它转换成一段长度较短、位数固定的密文（也称为输出序列、散列值、信息摘要、信息认证代码）。由于MD的设计，易受密码分析的攻击，SHA显得不易受这样的攻击，更安全。MD算法特点：计算得到的MD值长度固定，不管数据多大，摘要后都能生成唯一的MD值，对原数据进行任何改动，哪怕只修改个字节，所得到的MD值都会发生变化，伪造数据（找到具有相同MD值的数据）非常困难。
java加解密
long13131462101的专栏
12-07 74
[code="java"]第1章 基础知识 1.1. 单钥密码体制 单钥密码体制是一种传统的加密算法，是指信息的发送方和接收方共同使用同一把密钥进行加解密。 通常,使用的加密算法 比较简便高效,密钥简短，加解密速度快，破译极其困难。但是加密的安全性依靠密钥保管的安全性,在公开的计算机网络上安全地传送和保管密钥是一个严峻的问 题，并且如果在多用户的情况下密钥的保管安全性也...
Java EJB 加密解密实例详解
要实现加密与解密，你需要选择合适的加密算法，并使用Java的`Cipher`类来执行实际的加密和解密操作。例如，你可以创建一个`Cipher`对象，设置加密模式，然后使用`doFinal`方法处理数据。解密过程类似，但需要设置...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值