精华内容
下载资源
问答
  • 因为加密算法用比较多,这里就常用的加密算法(如AES、DES、MD5、SHA1、SHA256、SHA512、RSA等加密算法)基于基本用法结合实际应用做一个总结笔记。因为加密算法具体方法类都在jdk中有封装好,关于里面详细...

    前言:

    因为加密算法用的比较多,这里就常用的加密算法(如AES、DES、MD5、SHA1、SHA256、SHA512、RSA等加密算法)基于基本用法结合实际应用做一个总结笔记。因为加密算法的具体方法与类都在jdk中有封装好,关于里面的详细逻辑会在后面的章节里写出来,这里仅以应用为主。

    一、对称加密:双方使用的同一个密钥,既可以加密又可以解密,这种加密方法称为对称加密,也称为单密钥加密。

    优点:速度快,对称性加密通常在消息发送方需要加密大量数据时使用,算法公开、计算量小、加密速度快、加密效率高。

    缺点:在数据传送前,发送方和接收方必须商定好秘钥,然后 使双方都能保存好秘钥。其次如果一方的秘钥被泄露,那么加密信息也就不安全了。另外,每对用户每次使用对称加密算法时,都需要使用其他人不知道的唯一秘钥,这会使得收、发双方所拥有的钥匙数量巨大,密钥管理成为双方的负担。

    1.1,  对称加密之AES加密

    	//AES加密
    	public static byte[] encrypt(String content, String password) {  
            try {             
                    KeyGenerator kgen = KeyGenerator.getInstance("AES");  //(对称)密钥生成器
                    kgen.init(128, new SecureRandom(password.getBytes()));  //显式地初始化 KeyGenerator(通过调用 init 方法)
                    SecretKey secretKey = kgen.generateKey();  
                    byte[] enCodeFormat = secretKey.getEncoded();  
                    SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");  
                    Cipher cipher = Cipher.getInstance("AES");// 创建密码器  
                    byte[] byteContent = content.getBytes("utf-8");  
                    cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化  
                    byte[] result = cipher.doFinal(byteContent);  
                    return result; // 加密  
            } catch (Exception e) {  
            } 
            return null;  
    	}  
    1.2,  对称加密之AES解密

    	//AES解密
    	public static byte[] decrypt(byte[] content, String password) {  
            try {  
                     KeyGenerator kgen = KeyGenerator.getInstance("AES");  
                     kgen.init(128, new SecureRandom(password.getBytes()));  
                     SecretKey secretKey = kgen.generateKey();  
                     byte[] enCodeFormat = secretKey.getEncoded();  
                     SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");              
                     Cipher cipher = Cipher.getInstance("AES");// 创建密码器  
                    cipher.init(Cipher.DECRYPT_MODE, key);// 初始化  
                    byte[] result = cipher.doFinal(content);  
                    return result; // 加密  
            } catch (Exception e) {
                    e.printStackTrace();  
            } 
            return null;  
    	}  
    1.3,测试结果
    测试结果








































    1.4,应用
    该AES适合加密字符串,当然也可以加密文件如音视频媒体文件、可执行文件等,但这种加密对于大的文件比较耗时,下面贴出自己平常使用中的AES加密算法,这个是另外一种AES加密,但这种对于加密字符串有缺点,
    • 密钥必须是16位的
    • 待加密内容的长度必须是16的倍数,如果不是16的倍数,就会出异常
    这里是代码:

    	//手机常用路径记录/sdcard/DCIM/Camera/VID_20140217_144346.mp4
    	// 原文件
    	private static final String filePath = "F:/惊鸿一面mv.mp4";
    	// 加密后的文件
    	private static final String outPath = "F:/惊鸿一面mvAES加密.mp4";
    	// 加密再解密后的文件
    	private static final String inPath = "F:/惊鸿一面mvAES解密.mp4";	
    	//AES加密文件算法
    	private void encrypt() throws Exception{
    		FileInputStream fis = new FileInputStream(filePath);
    		FileOutputStream fos = new FileOutputStream(outPath);
    		SecretKeySpec sks = new SecretKeySpec("MyDifficultPassw".getBytes(),// Length is 16 byte
    				"AES");
    		Cipher cipher = Cipher.getInstance("AES");
    		cipher.init(Cipher.ENCRYPT_MODE, sks);
    		CipherOutputStream cos = new CipherOutputStream(fos, cipher);
    		int b;
    		byte[] d = new byte[8];
    		while ((b = fis.read(d)) != -1) {
    			cos.write(d, 0, b);
    		}
    		// Flush and close streams.
    		cos.flush();
    		cos.close();
    		fis.close();
    	}
    	//AES解密文件算法
    	private void decrypt() throws Exception,{
    		FileInputStream fis = new FileInputStream(outPath);
    		FileOutputStream fos = new FileOutputStream(inPath);
    		SecretKeySpec sks = new SecretKeySpec("MyDifficultPassw".getBytes(),
    				"AES");
    		Cipher cipher = Cipher.getInstance("AES");
    		cipher.init(Cipher.DECRYPT_MODE, sks);
    		CipherInputStream cis = new CipherInputStream(fis, cipher);
    		int b;
    		byte[] d = new byte[8];
    		while ((b = cis.read(d)) != -1) {
    			fos.write(d, 0, b);
    		}
    		fos.flush();
    		fos.close();
    		cis.close();
    	}
    2.1,对称加密之DES加密
    des对称加密算法现不推荐使用,因为des使用56位密钥,以现代计算能力,24小时内即可被破解,另外密码key须是8的整数倍,下面还是将算法列举出来

    	//des加密算法
    	public static byte[] encrypt2(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;  
    	}  
    2.2,对称加密之DES解密
    	//des解密算法
    	private static byte[] decrypt2(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);  
    	}  
    2.3,测试结果
    测试结果

























    3.1,对称加密之SHA加密
    	/**
         * SHA加密
         *
         * @param strSrc
         *            明文
         * @return 加密之后的密文
         */
        public static String shaEncrypt(String strSrc) {
            MessageDigest md = null;
            String strDes = null;
            byte[] bt = strSrc.getBytes();
            try {
                md = MessageDigest.getInstance("SHA-1");// 将此换成SHA-1、SHA-512、SHA-384等参数
                md.update(bt);
                strDes = bytes2Hex(md.digest()); // to HexString
            } catch (NoSuchAlgorithmException e) {
                return null;
            }
            return strDes;
        }
    
    
        /**
         * byte数组转换为16进制字符串
         *
         * @param bts
         *            数据源
         * @return 16进制字符串
         */
        public static String bytes2Hex(byte[] bts) {
            String des = "";
            String tmp = null;
            for (int i = 0; i < bts.length; i++) {
                tmp = (Integer.toHexString(bts[i] & 0xFF));
                if (tmp.length() == 1) {
                    des += "0";
                }
                des += tmp;
            }
            return des;
        }
    SHA系列的算法属于不可逆的单向哈希算法,主要应用还是验证如数字签名等。
    3.2,测试结果
    测试结果





























    二、非对称加密:一对密钥由公钥和私钥组成(可以使用很多对密钥)。私钥解密公钥加密数据,公钥解密私钥加密数据(私钥公钥可以互相加密解密)。

    私钥只能由一方保管,不能外泄。公钥可以交给任何请求方。


    1.1,对称加密算法之MD5加解密
    MD5属于hash算法,严格意义上并不算加密算法,但是这里还是列举一下其用法:
         /*** 
         * MD5加码 生成32位md5码 
         */  
        public static String string2MD5(String inStr){  
            MessageDigest md5 = null;  
            try{  
                md5 = MessageDigest.getInstance("MD5");  
            }catch (Exception e){  
                System.out.println(e.toString());  
                e.printStackTrace();  
                return "";  
            }  
            char[] charArray = inStr.toCharArray();  
            byte[] byteArray = new byte[charArray.length];  
      
            for (int i = 0; i < charArray.length; i++)  
                byteArray[i] = (byte) charArray[i];  
            byte[] md5Bytes = md5.digest(byteArray);  
            StringBuffer hexValue = new StringBuffer();  
            for (int i = 0; i < md5Bytes.length; i++){  
                int val = ((int) md5Bytes[i]) & 0xff;  
                if (val < 16)  
                    hexValue.append("0");  
                hexValue.append(Integer.toHexString(val));  
            }  
            return hexValue.toString();  
      
        }  
      
        /** 
         * 加密解密算法 执行一次加密,两次解密 
         */   
        public static String convertMD5(String inStr){  
      
            char[] a = inStr.toCharArray();  
            for (int i = 0; i < a.length; i++){  
                a[i] = (char) (a[i] ^ 't');  
            }  
            String s = new String(a);  
            return s;  
      
        }  
    1.2,测试结果
    测试结果


































    2.1,RSA加解密算法
         public static void generateKey() {  
            try {  
                KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");  
                kpg.initialize(1024);  
                KeyPair kp = kpg.genKeyPair();  
                PublicKey pbkey = kp.getPublic();  
                PrivateKey prkey = kp.getPrivate();  
                // 保存公钥  
                FileOutputStream f1 = new FileOutputStream("pubkey.dat");  
                ObjectOutputStream b1 = new ObjectOutputStream(f1);  
                b1.writeObject(pbkey);  
                // 保存私钥  
                FileOutputStream f2 = new FileOutputStream("privatekey.dat");  
                ObjectOutputStream b2 = new ObjectOutputStream(f2);  
                b2.writeObject(prkey);  
            } catch (Exception e) {  
            }  
        }  
        public static void encrypt() throws Exception {  
            String s = "helloworld";  
            // 获取公钥及参数e,n  
            FileInputStream f = new FileInputStream("pubkey.dat");  
            ObjectInputStream b = new ObjectInputStream(f);  
            RSAPublicKey pbk = (RSAPublicKey) b.readObject();  
            BigInteger e = pbk.getPublicExponent();  
            BigInteger n = pbk.getModulus();  
            System.out.println("e= " + e);  
            System.out.println("n= " + n);  
            // 获取明文m  
            byte ptext[] = s.getBytes("UTF-8");  
            BigInteger m = new BigInteger(ptext);  
            // 计算密文c  
            BigInteger c = m.modPow(e, n);  
            System.out.println("c= " + c);  
            // 保存密文  
            String cs = c.toString();  
            BufferedWriter out =  
                new BufferedWriter(  
                    new OutputStreamWriter(new FileOutputStream("encrypt.dat")));  
            out.write(cs, 0, cs.length());  
            out.close();  
        }  
        public static void decrypt() throws Exception {  
            // 读取密文  
            BufferedReader in =  
                new BufferedReader(  
                    new InputStreamReader(new FileInputStream("encrypt.dat")));  
            String ctext = in.readLine();  
            BigInteger c = new BigInteger(ctext);  
            // 读取私钥  
            FileInputStream f = new FileInputStream("privatekey.dat");  
            ObjectInputStream b = new ObjectInputStream(f);  
            RSAPrivateKey prk = (RSAPrivateKey) b.readObject();  
            BigInteger d = prk.getPrivateExponent();  
            // 获取私钥参数及解密  
            BigInteger n = prk.getModulus();  
            System.out.println("d= " + d);  
            System.out.println("n= " + n);  
            BigInteger m = c.modPow(d, n);  
            // 显示解密结果  
            System.out.println("m= " + m);  
            byte[] mt = m.toByteArray();  
            String s = new String(mt,"UTF-8");
            System.out.println("\n解密后的明文:" + s);
        }  
    	这里只是简单地利用了公钥加密,私钥解密,较为全面的还有私钥加密,公钥解密,更为全面的请参考Central-Perk的博客
    2.2,测试结果
    测试结果




























    参考博客:http://blog.csdn.net/centralperk/article/details/8538697
        http://blog.csdn.net/houzuoxin/article/details/39054895
        
    展开全文
  • 1.数字签名 对摘要信息进行加密,这样做就能保证原文公钥的一致性。 2.保密通讯(SSLHTTPS) 实际上是使用非对称加密传递对称加密的密钥。 ...

    1.数字签名


     

    对摘要信息进行加密,这样做就能保证原文与公钥的一致性。

     

     

    2.保密通讯(SSL与HTTPS)


     

    实际上是使用非对称加密传递对称加密的密钥。

     

    转载于:https://my.oschina.net/chunquedong/blog/54348

    展开全文
  • 非对称加密,其加密和解密密钥是不同,区分为公钥和私钥两部分,公钥通常用于加密消息,而私钥用于解密消息。RSA算法被认为是使用最广泛的非对称加密算法。RSA算法在计算过程中存在较多模幂运算,计算速度比对称...

    引言

    对称加密,加密密钥和解密密钥是同一密钥,表现为对称性。而非对称加密,其加密和解密密钥是不同的,区分为公钥和私钥两部分,公钥通常用于加密消息,而私钥用于解密消息。RSA算法被认为是使用最广泛的非对称加密算法。RSA算法在计算过程中存在较多模幂运算,计算速度比对称加密算法要慢很多,并不适用与对大量数据进行加密或加密操作,实际使用中一般用于加密或解密小数据片段,例如AES128密钥等(记住,网络传输中高吞吐量数据基本都是用对称加密,AES128)

    图解非对称加密

    如上电脑A向电脑B发送消息,使用非对称加密RSA算法过程:

    • 电脑B使用第三方工具生成密钥对,分别是公钥和私钥
    • 电脑B向电脑A先提供公钥,自己保留私钥,私钥无论在什么情况下都不能提供
    • 电脑A使用B提供的公钥,使用非对称加密RSA算法对明文加密得到密文
    • 电脑A向电脑B发送密文
    • 电脑B匹配自己的私钥,使用非对称加密RSA算法对密文进行解密,得到原文
    • 窃听者截获到电脑A发送的密文,哪怕通过途径获得电脑A存储的由电脑B提供的公钥,也无法解密,因为解密需要用到B的私钥

    非对称加密RSA算法填充方式

    做过AES128对称加密算法加密解密应用的,估计不少都遇到因填充方式不一致导致解密失败的问题。同理,RSA算法也有填充的概念,但是RSA算法的字节填充,目的并不是像对称加密算法那样用于解决分组对齐的问题,而是用于加强安全性。如果一段数据RSA加密结果总是确定的(同一公钥前提下),即特定的明文总是可以得到特定的密文,窃听者必然可以在密文中获得明文的一些统计信息,故RSA算法实际使用中一般会加入填充方案,往明文中注入随机性信息,例如时间或随机数等,常见的RSA填充方案有两种:RSAES-OAEP和RSAES-PKCS1-V1_5(后者是早期填充方案,新应用已不再使用),下面介绍下PKCS1-V1_5的填充方式,好让大家对RSA填充方案有个基本概念

    EM(填充后的明文)= 0x00(指示填充开始) || 0x02(指示算法,0x02标识公钥操作) || PS(填充随机字符串) || 0x00(指示填充结束) || M(未填充明文)

    mbedtls工具非对称加密RSA算法代码分析与应用

    RSA算法,密钥对生成参考路径mbedtls/programs/pkey/rsa_genkey.c

    /*
     *  Example RSA key generation program
     *
     *  Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
     *  SPDX-License-Identifier: Apache-2.0
     *
     *  Licensed under the Apache License, Version 2.0 (the "License"); you may
     *  not use this file except in compliance with the License.
     *  You may obtain a copy of the License at
     *
     *  http://www.apache.org/licenses/LICENSE-2.0
     *
     *  Unless required by applicable law or agreed to in writing, software
     *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
     *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     *  See the License for the specific language governing permissions and
     *  limitations under the License.
     *
     *  This file is part of mbed TLS (https://tls.mbed.org)
     */
    
    #if !defined(MBEDTLS_CONFIG_FILE)
    #include "mbedtls/config.h"
    #else
    #include MBEDTLS_CONFIG_FILE
    #endif
    
    #if defined(MBEDTLS_PLATFORM_C)
    #include "mbedtls/platform.h"
    #else
    #include <stdio.h>
    #include <stdlib.h>
    #define mbedtls_printf          printf
    #define MBEDTLS_EXIT_SUCCESS    EXIT_SUCCESS
    #define MBEDTLS_EXIT_FAILURE    EXIT_FAILURE
    #endif /* MBEDTLS_PLATFORM_C */
    
    #if defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_ENTROPY_C) && \
        defined(MBEDTLS_RSA_C) && defined(MBEDTLS_GENPRIME) && \
        defined(MBEDTLS_FS_IO) && defined(MBEDTLS_CTR_DRBG_C)
    #include "mbedtls/entropy.h"
    #include "mbedtls/ctr_drbg.h"
    #include "mbedtls/bignum.h"
    #include "mbedtls/x509.h"
    #include "mbedtls/rsa.h"
    
    #include <stdio.h>
    #include <string.h>
    #endif
    
    #define KEY_SIZE 2048
    #define EXPONENT 65537
    
    #if !defined(MBEDTLS_BIGNUM_C) || !defined(MBEDTLS_ENTROPY_C) ||   \
        !defined(MBEDTLS_RSA_C) || !defined(MBEDTLS_GENPRIME) ||      \
        !defined(MBEDTLS_FS_IO) || !defined(MBEDTLS_CTR_DRBG_C)
    int main( void )
    {
        mbedtls_printf("MBEDTLS_BIGNUM_C and/or MBEDTLS_ENTROPY_C and/or "
               "MBEDTLS_RSA_C and/or MBEDTLS_GENPRIME and/or "
               "MBEDTLS_FS_IO and/or MBEDTLS_CTR_DRBG_C not defined.\n");
        return( 0 );
    }
    #else
    int main( void )
    {
        int ret = 1;
        int exit_code = MBEDTLS_EXIT_FAILURE;
        mbedtls_rsa_context rsa;
        mbedtls_entropy_context entropy;
        mbedtls_ctr_drbg_context ctr_drbg;
        mbedtls_mpi N, P, Q, D, E, DP, DQ, QP;
        FILE *fpub  = NULL;
        FILE *fpriv = NULL;
        const char *pers = "rsa_genkey";
    
        mbedtls_ctr_drbg_init( &ctr_drbg );
        mbedtls_rsa_init( &rsa, MBEDTLS_RSA_PKCS_V15, 0 );
        mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P ); mbedtls_mpi_init( &Q );
        mbedtls_mpi_init( &D ); mbedtls_mpi_init( &E ); mbedtls_mpi_init( &DP );
        mbedtls_mpi_init( &DQ ); mbedtls_mpi_init( &QP );
    
        mbedtls_printf( "\n  . Seeding the random number generator..." );
        fflush( stdout );
    
        mbedtls_entropy_init( &entropy );
        if( ( ret = mbedtls_ctr_drbg_seed( &ctr_drbg, mbedtls_entropy_func, &entropy,
                                   (const unsigned char *) pers,
                                   strlen( pers ) ) ) != 0 )
        {
            mbedtls_printf( " failed\n  ! mbedtls_ctr_drbg_seed returned %d\n", ret );
            goto exit;
        }
    
        mbedtls_printf( " ok\n  . Generating the RSA key [ %d-bit ]...", KEY_SIZE );
        fflush( stdout );
    
        if( ( ret = mbedtls_rsa_gen_key( &rsa, mbedtls_ctr_drbg_random, &ctr_drbg, KEY_SIZE,
                                         EXPONENT ) ) != 0 )
        {
            mbedtls_printf( " failed\n  ! mbedtls_rsa_gen_key returned %d\n\n", ret );
            goto exit;
        }
    
        mbedtls_printf( " ok\n  . Exporting the public  key in rsa_pub.txt...." );
        fflush( stdout );
    
        if( ( ret = mbedtls_rsa_export    ( &rsa, &N, &P, &Q, &D, &E ) ) != 0 ||
            ( ret = mbedtls_rsa_export_crt( &rsa, &DP, &DQ, &QP ) )      != 0 )
        {
            mbedtls_printf( " failed\n  ! could not export RSA parameters\n\n" );
            goto exit;
        }
    
        if( ( fpub = fopen( "rsa_pub.txt", "wb+" ) ) == NULL )
        {
            mbedtls_printf( " failed\n  ! could not open rsa_pub.txt for writing\n\n" );
            goto exit;
        }
    
        if( ( ret = mbedtls_mpi_write_file( "N = ", &N, 16, fpub ) ) != 0 ||
            ( ret = mbedtls_mpi_write_file( "E = ", &E, 16, fpub ) ) != 0 )
        {
            mbedtls_printf( " failed\n  ! mbedtls_mpi_write_file returned %d\n\n", ret );
            goto exit;
        }
    
        mbedtls_printf( " ok\n  . Exporting the private key in rsa_priv.txt..." );
        fflush( stdout );
    
        if( ( fpriv = fopen( "rsa_priv.txt", "wb+" ) ) == NULL )
        {
            mbedtls_printf( " failed\n  ! could not open rsa_priv.txt for writing\n" );
            goto exit;
        }
    
        if( ( ret = mbedtls_mpi_write_file( "N = " , &N , 16, fpriv ) ) != 0 ||
            ( ret = mbedtls_mpi_write_file( "E = " , &E , 16, fpriv ) ) != 0 ||
            ( ret = mbedtls_mpi_write_file( "D = " , &D , 16, fpriv ) ) != 0 ||
            ( ret = mbedtls_mpi_write_file( "P = " , &P , 16, fpriv ) ) != 0 ||
            ( ret = mbedtls_mpi_write_file( "Q = " , &Q , 16, fpriv ) ) != 0 ||
            ( ret = mbedtls_mpi_write_file( "DP = ", &DP, 16, fpriv ) ) != 0 ||
            ( ret = mbedtls_mpi_write_file( "DQ = ", &DQ, 16, fpriv ) ) != 0 ||
            ( ret = mbedtls_mpi_write_file( "QP = ", &QP, 16, fpriv ) ) != 0 )
        {
            mbedtls_printf( " failed\n  ! mbedtls_mpi_write_file returned %d\n\n", ret );
            goto exit;
        }
    /*
        mbedtls_printf( " ok\n  . Generating the certificate..." );
    
        x509write_init_raw( &cert );
        x509write_add_pubkey( &cert, &rsa );
        x509write_add_subject( &cert, "CN='localhost'" );
        x509write_add_validity( &cert, "2007-09-06 17:00:32",
                                       "2010-09-06 17:00:32" );
        x509write_create_selfsign( &cert, &rsa );
        x509write_crtfile( &cert, "cert.der", X509_OUTPUT_DER );
        x509write_crtfile( &cert, "cert.pem", X509_OUTPUT_PEM );
        x509write_free_raw( &cert );
    */
        mbedtls_printf( " ok\n\n" );
    
        exit_code = MBEDTLS_EXIT_SUCCESS;
    
    exit:
    
        if( fpub  != NULL )
            fclose( fpub );
    
        if( fpriv != NULL )
            fclose( fpriv );
    
        mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P ); mbedtls_mpi_free( &Q );
        mbedtls_mpi_free( &D ); mbedtls_mpi_free( &E ); mbedtls_mpi_free( &DP );
        mbedtls_mpi_free( &DQ ); mbedtls_mpi_free( &QP );
        mbedtls_rsa_free( &rsa );
        mbedtls_ctr_drbg_free( &ctr_drbg );
        mbedtls_entropy_free( &entropy );
    
    #if defined(_WIN32)
        mbedtls_printf( "  Press Enter to exit this program.\n" );
        fflush( stdout ); getchar();
    #endif
    
        return( exit_code );
    }
    #endif /* MBEDTLS_BIGNUM_C && MBEDTLS_ENTROPY_C && MBEDTLS_RSA_C &&
              MBEDTLS_GENPRIME && MBEDTLS_FS_IO && MBEDTLS_CTR_DRBG_C */

    RSA算法,加密算法应用,参考路径mbedtls/programs/pkey/rsa_encrypt.c

    /*
     *  RSA simple data encryption program
     *
     *  Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
     *  SPDX-License-Identifier: Apache-2.0
     *
     *  Licensed under the Apache License, Version 2.0 (the "License"); you may
     *  not use this file except in compliance with the License.
     *  You may obtain a copy of the License at
     *
     *  http://www.apache.org/licenses/LICENSE-2.0
     *
     *  Unless required by applicable law or agreed to in writing, software
     *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
     *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     *  See the License for the specific language governing permissions and
     *  limitations under the License.
     *
     *  This file is part of mbed TLS (https://tls.mbed.org)
     */
    
    #if !defined(MBEDTLS_CONFIG_FILE)
    #include "mbedtls/config.h"
    #else
    #include MBEDTLS_CONFIG_FILE
    #endif
    
    #if defined(MBEDTLS_PLATFORM_C)
    #include "mbedtls/platform.h"
    #else
    #include <stdio.h>
    #include <stdlib.h>
    #define mbedtls_fprintf         fprintf
    #define mbedtls_printf          printf
    #define mbedtls_exit            exit
    #define MBEDTLS_EXIT_SUCCESS    EXIT_SUCCESS
    #define MBEDTLS_EXIT_FAILURE    EXIT_FAILURE
    #endif /* MBEDTLS_PLATFORM_C */
    
    #if defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_RSA_C) && \
        defined(MBEDTLS_ENTROPY_C) && defined(MBEDTLS_FS_IO) && \
        defined(MBEDTLS_CTR_DRBG_C)
    #include "mbedtls/rsa.h"
    #include "mbedtls/entropy.h"
    #include "mbedtls/ctr_drbg.h"
    
    #include <string.h>
    #endif
    
    #if !defined(MBEDTLS_BIGNUM_C) || !defined(MBEDTLS_RSA_C) ||  \
        !defined(MBEDTLS_ENTROPY_C) || !defined(MBEDTLS_FS_IO) || \
        !defined(MBEDTLS_CTR_DRBG_C)
    int main( void )
    {
        mbedtls_printf("MBEDTLS_BIGNUM_C and/or MBEDTLS_RSA_C and/or "
               "MBEDTLS_ENTROPY_C and/or MBEDTLS_FS_IO and/or "
               "MBEDTLS_CTR_DRBG_C not defined.\n");
        return( 0 );
    }
    #else
    int main( int argc, char *argv[] )
    {
        FILE *f;
        int ret = 1;
        int exit_code = MBEDTLS_EXIT_FAILURE;
        size_t i;
        mbedtls_rsa_context rsa;
        mbedtls_entropy_context entropy;
        mbedtls_ctr_drbg_context ctr_drbg;
        unsigned char input[1024];
        unsigned char buf[512];
        const char *pers = "rsa_encrypt";
        mbedtls_mpi N, E;
    
        if( argc != 2 )
        {
            mbedtls_printf( "usage: rsa_encrypt <string of max 100 characters>\n" );
    
    #if defined(_WIN32)
            mbedtls_printf( "\n" );
    #endif
    
            mbedtls_exit( exit_code );
        }
    
        mbedtls_printf( "\n  . Seeding the random number generator..." );
        fflush( stdout );
    
        mbedtls_mpi_init( &N ); mbedtls_mpi_init( &E );
        mbedtls_rsa_init( &rsa, MBEDTLS_RSA_PKCS_V15, 0 );
        mbedtls_ctr_drbg_init( &ctr_drbg );
        mbedtls_entropy_init( &entropy );
    
        ret = mbedtls_ctr_drbg_seed( &ctr_drbg, mbedtls_entropy_func,
                                     &entropy, (const unsigned char *) pers,
                                     strlen( pers ) );
        if( ret != 0 )
        {
            mbedtls_printf( " failed\n  ! mbedtls_ctr_drbg_seed returned %d\n",
                            ret );
            goto exit;
        }
    
        mbedtls_printf( "\n  . Reading public key from rsa_pub.txt" );
        fflush( stdout );
    
        if( ( f = fopen( "rsa_pub.txt", "rb" ) ) == NULL )
        {
            mbedtls_printf( " failed\n  ! Could not open rsa_pub.txt\n" \
                    "  ! Please run rsa_genkey first\n\n" );
            goto exit;
        }
    
        if( ( ret = mbedtls_mpi_read_file( &N, 16, f ) ) != 0 ||
            ( ret = mbedtls_mpi_read_file( &E, 16, f ) ) != 0 )
        {
            mbedtls_printf( " failed\n  ! mbedtls_mpi_read_file returned %d\n\n",
                            ret );
            fclose( f );
            goto exit;
        }
        fclose( f );
    
        if( ( ret = mbedtls_rsa_import( &rsa, &N, NULL, NULL, NULL, &E ) ) != 0 )
        {
            mbedtls_printf( " failed\n  ! mbedtls_rsa_import returned %d\n\n",
                            ret );
            goto exit;
        }
    
        if( strlen( argv[1] ) > 100 )
        {
            mbedtls_printf( " Input data larger than 100 characters.\n\n" );
            goto exit;
        }
    
        memcpy( input, argv[1], strlen( argv[1] ) );
    
        /*
         * Calculate the RSA encryption of the hash.
         */
        mbedtls_printf( "\n  . Generating the RSA encrypted value" );
        fflush( stdout );
    
        ret = mbedtls_rsa_pkcs1_encrypt( &rsa, mbedtls_ctr_drbg_random,
                                         &ctr_drbg, MBEDTLS_RSA_PUBLIC,
                                         strlen( argv[1] ), input, buf );
        if( ret != 0 )
        {
            mbedtls_printf( " failed\n  ! mbedtls_rsa_pkcs1_encrypt returned %d\n\n",
                            ret );
            goto exit;
        }
    
        /*
         * Write the signature into result-enc.txt
         */
        if( ( f = fopen( "result-enc.txt", "wb+" ) ) == NULL )
        {
            mbedtls_printf( " failed\n  ! Could not create %s\n\n", "result-enc.txt" );
            goto exit;
        }
    
        for( i = 0; i < rsa.len; i++ )
            mbedtls_fprintf( f, "%02X%s", buf[i],
                     ( i + 1 ) % 16 == 0 ? "\r\n" : " " );
    
        fclose( f );
    
        mbedtls_printf( "\n  . Done (created \"%s\")\n\n", "result-enc.txt" );
    
        exit_code = MBEDTLS_EXIT_SUCCESS;
    
    exit:
        mbedtls_mpi_free( &N ); mbedtls_mpi_free( &E );
        mbedtls_ctr_drbg_free( &ctr_drbg );
        mbedtls_entropy_free( &entropy );
        mbedtls_rsa_free( &rsa );
    
    #if defined(_WIN32)
        mbedtls_printf( "  + Press Enter to exit this program.\n" );
        fflush( stdout ); getchar();
    #endif
    
        return( exit_code );
    }
    #endif /* MBEDTLS_BIGNUM_C && MBEDTLS_RSA_C && MBEDTLS_ENTROPY_C &&
              MBEDTLS_FS_IO && MBEDTLS_CTR_DRBG_C */

     RSA算法,解密算法应用,参考路径mbedtls/programs/pkey/rsa_decrypt.c

    /*
     *  RSA simple decryption program
     *
     *  Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
     *  SPDX-License-Identifier: Apache-2.0
     *
     *  Licensed under the Apache License, Version 2.0 (the "License"); you may
     *  not use this file except in compliance with the License.
     *  You may obtain a copy of the License at
     *
     *  http://www.apache.org/licenses/LICENSE-2.0
     *
     *  Unless required by applicable law or agreed to in writing, software
     *  distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
     *  WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     *  See the License for the specific language governing permissions and
     *  limitations under the License.
     *
     *  This file is part of mbed TLS (https://tls.mbed.org)
     */
    
    #if !defined(MBEDTLS_CONFIG_FILE)
    #include "mbedtls/config.h"
    #else
    #include MBEDTLS_CONFIG_FILE
    #endif
    
    #if defined(MBEDTLS_PLATFORM_C)
    #include "mbedtls/platform.h"
    #else
    #include <stdio.h>
    #include <stdlib.h>
    #define mbedtls_printf       printf
    #define mbedtls_exit         exit
    #define MBEDTLS_EXIT_SUCCESS EXIT_SUCCESS
    #define MBEDTLS_EXIT_FAILURE EXIT_FAILURE
    #endif /* MBEDTLS_PLATFORM_C */
    
    #if defined(MBEDTLS_BIGNUM_C) && defined(MBEDTLS_RSA_C) && \
        defined(MBEDTLS_FS_IO) && defined(MBEDTLS_ENTROPY_C) && \
        defined(MBEDTLS_CTR_DRBG_C)
    #include "mbedtls/rsa.h"
    #include "mbedtls/entropy.h"
    #include "mbedtls/ctr_drbg.h"
    
    #include <string.h>
    
    #endif
    
    #if !defined(MBEDTLS_BIGNUM_C) || !defined(MBEDTLS_RSA_C) ||  \
        !defined(MBEDTLS_FS_IO) || !defined(MBEDTLS_ENTROPY_C) || \
        !defined(MBEDTLS_CTR_DRBG_C)
    int main( void )
    {
        mbedtls_printf("MBEDTLS_BIGNUM_C and/or MBEDTLS_RSA_C and/or "
               "MBEDTLS_FS_IO and/or MBEDTLS_ENTROPY_C and/or "
               "MBEDTLS_CTR_DRBG_C not defined.\n");
        return( 0 );
    }
    #else
    int main( int argc, char *argv[] )
    {
        FILE *f;
        int ret = 1;
        int exit_code = MBEDTLS_EXIT_FAILURE;
        int c;
        size_t i;
        mbedtls_rsa_context rsa;
        mbedtls_mpi N, P, Q, D, E, DP, DQ, QP;
        mbedtls_entropy_context entropy;
        mbedtls_ctr_drbg_context ctr_drbg;
        unsigned char result[1024];
        unsigned char buf[512];
        const char *pers = "rsa_decrypt";
        ((void) argv);
    
        memset(result, 0, sizeof( result ) );
    
        if( argc != 1 )
        {
            mbedtls_printf( "usage: rsa_decrypt\n" );
    
    #if defined(_WIN32)
            mbedtls_printf( "\n" );
    #endif
    
            mbedtls_exit( exit_code );
        }
    
        mbedtls_printf( "\n  . Seeding the random number generator..." );
        fflush( stdout );
    
        mbedtls_rsa_init( &rsa, MBEDTLS_RSA_PKCS_V15, 0 );
        mbedtls_ctr_drbg_init( &ctr_drbg );
        mbedtls_entropy_init( &entropy );
        mbedtls_mpi_init( &N ); mbedtls_mpi_init( &P ); mbedtls_mpi_init( &Q );
        mbedtls_mpi_init( &D ); mbedtls_mpi_init( &E ); mbedtls_mpi_init( &DP );
        mbedtls_mpi_init( &DQ ); mbedtls_mpi_init( &QP );
    
        ret = mbedtls_ctr_drbg_seed( &ctr_drbg, mbedtls_entropy_func,
                                            &entropy, (const unsigned char *) pers,
                                            strlen( pers ) );
        if( ret != 0 )
        {
            mbedtls_printf( " failed\n  ! mbedtls_ctr_drbg_seed returned %d\n",
                            ret );
            goto exit;
        }
    
        mbedtls_printf( "\n  . Reading private key from rsa_priv.txt" );
        fflush( stdout );
    
        if( ( f = fopen( "rsa_priv.txt", "rb" ) ) == NULL )
        {
            mbedtls_printf( " failed\n  ! Could not open rsa_priv.txt\n" \
                    "  ! Please run rsa_genkey first\n\n" );
            goto exit;
        }
    
        if( ( ret = mbedtls_mpi_read_file( &N , 16, f ) )  != 0 ||
            ( ret = mbedtls_mpi_read_file( &E , 16, f ) )  != 0 ||
            ( ret = mbedtls_mpi_read_file( &D , 16, f ) )  != 0 ||
            ( ret = mbedtls_mpi_read_file( &P , 16, f ) )  != 0 ||
            ( ret = mbedtls_mpi_read_file( &Q , 16, f ) )  != 0 ||
            ( ret = mbedtls_mpi_read_file( &DP , 16, f ) ) != 0 ||
            ( ret = mbedtls_mpi_read_file( &DQ , 16, f ) ) != 0 ||
            ( ret = mbedtls_mpi_read_file( &QP , 16, f ) ) != 0 )
        {
            mbedtls_printf( " failed\n  ! mbedtls_mpi_read_file returned %d\n\n",
                            ret );
            fclose( f );
            goto exit;
        }
        fclose( f );
    
        if( ( ret = mbedtls_rsa_import( &rsa, &N, &P, &Q, &D, &E ) ) != 0 )
        {
            mbedtls_printf( " failed\n  ! mbedtls_rsa_import returned %d\n\n",
                            ret );
            goto exit;
        }
    
        if( ( ret = mbedtls_rsa_complete( &rsa ) ) != 0 )
        {
            mbedtls_printf( " failed\n  ! mbedtls_rsa_complete returned %d\n\n",
                            ret );
            goto exit;
        }
    
        /*
         * Extract the RSA encrypted value from the text file
         */
        if( ( f = fopen( "result-enc.txt", "rb" ) ) == NULL )
        {
            mbedtls_printf( "\n  ! Could not open %s\n\n", "result-enc.txt" );
            goto exit;
        }
    
        i = 0;
    
        while( fscanf( f, "%02X", &c ) > 0 &&
               i < (int) sizeof( buf ) )
            buf[i++] = (unsigned char) c;
    
        fclose( f );
    
        if( i != rsa.len )
        {
            mbedtls_printf( "\n  ! Invalid RSA signature format\n\n" );
            goto exit;
        }
    
        /*
         * Decrypt the encrypted RSA data and print the result.
         */
        mbedtls_printf( "\n  . Decrypting the encrypted data" );
        fflush( stdout );
    
        ret = mbedtls_rsa_pkcs1_decrypt( &rsa, mbedtls_ctr_drbg_random,
                                                &ctr_drbg, MBEDTLS_RSA_PRIVATE, &i,
                                                buf, result, 1024 );
        if( ret != 0 )
        {
            mbedtls_printf( " failed\n  ! mbedtls_rsa_pkcs1_decrypt returned %d\n\n",
                            ret );
            goto exit;
        }
    
        mbedtls_printf( "\n  . OK\n\n" );
    
        mbedtls_printf( "The decrypted result is: '%s'\n\n", result );
    
        exit_code = MBEDTLS_EXIT_SUCCESS;
    
    exit:
        mbedtls_ctr_drbg_free( &ctr_drbg );
        mbedtls_entropy_free( &entropy );
        mbedtls_rsa_free( &rsa );
        mbedtls_mpi_free( &N ); mbedtls_mpi_free( &P ); mbedtls_mpi_free( &Q );
        mbedtls_mpi_free( &D ); mbedtls_mpi_free( &E ); mbedtls_mpi_free( &DP );
        mbedtls_mpi_free( &DQ ); mbedtls_mpi_free( &QP );
    
    #if defined(_WIN32)
        mbedtls_printf( "  + Press Enter to exit this program.\n" );
        fflush( stdout ); getchar();
    #endif
    
        return( exit_code );
    }
    #endif /* MBEDTLS_BIGNUM_C && MBEDTLS_RSA_C && MBEDTLS_FS_IO */

    使用示例:(默认使用生成2048比特长度的密钥,PKCS1V1_5填充方式)

     

    中国剩余定理CRT加速对RSA性能的影响研究

    mbedtls提供了性能测试工具,可查看指定算法性能,应用工具的实现代码位于/programs/test/benchmark.c,命令:benchmark,在mbetls配置文件中(mbedtls/include/mbedtls/config.h),可通过MBEDTLS_RSA_NO_CRT宏定义打开或关闭CRT加速,默认开启

    可以看到,使能CRT加速后私钥解密的性能有明显提升,而CRT对公钥加密的影响不明显。看上面RSA-2048私钥解密,未开启CRT加速的情况下私钥解密速度为每秒92次,开启CRT加速后解密速度提升至每秒247次

    展开全文
  • 由于 RSA算法加密解密速度要比对称算法速度慢很多,在实际应用中,通常采取如下: 1.数据本身加密和解密使用对称加密算法(AES)。 2.用RSA算法加密并传输对称算法所需密钥。 参考博客: iOS使用RSA加密 IOS...

    返回上级目录:iOS面试和知识点整理

    RSA应用场景

    由于 RSA算法的加密解密速度要比对称算法速度慢很多,在实际应用中,通常采取如下:
    1.数据本身的加密和解密使用对称加密算法(AES)。
    2.用RSA算法加密并传输对称算法所需的密钥。

    参考:iOS使用RSA加密

    RSA加密、签名区别

    简单的说,加密是为了防止信息被泄露,而签名是为了防止信息被篡改。

    参考:RSA加密、解密、签名、验签的原理及方法

    RSA的公钥和私钥到底哪个才是用来加密和哪个用来解密?

    公钥和私钥都可用于加密和解密。但是不同场景使用不同的密钥来加密。

    1、私钥用于签名、公钥用于验签

    签名和加密作用不同,签名并不是为了保密,而是为了保证这个签名是由特定的某个人签名的,而不是被其它人伪造的签名,所以私钥的私有性就适合用在签名用途上。

    私钥签名后,只能由对应的公钥解密,公钥又是公开的(很多人可持有),所以这些人拿着公钥来解密,解密成功后就能判断出是持有私钥的人做的签名,验证了身份合法性。

    2、公钥用于加密、私钥用于解密,这才能起到加密作用

    因为公钥是公开的,很多人可以持有公钥。若用私钥加密,那所有持有公钥的人都可以进行解密,这是不安全的!

    若用公钥加密,那只能由私钥解密,而私钥是私有不公开的,只能由特定的私钥持有人解密,保证的数据的安全性。

    参考:rsa公钥和私钥到底哪个才是用来加密,哪个用来解密?

    其他参考:
    iOS之RSA加密解密与后台之间的双向加密详解

    展开全文
  • 1、如何生成 RSA 公钥和私钥 第一步: 随机选择两个不相等质数 p 和 q 爱丽丝选择了 61 和 53,这两个质数越大,就越难破解。 第二步: ...计算 p 和 q 乘积 n ...爱丽丝就把 61 和 53 相乘:n = 61×...实际应用...
  • java 非对称加密(公钥加密)

    千次阅读 2012-05-16 11:15:12
    实际应用中单单只有对称加密是不够的,更多的时候是对称加密与非对称加密结合使用,非对称加密(公钥加密)特点速度慢、加密和解密的钥匙不相同,加密的方式是:  * 公钥加密-私钥解密  * 私钥加密-公钥解密...
  • 引言:去年阅读了《JAVA加密与解密的艺术...2、摘要、对称加密、非对称加密的区别 3、具体实现代码 JAVA安全领域的组成部分 Java安全领域总共分为四个部分: JCA(Java加密体系结构):基本的加密框架,如证书、...
  • 本文不对具体算法做深入研究,只是讲解各种安全算法原理和使用场景。 一、数据校验算法 数据校验,是为保护数据完整性,用一种指定算法对原始数据计算出一个校验值。当接收方用同样算法再算一次校验值...
  • 搞懂 非对称秘钥加密

    2020-12-03 18:34:14
    公开秘钥加密 Public Key Cryptography,私有秘钥加密解密所用同一秘钥不同,公开秘钥加密和解密所用秘钥是不同,也称非对称秘钥加密法。 借助秘钥生成器生成秘钥A和秘钥B,两把秘钥在数学上相关,被称作秘钥...
  • 主要内容:GPG加密解密基本操作少量应用。 简介 安装 生成密钥操作过程 对密钥一些操作 查看密钥 导出密钥 导入密钥 注销密钥 删除密钥 编辑密钥 签名 修改密码 等…… 加密文件 ...
  • 常用加密算法的应用

    2019-05-23 08:52:07
    文章目录基本概念密码体制密码破译加密算法对称加密算法非对称加密算法(公钥算法)公钥算法的应用Hash函数(散列函数或摘要函数)Hash函数的应用加密方式流密码参考文献 实际工作和开发过程中,网络通信过程中数据...
  • Java加密与解密艺术

    2011-12-22 10:51:20
    综合应用篇既细致地讲解了加密技术对数字证书和SSL/TLS协议的应用,又以示例的方式讲解了加密与解密技术在网络中的实际应用,极具实践指导性。 Java开发者将通过本书掌握密码学和Java加密与解密技术的所有细节;...
  • java加密与解密艺术 -- 笔记

    千次阅读 2016-02-15 14:59:08
     这几章主要介绍了一些为什么要加密,加密的历史原因以及演变过程,并介绍了几种常见的加密算法,画出了对称与非对称加密实际应用中的思维导图。  (了解到加密技术分为对称加密,非对称加密,单向加密(散列...
  • 采用了分析比较方法,首先研究了目前常用对称加密算法DES以及非对称加密算法RSA,然后分析比较了它们优缺点,进而综合安全性和效率设计出适合于在实际工程中应用的RSA、DES混合加密算法,最后结合实际JAVA...
  • 全书包含3个部分,基础篇对Java企业级应用的安全知识、密码学核心知识...综合应用篇既细致地讲解了加密技术对数字证书和SSL/TLS协议的应用,又以示例的方式讲解了加密与解密技术在网络中的实际应用,极具实践指导性。
  • JSON 接口如何实现 RSA 非对称签名

    千次阅读 2018-08-14 00:43:35
    现在互联网中很多系统都是分布式的,系统之间都需要进行数据传输。而且很多数据都是很私密的,是不能够被别人窃取的。所以就很有必要对其进行加密...RSA 非对称加密在代码中的实际应用。 数据加密与 HTTPS 区别。 ...
  • 综合应用篇(第10~12章)既细致地讲解了加密技术对数字证书和SSL/TLS协议的应用,又以示例的方式讲解了加密与解密技术在网络中的实际应用,极具实践指导性。  Java开发者将通过本书掌握密码学和Java加密/解密技术...
  • 软考——加密与认证技术

    千次阅读 热门讨论 2015-10-20 20:12:26
    一、加密技术1、对称加密:文件加密和解密使用相同密钥2、非对称加密:有两个密钥,公开密钥和私有密钥。如果用公开密钥对数据进行加密,只有用对应私有密钥才能解密;如果用私有密钥对数据进行加密,那么只有...
  • 前言:本文主要讲述RSA的加解密原理基本过程,整理常见的RSA破解手段,以及如何将原理应用到CTF等相关赛事或实际工作中。...RSA是一种非对称加密算法,是第一种能同时应用于数字签名和加密的算法。RSA的安全...
  • Go 加密解密算法总结

    2020-09-23 14:53:39
    非对称加密(公钥加密):指加密和解密使用不同密钥加密算法,也称为公私钥加密。具体算法主要有RSA、Elgamal、背包算法、Rabin、D-H、ECC(椭圆曲线加密算法)。 数字签名:数字签名是非对称密钥加密技术数字摘要...
  • RSA公钥加密算法

    2014-12-02 10:34:46
    公钥加密或说非对称加密其作用已经不言而喻,在实际中已经得到大量应用,比如HTTPS证书,其中便包含了网站的公钥信息。非对称加密与对称加密最大的区别是,加密与解密使用不同的密钥,通过公钥加密的内容只有通过...
  • c# 加密和解密相关代码

    热门讨论 2011-09-06 11:04:59
    数据的加密与解密 文件的加密与解密 第 章 加密与解密技术 第19章 加密与解密技术 829 19.1 数据的加密与解密 实例571 异或算法对数字进行加密与解密 光盘位置:光盘\MR\19\571 中级 趣味指数: 实 例说明 在实现...
  • [SSL]公钥私钥典型应用

    千次阅读 2013-07-15 14:26:48
    1、关于公钥和私钥  公钥和私钥或者称非对称密钥和对称密钥是密码体制的两种方式。私钥体制指加解密密钥相同或彼此容易推出,因此加解密密钥都是保密的。...2、关于加密和签名的实际应用  在实际加密应用

空空如也

空空如也

1 2 3 4
收藏数 70
精华内容 28
关键字:

对称加密与非对称加密的实际应用