Java对称加密工作模式原理详解

来源:脚本之家  责任编辑:小易  

如果我说没有区别你会信吗?但答案还真是这样,两者没有任何区别的,只不过实现的语言代码不同而已。

这篇文章主要介绍了Java对称加密工作模式原理详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

^是异或运算符,异或运算满足交换律,结合律和自反性,交换律是指异或顺序无所谓,结合律是说(a^b)^

对称加密又分为分组加密和序列密码。

非对称加密和对称加密在加密和解密过程、加密解密速度、传输的安全性上都有所不同,具体介绍如下:1、加

分组密码,也叫块加密(block cyphers),一次加密明文中的一个块。是将明文按一定的位长分组,明文组经过加密运算得到密文组,密文组经过解密运算(加密运算的逆运算),还原成明文组。

没有区别,DES只是加密的一种算法,Java与.NET语言中只是对这种算法的实现,所以两者是没有任何

序列密码,也叫流加密(stream cyphers),一次加密明文中的一个位。是指利用少量的密钥(制乱元素)通过某种复杂的运算(密码算法)产生大量的伪随机位流,用于对明文位流的加密。

从宏观上介绍一下Java虚拟机的工作原理。从最初编写的Java源文件(.java文件)是如何一步步执

解密是指用同样的密钥和密码算法及与加密相同的伪随机位流,用以还原明文位流。

其实害羞或者内向,本身就是一种正常的生理现象,外向与内向并无优劣之分!我家大女儿,以前也挺内向的,不肯和别人说话,甚至见到她同学都不爱打招呼,我便试着用以下方法来试着改变一下她,效果也还不错,虽然并没改变她内向的性格,但至少改变了一些??一,多带孩子出去参加集体活动。比如公园,聚会……都是有很多人的地方,多带孩子出去参加这种场合,开阔孩子的视野,见识,并鼓励孩子参与其中,一开始也不要硬推着他参与,哪怕刚开始在那儿看着别人怎么玩都没事,慢慢来,孩子感兴趣了自会参与其中。二,选择孩子爱好的事情让他们做。比如孩子爱画画,那我们就给他报个美术班让他去学;爱好跳舞,就让他去学舞蹈……当他们从中体会到乐趣

分组加密算法中,有ECB,CBC,CFB,OFB这几种算法模式。

男人的最佳生育年龄是几岁父亲年龄影响宝宝智商男人一生中,有哪个几个阶段是最佳生育期,这期间,身体状态比较乐观,而且精子质量也是比较高的,这个时期的男人要抓紧时间把你的优良基因传播下去噢。那么,男人最佳的生育期是什么时候呢,今天我们就一起来看看吧。男人的最佳生育期是何时——男人生育年龄有限制吗男人在35岁的时候,精子质量是一个分水岭,虽说老年男性的精子并不衰老,而且密度也较高,但精子出现基因变异的比率大大增加,精子活动能力已有明显下降的势头,不动的与畸形的精子数增加了20%。不仅如此,精子代谢的速度也有所下滑,代谢后还产生了不少废物,这些都对生育产生着不良的影响。所以,从优生角度看,男人当爹的最

1)ECB(Electronic Code Book)/电码本模式

8月21日,由腾讯和PACE共同打造的智能运动手环在京东众筹上线,而这款手环也毫无意外的加入了“社交”功能。下面我们就来看看这款腾讯手环究有什么不一样?作为腾讯合作的的首款智能手环,在玩法上与社交搭边其实已在很多人的预料之中。据了解,PacewearS8智能手环加入了团队PK机制,同时加入抢红包等玩法等,而这样的玩法也非常具有腾讯特色。根据产品页面介绍,PacewearS8手环搭载一块0.49英寸PMOLED屏,采用光电式心率传感器,续航达到21天。同时在功能上,PacewearS8支持运动记步、心率监测、减脂模式、信息提醒、心率监控、睡眠监测等功能。另外,PacewearS8手环还拥有IP6

ECB(电子密本方式)其实非常简单,就是将数据按照8/16节一段进行加密或解密得到一段8/16个字节的密文或者明文,最后一段不足8/16个字节,按照需求补足8/16个字节进行计算,之后按照顺序将计算所得的数据连在一起即可,各段数据之间互不影响。

一句话:价值不大。如果你有能力在城市置业,答案将更极端:没价值。且听我慢慢讲来。以十年为期,中国城乡差别在十年之后,是更大还是更小,决定了十年以后,农村房子的价值的大小。最近,成都、长沙、郑州和无锡等城市鼓励人才落户,甚至“租售同权”的新闻迭出。这无疑将导致,城市尤其一二线和经济发达城市,对周边区域的虹吸将加速加剧,这对乡村,即使城乡结合部意味着什么,可想而知。任何国家,城市化到一定阶段之后,各城市之间就会展开对人才、资金和产业的竞争,只有流入更多的人才和资金,才会确保城市的未来。哪怕从功利角度来看,更多的人和资金将带来更高的GDP,会抬高主政官员的政绩。所以,中国除了北京和上海等极少数城市外

优点:

1.简单,有利于并行计算,误差不会被传送

缺点:

1.不能隐藏明文的模式

2.可能对明文进行主动攻击

2)CBC(Cipher Block Chaining)/密文分组链接方式

CBC(密文分组链接方式)的实现机制使加密的各段数据之间有了联系。其实现的机理如下:

加密步骤如下:

1)首先将数据按照8/16个字节一组进行分组得到D1D2......Dn(若数据不是8的整数倍,用指定的PADDING数据补位)

2)第一组数据D1与初始化向量I异或后的结果进行加密得到第一组密文C1

3)第二组数据D2与第一组的加密结果C1异或以后的结果进行加密,得到第二组密文C2

4)之后的数据以此类推,得到Cn

5)按顺序连为C1C2C3......Cn即为加密结果。

解密是加密的逆过程,步骤如下:

1)首先将数据按照8/16个字节一组进行分组得到C1C2C3......Cn

2)将第一组数据进行解密后与初始化向量I进行异或得到第一组明文D1(注意:一定是先解密再异或)

3)将第二组数据C2进行解密后与第一组密文数据进行异或得到第二组数据D2

4)之后依此类推,得到Dn

5)按顺序连为D1D2D3......Dn即为解密结果。

这里注意一点,解密的结果并不一定是我们原来的加密数据,可能还含有你补得位,一定要把补位去掉才是你的原来的数据。

优点:

1. 不容易主动攻击,安全性好于ECB,适合传输长度长的报文,是SSL、IPSec的标准

缺点:

1. 发送方和接收方都需要知道初始化向量 IV

2.加密过程是串行的,无法被并行化(在解密时,从两个邻接的密文块中即可得到一个平文块。因此,解密过程可以被并行化)

3.误差传递

3)Cipher Feedback (CFB)/密文反馈模式

密文反馈(CFB,Cipher feedback)模式类似于CBC,可以将块密码变为自同步的流密码;工作过程亦非常相似,CFB的解密过程几乎就是颠倒的CBC的加密过程:

需要使用一个与块的大小相同的移位寄存器,并用IV将寄存器初始化。然后,将寄存器内容使用块密码加密,然后将结果的最高x位与平文的x进行异或,以产生密文的x位。下一步将生成的x位密文移入寄存器中,并对下面的x位平文重复这一过程。解密过程与加密过程相似,以IV开始,对寄存器加密,将结果的高x与密文异或,产生x位平文,再将密文的下面x位移入寄存器。

与CBC相似,平文的改变会影响接下来所有的密文,因此加密过程不能并行化;而同样的,与CBC类似,解密过程是可以并行化的。

优点:

1.隐藏了明文模式

2.分组密码转化为流模式

3.可以及时加密传送小于分组的数据

缺点:

1.不利于并行计算

2.误差传送:一个明文单元损坏影响多个单元

3.唯一的IV

4)Output Feedback (OFB)/输出反馈模式

输出反馈模式(Output feedback, OFB)可以将块密码变成同步的流密码。它产生密钥流的块,然后将其与平文块进行异或,得到密文。与其它流密码一样,密文中一个位的翻转会使平文中同样位置的位也产生翻转。这种特性使得许多错误校正码,例如奇偶校验位,即使在加密前计算而在加密后进行校验也可以得出正确结果。

每个使用OFB的输出块与其前面所有的输出块相关,因此不能并行化处理。然而,由于平文和密文只在最终的异或过程中使用,因此可以事先对IV进行加密,最后并行的将平文或密文进行并行的异或处理。

可以利用输入全0的CBC模式产生OFB模式的密钥流。这种方法十分实用,因为可以利用快速的CBC硬件实现来加速OFB模式的加密过程。

优点:

1.隐藏了明文模式

2.分组密码转化为流模式

3.可以及时加密传送小于分组的数据

缺点:

1.不利于并行计算

2.对明文的主动攻击是可能的

3.误差传送:一个明文单元损坏影响多个单元

扩展阅读,根据您访问的内容系统为您准备了以下内容,希望对您有帮助。

Java实现AES256位对称加密算法要替换什么包才能实现

需要下载对应版本的Java Cryptography Extension (JCE),替换JDK安装目录\jre\lib\security下的local_policy.jar和US_export_policy.jar,如果独立JRE的话也是覆盖相同路径的文件。

JDK8对应的JCE在 http://www.oracle.com/technetwork/java/javase/downloads/jce8-download-2133166.html

可以参考我的文章 http://boytnt.blog.51cto.com/966121/1860309

Java中RSA的方式如何实现非对称加密的示例

代码如下,需要依赖一个jar包commons-codec-1.9.jar,用于Base64转换,请自行下载。

import org.apache.commons.codec.binary.Base64;

import javax.crypto.BadPaddingException;

import javax.crypto.Cipher;

import javax.crypto.IllegalBlockSizeException;

import java.io.ByteArrayOutputStream;

import java.io.UnsupportedEncodingException;

import java.security.*;

import java.security.interfaces.RSAPrivateKey;

import java.security.interfaces.RSAPublicKey;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

public class RSAUtils {

    // 加密方式

    public static final String ALGORITHM = "RSA";

    // 签名算法

    private static final String SIGNATURE_ALGORITHM = "SHA1WithRSA";

    // 创建密钥对初始长度

    private static final int KEY_SIZE = 512;

    // 字符编码格式

    private static final String CHARSET = "UTF-8";

    // RSA最大加密明文大小

    private static final int MAX_ENCRYPT_BLOCK = 117;

    // RSA最大解密密文大小

    private static final int MAX_DECRYPT_BLOCK = 128;

    private KeyFactory keyFactory;

    public RSAUtils() throws NoSuchAlgorithmException {

        keyFactory = KeyFactory.getInstance(ALGORITHM);

    }

    /**

     * 私钥加密

     *

     * @param content    待加密字符串

     * @param privateKey 私钥

     * @return 加密后字符串(BASE64编码)

     */

    public String encryptByPrivateKey(String content, String privateKey) throws Exception {

        String result;

        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {

            byte[] keyBytes = new Base64().decode(privateKey);

            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

            PrivateKey pKey = keyFactory.generatePrivate(pkcs8KeySpec);

            Cipher cipher = Cipher.getInstance(ALGORITHM);

            cipher.init(Cipher.ENCRYPT_MODE, pKey);

            byte[] data = content.getBytes(CHARSET);

            write2Stream(cipher, data, out);

            byte[] resultBytes = out.toByteArray();

            result = Base64.encodeBase64String(resultBytes);

        } catch (Exception e) {

            throw new Exception(e);

        }

        return result;

    }

    /**

     * 公钥解密

     *

     * @param content   已加密字符串(BASE64加密)

     * @param publicKey 公钥

     * @return

     */

    public String decryptByPublicKey(String content, String publicKey) throws Exception {

        String result = "";

        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {

            byte[] keyBytes = new Base64().decode(publicKey);

            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);

            PublicKey pKey = keyFactory.generatePublic(x509KeySpec);

            Cipher cipher = Cipher.getInstance(ALGORITHM);

            cipher.init(Cipher.DECRYPT_MODE, pKey);

            byte[] data = Base64.decodeBase64(content);

            write2Stream(cipher, data, out);

            byte[] resultBytes = out.toByteArray();

            result = new String(resultBytes);

        } catch (Exception e) {

            throw new Exception(e);

        }

        return result;

    }

    /**

     * 公钥加密

     *

     * @param content   待加密字符串

     * @param publicKey 公钥

     * @return 加密后字符串(BASE64编码)

     */

    public String encryptByPublicKey(String content, String publicKey) throws Exception {

        String result = "";

        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {

            byte[] keyBytes = new Base64().decode(publicKey);

            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);

            PublicKey pKey = keyFactory.generatePublic(x509KeySpec);

            Cipher cipher = Cipher.getInstance(ALGORITHM);

            cipher.init(Cipher.ENCRYPT_MODE, pKey);

            byte[] data = content.getBytes(CHARSET);

            write2Stream(cipher,

                    data, out);

            byte[] resultBytes = out.toByteArray();

            result = Base64.encodeBase64String(resultBytes);

        } catch (Exception e) {

            throw new Exception(e);

        }

        return result;

    }

    /**

     * 私钥解密

     *

     * @param content    已加密字符串

     * @param privateKey 私钥

     * @return 解密后字符串

     */

    public String decryptByPrivateKey(String content, String privateKey) throws Exception {

        String result = "";

        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {

            byte[] keyBytes = new Base64().decode(privateKey);

            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

            PrivateKey pKey = keyFactory.generatePrivate(pkcs8KeySpec);

            Cipher cipher = Cipher.getInstance(ALGORITHM);

            cipher.init(Cipher.DECRYPT_MODE, pKey);

            byte[] data = Base64.decodeBase64(content);

            write2Stream(cipher, data, out);

            byte[] resultBytes = out.toByteArray();

            result = new String(resultBytes);

        } catch (Exception e) {

            throw new Exception(e);

        }

        return result;

    }

    private static void write2Stream(Cipher cipher, byte[] data, ByteArrayOutputStream out) throws

            BadPaddingException, IllegalBlockSizeException {

        int dataLen = data.length;

        int offSet = 0;

        byte[] cache;

        int i = 0;

        // 对数据分段解密

        while (dataLen - offSet > 0) {

            if (dataLen - offSet > MAX_DECRYPT_BLOCK) {

                cache = cipher.doFinal(data, offSet, MAX_DECRYPT_BLOCK);

            } else {

                cache = cipher.doFinal(data, offSet, dataLen - offSet);

            }

            out.write(cache, 0, cache.length);

            i++;

            offSet = i * MAX_DECRYPT_BLOCK;

        }

    }

    /**

     * 用私钥对信息生成数字签名

     *

     * @param data       已加密数据

     * @param privateKey 私钥(BASE64编码)

     * @return sign

     */

    public String sign(String data, String privateKey) throws Exception {

        String result = "";

        try {

            byte[] keyBytes = new Base64().decode(privateKey);

            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

            PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);

            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);

            signature.initSign(privateK);

            signature.update(parse2HexStr(data).getBytes(CHARSET));

            result = new Base64().encodeToString(signature.sign());

        } catch (Exception e) {

            throw new Exception(e);

        }

        return result;

    }

    /**

     * 校验数字签名

     *

     * @param data      已加密数据

     * @param publicKey 公钥(BASE64编码)

     * @param sign      数字签名

     * @return

     * @throws Exception

     */

    public boolean verify(String data, String publicKey, String sign) throws Exception {

        boolean result;

        try {

            byte[] keyBytes = new Base64().decode(publicKey);

            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

            PublicKey publicK = keyFactory.generatePublic(keySpec);

            Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);

            signature.initVerify(publicK);

            signature.update(parse2HexStr(data).getBytes(CHARSET));

            result = signature.verify(new Base64().decode(sign));

        } catch (Exception e) {

            throw new Exception(e);

        }

        return result;

    }

    /**

     * 将二进制转换成16进制

     *

     * @param data

     * @return

     */

    public static String parse2HexStr(String data) throws Exception {

        String result = "";

        try {

            byte[] buf = data.getBytes(CHARSET);

            StringBuffer sb = new StringBuffer();

            for (int i = 0; i < buf.length; i++) {

                String hex = Integer.toHexString(buf[i] & 0xFF);

                if (hex.length() == 1) {

                    hex = '0' + hex;

                }

                sb.append(hex.toUpperCase());

            }

            result = sb.toString();

        } catch (UnsupportedEncodingException e) {

            throw new Exception(e);

        }

        return result;

    }

    /**

     * 生成公钥与私钥

     */

    public static void createKey() throws Exception {

        try {

            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(ALGORITHM);

            keyPairGenerator.initialize(KEY_SIZE);

            KeyPair keyPair = keyPairGenerator.generateKeyPair();

            RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();

            RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();

            String publicKey = Base64.encodeBase64String(rsaPublicKey.getEncoded());

            String privateKey = Base64.encodeBase64String(rsaPrivateKey.getEncoded());

            System.out.println("publicKey=" + publicKey + "\nprivateKey=" + privateKey);

        } catch (NoSuchAlgorithmException e) {

            throw new Exception(e);

        }

    }

    public static void main(String[] args) throws Exception {

        String PRIVATE_KEY = "MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBAKeYGXH6Vz+m+KuL11RDRaNdHB4YQeZgqpJGPRSwBelgvEoHu2/fNs1bmgfJhI8lhr/o/Hy8EFB/I/DDyLcCcU4bCLtxpki8edC+KJR2WvyYfnVmWEe/3q2jSVKRf81868q9Cd3MMfrQPMsY4x0TQ0GtOf/nMSMbAltV2W8J86IfAgMBAAECgYEApYu4lr2SMW3ddJZNvQ42W4g9nfyYG9igpJx8+VJmhIDpfLbmjzsOBwvUupx0NHH9CNQ7k3qxItJzzf+W5C+lesEOAqdO5nahRZsL8BIDoxTEn2j+1GXkzQw3vqPY50xqRnZsoP5TyNNsOM7KYaOoz4VFMdVIFwoT3OKM5z7mxgECQQD51r17WZDSa/kucaH7gCOePxJPS6Ust0eVd5tBOMpFzD/VtziogSIWyhGKkLH0SyTJEe91CCpdpxufLSZgIiN5AkEAq7ojtvU4twak1N1/1qX+t8f5wD8i/8GU702PeCwkGI5ymrARq+W2yCuvU1bouXBhjKHV4KhafKYixdHUMg00VwJAYVUjpLaUESY3gbyLWqvlNHVl8LaLtwwAO17JgXNaei7Ef8JNtHf6i95VTyJn8cCEqEDwhSuVNb8wp6azWKh0IQJBAJHrcT2d0bt0IcvfCynRk0eG3WnGPG8mhu9w8GAk4ecb47YdtmZio5YjyK8AQnCQVdOyEJL9eyY/5XxCeBSvs7ECQQCKQ2f5HLDkkHvc6rlaHCJmqNRCS+CxhoaiaSPYLAac7WXmb614ACLECc86C/nkefTq0SNpUDVbGxVpJi9/FOUf";

        String PUBLIC_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCnmBlx+lc/pviri9dUQ0WjXRweGEHmYKqSRj0UsAXpYLxKB7tv3zbNW5oHyYSPJYa/6Px8vBBQfyPww8i3AnFOGwi7caZIvHnQviiUdlr8mH51ZlhHv96to0lSkX/NfOvKvQndzDH60DzLGOMdE0NBrTn/5zEjGwJbVdlvCfOiHwIDAQAB";

        RSAUtils rsaUtil = new RSAUtils();

        String encryptByPublicKey = rsaUtil.encryptByPublicKey("你好!", PUBLIC_KEY);

        System.out.println(encryptByPublicKey);

        String decryptByPrivateKey = rsaUtil.decryptByPrivateKey(encryptByPublicKey, PRIVATE_KEY);

        System.out.println(decryptByPrivateKey);

        String encryptByPrivateKey = rsaUtil.encryptByPrivateKey("你好!", PRIVATE_KEY);

        System.out.println(encryptByPrivateKey);

        String decryptByPublicKey = rsaUtil.decryptByPublicKey(encryptByPrivateKey, PUBLIC_KEY);

        System.out.println(decryptByPublicKey);

        String sign = rsaUtil.sign("1234", PRIVATE_KEY);

        System.out.println("sign:" + sign);

        System.out.println(rsaUtil.verify("1234", PUBLIC_KEY, sign));

    }

}

java加密的几种方式

基本的单向加密算法: 

  • BASE64 严格地说,属于编码格式,而非加密算法

  • MD5(Message Digest algorithm 5,信息摘要算法)

  • SHA(Secure Hash Algorithm,安全散列算法)

  • HMAC(Hash Message Authentication Code,散列消息鉴别码)

复杂的对称加密(DES、PBE)、非对称加密算法: 

  • DES(Data Encryption Standard,数据加密算法)

  • PBE(Password-based encryption,基于密码验证)

  • RSA(算法的名字以发明者的名字命名:Ron Rivest, AdiShamir 和Leonard Adleman)

  • DH(Diffie-Hellman算法,密钥一致协议)

  • DSA(Digital Signature Algorithm,数字签名)

  • ECC(Elliptic Curves Cryptography,椭圆曲线密码编码学)

代码参考:

  • /** 

  • * BASE64加密 

  • *  

  • * @param key 

  • * @return 

  • * @throws Exception 

  • */  

  • public static String encryptBASE64(byte[] key) throws Exception {  

  • return (new BASE64Encoder()).encodeBuffer(key);  

  • }  

  • /** 

  • * MD5加密 

  • *  

  • * @param data 

  • * @return 

  • * @throws Exception 

  • */  

  • public static byte[] encryptMD5(byte[] data) throws Exception {  

  • MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);  

  • md5.update(data);  

  • return md5.digest();  

  • }  

  • /** 

  • * SHA加密 

  • *  

  • * @param data 

  • * @return 

  • * @throws Exception 

  • */  

  • public static byte[] encryptSHA(byte[] data) throws Exception {  

  • MessageDigest sha = MessageDigest.getInstance(KEY_SHA);  

  • sha.update(data);  

  • return sha.digest();  

  • }  

  • }  

  • /** 

  • * 初始化HMAC密钥 

  • *  

  • * @return 

  • * @throws Exception 

  • */  

  • public static String initMacKey() throws Exception {  

  • KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);  

  • SecretKey secretKey = keyGenerator.generateKey();  

  • return encryptBASE64(secretKey.getEncoded());  

  • }  

  • /** 

  • * HMAC加密 

  • *  

  • * @param data 

  • * @param key 

  • * @return 

  • * @throws Exception 

  • */  

  • public static byte[] encryptHMAC(byte[] data, String key) throws Exception {  

  • SecretKey secretKey = new SecretKeySpec(decryptBASE64(key), KEY_MAC);  

  • Mac mac = Mac.getInstance(secretKey.getAlgorithm());  

  • mac.init(secretKey);  

  • return mac.doFinal(data);  

  • }  

java des 默认采用什么加密模式

JAVA和.NET的系统类库里都有封装DES对称加密的实现方式,但是对外暴露的接口却各不相同,甚至有时会让自己难以解决其中的问题,比如JAVA加密后的结果在.NET中解密不出来等,由于最近项目有跨JAVA和.NET的加解密,经过我的分析调试,终于让它们可以互相加密解密了。

DES加密

DES是一种对称加密(Data Encryption Standard)算法,以前我写过一篇文章:.NET中加密解密相关知识,有过简单描述。

DES算法一般有两个关键点,第一个是加密算法,第二个是数据补位。

加密算法常见的有ECB模式和CBC模式:

本回答被提问者采纳

java工作原理

java是通过java虚拟机进行编译和运行的。 

Java虚拟机是编译和运行Java程序等的各种命令及其运行环境的总称。Java源程序在编译之后生成后缀为“.class”的文件,该文件以字节码(bytecode)的方式进行编码。这种字节码实际上是一种伪代码,它包含各种指令,这些指令基本上是与平台无关的指令。Java虚拟机在字节码文件(及编译生成的后缀为.class的文件)的基础上解释这些字节码,及将这些字节码转行成为本地计算机的机器代码,并交给本地计算机执行。

   

这样,字节码实际上是一种与平台无关的伪代码,通过Java命令变成在各种平台上的机器代码。这些伪代码最终是在本地计算机平台上运行的,但Java程序就好像是在这些Java命令的基础上运行的,因此这些Java命令的集合好像是采用软件技术实现的一种虚拟计算机。这就是Java虚拟机名称的由来。

Java虚拟机执行字节码的过程由一个循环组成,它不停地家族程序,进行合法性和安全性检测,以及解释执行,直到程序执行完毕(包括异常退出)。Java虚拟机首先从后缀为“.class”文件中加载字节码到内存中;接着在内存中检测代码的合法性和安全性,例如,检测Java程序用到的数组是否越界、所要访问的内存地址是否合法等;然后解释执行通过检测的代码,及根据不同的计算机平台将字节码转化成为相应的计算机平台的机器代码,再交给相应的计算机执行。如果加载的代码不能通过合法性和安全性检测,则Java虚拟机执行相应的异常处理程序。Java虚拟机不停地执行这个过程直到程序执行结束。虽然Java语言含有编译命令,但是Java虚拟机对字节码的解释执行机制决定了Java语言是一种解释执行的语言。


  • 本文相关:
  • java对称加密算法des实例详解
  • java对称加密算法pbe定义与用法实例分析
  • java 非对称加密算法rsa实现详解
  • java结合keytool如何实现非对称加密与解密详解
  • java实现的对称加密算法3des定义与用法示例
  • java编程实现非对称加密的方法详解
  • java 对称加密几种算法分别实现
  • java中aes对称加密和解密过程
  • spring-boot原理及spring-boot-starter实例和代码
  • 数组重排序(如何将所有奇数都放在所有偶数前面)的深入分析
  • spring boot项目如何同时支持http和https协议的实现
  • java web实现自动登录功能
  • java实现批量修改txt文件名称的方法示例
  • java中http连接的两种方式(小结)
  • java calendar类使用总结及使用实例
  • java分页工具类及其使用(示例分享)
  • java实现的质因数分解操作示例【基于递归算法】
  • java判读数组中是否有重复值的示例
  • Java实现AES256位对称加密算法要替换什么包才能实现
  • Java中RSA的方式如何实现非对称加密的示例
  • java加密的几种方式
  • java des 默认采用什么加密模式
  • java工作原理
  • JAVA和.NET使用DES对称加密的区别
  • 谁能帮我解释一下这段Java加密代码的原理,自己分析了一下不是很懂
  • 非对称加密和对称加密的区别
  • Java和.NET使用DES对称加密的区别
  • java虚拟机工作原理?
  • 免责声明 - 关于我们 - 联系我们 - 广告联系 - 友情链接 - 帮助中心 - 频道导航
    Copyright © 2017 www.zgxue.com All Rights Reserved